PositionAngleDetector.java

  1. /* Copyright 2002-2018 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 org.hipparchus.util.FastMath;
  20. import org.hipparchus.util.MathUtils;
  21. import org.orekit.errors.OrekitException;
  22. import org.orekit.errors.OrekitIllegalArgumentException;
  23. import org.orekit.errors.OrekitInternalError;
  24. import org.orekit.errors.OrekitMessages;
  25. import org.orekit.orbits.CircularOrbit;
  26. import org.orekit.orbits.EquinoctialOrbit;
  27. import org.orekit.orbits.KeplerianOrbit;
  28. import org.orekit.orbits.OrbitType;
  29. import org.orekit.orbits.PositionAngle;
  30. import org.orekit.propagation.SpacecraftState;
  31. import org.orekit.propagation.events.handlers.EventHandler;
  32. import org.orekit.propagation.events.handlers.StopOnIncreasing;

  34. /** Detector for in-orbit position angle.
  35.  * <p>
  36.  * The detector is based on anomaly for {@link OrbitType#KEPLERIAN Keplerian}
  37.  * orbits, latitude argument for {@link OrbitType#CIRCULAR circular} orbits,
  38.  * or longitude argument for {@link OrbitType#EQUINOCTIAL equinoctial} orbits.
  39.  * It does not support {@link OrbitType#CARTESIAN Cartesian} orbits. The
  40.  * angles can be either {@link PositionAngle#TRUE true}, {link {@link PositionAngle#MEAN
  41.  * mean} or {@link PositionAngle#ECCENTRIC eccentric} angles.
  42.  * </p>
  43.  * @author Luc Maisonobe
  44.  * @since 7.1
  45.  */
  46. public class PositionAngleDetector extends AbstractDetector<PositionAngleDetector> {

  48.     /** Serializable UID. */
  49.     private static final long serialVersionUID = 20150825L;

  51.     /** Orbit type defining the angle type. */
  52.     private final OrbitType orbitType;

  54.     /** Type of position angle. */
  55.     private final PositionAngle positionAngle;

  57.     /** Fixed angle to be crossed. */
  58.     private final double angle;

  60.     /** Sign to apply for angle difference. */
  61.     private double sign;

  63.     /** Previous angle difference. */
  64.     private double previousDelta;

  66.     /** Build a new detector.
  67.      * <p>The new instance uses default values for maximal checking interval
  68.      * ({@link #DEFAULT_MAXCHECK}) and convergence threshold ({@link
  69.      * #DEFAULT_THRESHOLD}).</p>
  70.      * @param orbitType orbit type defining the angle type
  71.      * @param positionAngle type of position angle
  72.      * @param angle fixed angle to be crossed
  73.      * @exception OrekitIllegalArgumentException if orbit type is {@link OrbitType#CARTESIAN}
  74.      */
  75.     public PositionAngleDetector(final OrbitType orbitType, final PositionAngle positionAngle,
  76.                                  final double angle)
  77.         throws OrekitIllegalArgumentException {
  78.         this(DEFAULT_MAXCHECK, DEFAULT_THRESHOLD, orbitType, positionAngle, angle);
  79.     }

  81.     /** Build a detector.
  82.      * @param maxCheck maximal checking interval (s)
  83.      * @param threshold convergence threshold (s)
  84.      * @param orbitType orbit type defining the angle type
  85.      * @param positionAngle type of position angle
  86.      * @param angle fixed angle to be crossed
  87.      * @exception OrekitIllegalArgumentException if orbit type is {@link OrbitType#CARTESIAN}
  88.      */
  89.     public PositionAngleDetector(final double maxCheck, final double threshold,
  90.                                  final OrbitType orbitType, final PositionAngle positionAngle,
  91.                                  final double angle)
  92.         throws OrekitIllegalArgumentException {
  93.         this(maxCheck, threshold, DEFAULT_MAX_ITER, new StopOnIncreasing<PositionAngleDetector>(),
  94.              orbitType, positionAngle, angle);
  95.     }

  97.     /** Private constructor with full parameters.
  98.      * <p>
  99.      * This constructor is private as users are expected to use the builder
  100.      * API with the various {@code withXxx()} methods to set up the instance
  101.      * in a readable manner without using a huge amount of parameters.
  102.      * </p>
  103.      * @param maxCheck maximum checking interval (s)
  104.      * @param threshold convergence threshold (s)
  105.      * @param maxIter maximum number of iterations in the event time search
  106.      * @param handler event handler to call at event occurrences
  107.      * @param orbitType orbit type defining the angle type
  108.      * @param positionAngle type of position angle
  109.      * @param angle fixed angle to be crossed
  110.      * @exception OrekitIllegalArgumentException if orbit type is {@link OrbitType#CARTESIAN}
  111.      */
  112.     private PositionAngleDetector(final double maxCheck, final double threshold,
  113.                                      final int maxIter, final EventHandler<? super PositionAngleDetector> handler,
  114.                                      final OrbitType orbitType, final PositionAngle positionAngle,
  115.                                      final double angle)
  116.         throws OrekitIllegalArgumentException {
  117.         super(maxCheck, threshold, maxIter, handler);
  118.         if (orbitType == OrbitType.CARTESIAN) {
  119.             final String sep = ", ";
  120.             throw new OrekitIllegalArgumentException(OrekitMessages.ORBIT_TYPE_NOT_ALLOWED,
  121.                                                      orbitType,
  122.                                                      OrbitType.KEPLERIAN   + sep +
  123.                                                      OrbitType.CIRCULAR    + sep +
  124.                                                      OrbitType.EQUINOCTIAL);
  125.         }
  126.         this.orbitType     = orbitType;
  127.         this.positionAngle = positionAngle;
  128.         this.angle         = angle;
  129.         this.sign          = +1.0;
  130.         this.previousDelta = Double.NaN;
  131.     }

  133.     /** {@inheritDoc} */
  134.     @Override
  135.     protected PositionAngleDetector create(final double newMaxCheck, final double newThreshold,
  136.                                               final int newMaxIter,
  137.                                               final EventHandler<? super PositionAngleDetector> newHandler) {
  138.         return new PositionAngleDetector(newMaxCheck, newThreshold, newMaxIter, newHandler,
  139.                                          orbitType, positionAngle, angle);
  140.     }

  142.     /** Get the orbit type defining the angle type.
  143.      * @return orbit type defining the angle type
  144.      */
  145.     public OrbitType getOrbitType() {
  146.         return orbitType;
  147.     }

  149.     /** Get the type of position angle.
  150.      * @return type of position angle
  151.      */
  152.     public PositionAngle getPositionAngle() {
  153.         return positionAngle;
  154.     }

  156.     /** Get the fixed angle to be crossed (radians).
  157.      * @return fixed angle to be crossed (radians)
  158.      */
  159.     public double getAngle() {
  160.         return angle;
  161.     }

  163.     /** Compute the value of the detection function.
  164.      * <p>
  165.      * The value is the angle difference between the spacecraft and the fixed
  166.      * angle to be crossed, with some sign tweaks to ensure continuity.
  167.      * These tweaks imply the {@code increasing} flag in events detection becomes
  168.      * irrelevant here! As an example, the angle always increase in a Keplerian
  169.      * orbit, but this g function will increase and decrease so it
  170.      * will cross the zero value once per orbit, in increasing and decreasing
  171.      * directions on alternate orbits..
  172.      * </p>
  173.      * @param s the current state information: date, kinematics, attitude
  174.      * @return angle difference between the spacecraft and the fixed
  175.      * angle, with some sign tweaks to ensure continuity
  176.      * @exception OrekitException if some specific error occurs
  177.      */
  178.     public double g(final SpacecraftState s) throws OrekitException {

  180.         // get angle
  181.         final double currentAngle;
  182.         switch (orbitType) {
  183.             case KEPLERIAN:
  184.                 currentAngle = ((KeplerianOrbit) orbitType.convertType(s.getOrbit())).getAnomaly(positionAngle);
  185.                 break;
  186.             case CIRCULAR:
  187.                 currentAngle = ((CircularOrbit) orbitType.convertType(s.getOrbit())).getAlpha(positionAngle);
  188.                 break;
  189.             case EQUINOCTIAL:
  190.                 currentAngle = ((EquinoctialOrbit) orbitType.convertType(s.getOrbit())).getL(positionAngle);
  191.                 break;
  192.             default:
  193.                 // this should never happen as type was checked at construction
  194.                 throw new OrekitInternalError(null);
  195.         }

  197.         // angle difference
  198.         double delta = MathUtils.normalizeAngle(sign * (currentAngle - angle), 0.0);

  200.         // ensure continuity
  201.         if (FastMath.abs(delta - previousDelta) > FastMath.PI) {
  202.             sign  = -sign;
  203.             delta = MathUtils.normalizeAngle(sign * (currentAngle - angle), 0.0);
  204.         }
  205.         previousDelta = delta;

  207.         return delta;

  209.     }

  211. }
Created with JaCoCo 0.7.9.201702052155