GroundMaskElevationDetector.java

  1. /* Copyright 2002-2013 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.propagation.events;

  19. import java.util.Arrays;
  20. import java.util.Comparator;

  22. import org.apache.commons.math3.util.FastMath;
  23. import org.apache.commons.math3.util.MathUtils;
  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.errors.OrekitMessages;
  26. import org.orekit.frames.TopocentricFrame;
  27. import org.orekit.propagation.SpacecraftState;
  28. import org.orekit.propagation.events.handlers.EventHandler;
  29. import org.orekit.propagation.events.handlers.StopOnDecreasing;

  31. /** Finder for satellite azimuth-elevation events with respect to a mask.
  32.  * <p>This class finds elevation events (i.e. satellite raising and setting) with
  33.  * respect to an azimuth-elevation mask.</p>
  34.  * <p>An azimuth-elevation mask defines the physical horizon for a local point,
  35.  * origin of some topocentric frame.</p>
  36.  * <p>Azimuth is defined according to {@link TopocentricFrame#getAzimuth(org.apache.commons.math3.geometry.euclidean.threed.Vector3D, org.orekit.frames.Frame, org.orekit.time.AbsoluteDate) getAzimuth}.
  37.  *  Elevation is defined according to {@link TopocentricFrame#getElevation(org.apache.commons.math3.geometry.euclidean.threed.Vector3D, org.orekit.frames.Frame, org.orekit.time.AbsoluteDate) getElevation}.</p>
  38.  * <p>The azimuth elevation mask must be supplied as a twodimensional array with
  39.  *  multiples lines of pairs of azimuth-elevation angles. First row will be filled with
  40.  *  azimuth values, second row with elevation values, as in the following snippet:
  41.  *  <pre>
  42.  *    double [][] mask = {
  43.  *                        {FastMathFastMath.toRadians(0),   FastMath.toRadians(10)},
  44.  *                        {FastMathFastMath.toRadians(45),  FastMath.toRadians(8)},
  45.  *                        {FastMathFastMath.toRadians(90),  FastMath.toRadians(6)},
  46.  *                        {FastMathFastMath.toRadians(135), FastMath.toRadians(4)},
  47.  *                        {FastMathFastMath.toRadians(180), FastMath.toRadians(5)},
  48.  *                        {FastMathFastMath.toRadians(225), FastMath.toRadians(6)},
  49.  *                        {FastMathFastMath.toRadians(270), FastMath.toRadians(8)},
  50.  *                        {FastMathFastMath.toRadians(315), FastMath.toRadians(9)}
  51.  *                       };
  52.  *  </pre>
  53.  * </p>
  54.  * <p>No assumption is made on azimuth values and ordering. The only restraint is
  55.  * that only one elevation value can be associated to identical azimuths modulo 2PI.</p>
  56.  * <p>The default implementation behavior is to {@link
  57.  * org.orekit.propagation.events.handlers.EventHandler.Action#CONTINUE continue}
  58.  * propagation at raising and to {@link
  59.  * org.orekit.propagation.events.handlers.EventHandler.Action#STOP stop} propagation
  60.  * at setting. This can be changed by calling {@link #withHandler(EventHandler)}
  61.  * after construction.</p>
  62.  * @see org.orekit.propagation.Propagator#addEventDetector(EventDetector)
  63.  * @author Pascal Parraud
  64.  * @deprecated as of 6.1 replaced by {@link ElevationDetector}
  65.  */
  66. @Deprecated
  67. public class GroundMaskElevationDetector extends AbstractReconfigurableDetector<GroundMaskElevationDetector> {

  69.     /** Serializable UID. */
  70.     private static final long serialVersionUID = 20131118L;

  72.     /** Azimuth-elevation mask. */
  73.     private final double[][] azelmask;

  75.     /** Topocentric frame in which azimuth and elevation should be evaluated. */
  76.     private final TopocentricFrame topo;

  78.     /** Build a new azimuth-elevation detector.
  79.      *  <p>This simple constructor takes default values for maximal checking
  80.      *   interval ({@link #DEFAULT_MAXCHECK}) and convergence threshold
  81.      *   ({@link #DEFAULT_THRESHOLD}).</p>
  82.      * @param azimelev azimuth-elevation mask (rad)
  83.      * @param topo topocentric frame in which elevation should be evaluated
  84.      * @exception IllegalArgumentException if azimuth-elevation mask is not supported
  85.      */
  86.     public GroundMaskElevationDetector(final double[][] azimelev, final TopocentricFrame topo) {
  87.         this(DEFAULT_MAXCHECK, DEFAULT_THRESHOLD, azimelev, topo);
  88.     }

  90.     /** Build a new azimuth-elevation detector.
  91.      * <p>This constructor takes default value for convergence threshold
  92.      * ({@link #DEFAULT_THRESHOLD}).</p>
  93.      * <p>The maximal interval between elevation checks should
  94.      * be smaller than the half duration of the minimal pass to handle,
  95.      * otherwise some short passes could be missed.</p>
  96.      * @param maxCheck maximal checking interval (s)
  97.      * @param azimelev azimuth-elevation mask (rad)
  98.      * @param topo topocentric frame in which elevation should be evaluated
  99.      * @exception IllegalArgumentException if azimuth-elevation mask is not supported
  100.      */
  101.     public GroundMaskElevationDetector(final double maxCheck,
  102.                                        final double[][] azimelev,
  103.                                        final TopocentricFrame topo) {
  104.         this(maxCheck, DEFAULT_THRESHOLD, azimelev, topo);
  105.     }

  107.     /** Build a new azimuth-elevation detector.
  108.      * <p>The maximal interval between elevation checks should
  109.      * be smaller than the half duration of the minimal pass to handle,
  110.      * otherwise some short passes could be missed.</p>
  111.      * @param maxCheck maximal checking interval (s)
  112.      * @param threshold convergence threshold (s)
  113.      * @param azimelev azimuth-elevation mask (rad)
  114.      * @param topo topocentric frame in which elevation should be evaluated
  115.      * @exception IllegalArgumentException if azimuth-elevation mask is not supported
  116.      */
  117.     public GroundMaskElevationDetector(final double maxCheck, final double threshold,
  118.                                        final double[][] azimelev, final TopocentricFrame topo) {
  119.         this(maxCheck, threshold, DEFAULT_MAX_ITER,
  120.              new StopOnDecreasing<GroundMaskElevationDetector>(),
  121.              azimelev, topo);
  122.     }

  124.     /** Private constructor with full parameters.
  125.      * <p>
  126.      * This constructor is private as users are expected to use the builder
  127.      * API with the various {@code withXxx()} methods to set up the instance
  128.      * in a readable manner without using a huge amount of parameters.
  129.      * </p>
  130.      * @param maxCheck maximum checking interval (s)
  131.      * @param threshold convergence threshold (s)
  132.      * @param maxIter maximum number of iterations in the event time search
  133.      * @param handler event handler to call at event occurrences
  134.      * @param azimelev azimuth-elevation mask (rad)
  135.      * @param topo topocentric frame in which elevation should be evaluated
  136.      * @since 6.1
  137.      */
  138.     private GroundMaskElevationDetector(final double maxCheck, final double threshold,
  139.                                         final int maxIter, final EventHandler<GroundMaskElevationDetector> handler,
  140.                                         final double[][] azimelev,
  141.                                         final TopocentricFrame topo) {
  142.         super(maxCheck, threshold, maxIter, handler);
  143.         this.azelmask = checkMask(azimelev);
  144.         this.topo     = topo;
  145.     }

  147.     /** {@inheritDoc} */
  148.     @Override
  149.     protected GroundMaskElevationDetector create(final double newMaxCheck, final double newThreshold,
  150.                                                  final int newMaxIter, final EventHandler<GroundMaskElevationDetector> newHandler) {
  151.         return new GroundMaskElevationDetector(newMaxCheck, newThreshold, newMaxIter, newHandler,
  152.                                                azelmask, topo);
  153.     }

  155.     /** Get the topocentric frame.
  156.      * @return the topocentric frame
  157.      */
  158.     public TopocentricFrame getTopocentricFrame() {
  159.         return topo;
  160.     }

  162.     /** Compute the value of the switching function.
  163.      * This function measures the difference between the current elevation and the
  164.      * elevation for current azimuth interpolated from azimuth-elevation mask.
  165.      * @param s the current state information: date, kinematics, attitude
  166.      * @return value of the switching function
  167.      * @exception OrekitException if some specific error occurs
  168.      */
  169.     public double g(final SpacecraftState s) throws OrekitException {
  170.         final double azimuth = topo.getAzimuth(s.getPVCoordinates().getPosition(), s.getFrame(), s.getDate());
  171.         return topo.getElevation(s.getPVCoordinates().getPosition(), s.getFrame(), s.getDate()) - getElevation(azimuth);
  172.     }

  174.     /** Get the interpolated elevation for a given azimuth according to the mask.
  175.      * @param azimuth azimuth (rad)
  176.      * @return elevation angle (rad)
  177.      */
  178.     public double getElevation(final double azimuth) {
  179.         double elevation = 0.0;
  180.         boolean fin = false;
  181.         for (int i = 1; i < azelmask.length & !fin; i++) {
  182.             if (azimuth <= azelmask[i][0]) {
  183.                 fin = true;
  184.                 final double azd = azelmask[i - 1][0];
  185.                 final double azf = azelmask[i][0];
  186.                 final double eld = azelmask[i - 1][1];
  187.                 final double elf = azelmask[i][1];
  188.                 elevation = eld + (azimuth - azd) * (elf - eld) / (azf - azd);
  189.             }
  190.         }
  191.         return elevation;
  192.     }

  194.     /** Checking and ordering the azimuth-elevation tabulation.
  195.      * @param azimelev azimuth-elevation tabulation to be checked and ordered
  196.      * @return ordered azimuth-elevation tabulation ordered
  197.      */
  198.     private static double[][] checkMask(final double[][] azimelev) {

  200.         /* Copy of the given mask */
  201.         final double[][] mask = new double[azimelev.length + 2][azimelev[0].length];
  202.         for (int i = 0; i < azimelev.length; i++) {
  203.             System.arraycopy(azimelev[i], 0, mask[i + 1], 0, azimelev[i].length);
  204.             /* Reducing azimuth between 0 and 2*Pi */
  205.             mask[i + 1][0] = MathUtils.normalizeAngle(mask[i + 1][0], FastMath.PI);
  206.         }

  208.         /* Sorting the mask with respect to azimuth */
  209.         Arrays.sort(mask, 1, mask.length - 1, new Comparator<double[]>() {
  210.             public int compare(final double[] d1, final double[] d2) {
  211.                 return Double.compare(d1[0], d2[0]);
  212.             }
  213.         });

  215.         /* Extending the mask in order to cover [0, 2PI] in azimuth */
  216.         mask[0][0] = mask[mask.length - 2][0] - MathUtils.TWO_PI;
  217.         mask[0][1] = mask[mask.length - 2][1];
  218.         mask[mask.length - 1][0] = mask[1][0] + MathUtils.TWO_PI;
  219.         mask[mask.length - 1][1] = mask[1][1];

  221.         /* Checking the sorted mask: same azimuth modulo 2PI must have same elevation */
  222.         for (int i = 1; i < mask.length; i++) {
  223.             if (Double.compare(mask[i - 1][0], mask[i][0]) == 0) {
  224.                 if (Double.compare(mask[i - 1][1], mask[i][1]) != 0) {
  225.                     throw OrekitException.createIllegalArgumentException(OrekitMessages.UNEXPECTED_TWO_ELEVATION_VALUES_FOR_ONE_AZIMUTH, mask[i - 1][1], mask[i][1], mask[i][0]);
  226.                 }
  227.             }
  228.         }

  230.         return mask;
  231.     }

  233. }
Created with JaCoCo 0.6.3.201306030806