ImpulseManeuver.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.forces.maneuvers;

  19. import java.util.Map;

  21. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  22. import org.hipparchus.util.FastMath;
  23. import org.orekit.attitudes.Attitude;
  24. import org.orekit.attitudes.AttitudeProvider;
  25. import org.orekit.errors.OrekitException;
  26. import org.orekit.orbits.CartesianOrbit;
  27. import org.orekit.propagation.SpacecraftState;
  28. import org.orekit.propagation.events.AbstractDetector;
  29. import org.orekit.propagation.events.EventDetector;
  30. import org.orekit.propagation.events.handlers.EventHandler;
  31. import org.orekit.time.AbsoluteDate;
  32. import org.orekit.utils.Constants;
  33. import org.orekit.utils.PVCoordinates;

  35. /** Impulse maneuver model.
  36.  * <p>This class implements an impulse maneuver as a discrete event
  37.  * that can be provided to any {@link org.orekit.propagation.Propagator
  38.  * Propagator}.</p>
  39.  * <p>The maneuver is triggered when an underlying event generates a
  40.  * {@link org.orekit.propagation.events.handlers.EventHandler.Action#STOP STOP} event,
  41.  * in which case this class will generate a {@link
  42.  * org.orekit.propagation.events.handlers.EventHandler.Action#RESET_STATE RESET_STATE}
  43.  * event (the stop event from the underlying object is therefore filtered out).
  44.  * In the simple cases, the underlying event detector may be a basic
  45.  * {@link org.orekit.propagation.events.DateDetector date event}, but it
  46.  * can also be a more elaborate {@link
  47.  * org.orekit.propagation.events.ApsideDetector apside event} for apogee
  48.  * maneuvers for example.</p>
  49.  * <p>The maneuver is defined by a single velocity increment in satellite
  50.  * frame. The current attitude of the spacecraft, defined by the current
  51.  * spacecraft state, will be used to compute the velocity direction in
  52.  * inertial frame. A typical case for tangential maneuvers is to use a
  53.  * {@link org.orekit.attitudes.LofOffset LOF aligned} attitude provider for state propagation and a
  54.  * velocity increment along the +X satellite axis.</p>
  55.  * <p>Beware that the triggering event detector must behave properly both
  56.  * before and after maneuver. If for example a node detector is used to trigger
  57.  * an inclination maneuver and the maneuver change the orbit to an equatorial one,
  58.  * the node detector will fail just after the maneuver, being unable to find a
  59.  * node on an equatorial orbit! This is a real case that has been encountered
  60.  * during validation ...</p>
  61.  * @see org.orekit.propagation.Propagator#addEventDetector(EventDetector)
  62.  * @param <T> class type for the generic version
  63.  * @author Luc Maisonobe
  64.  */
  65. public class ImpulseManeuver<T extends EventDetector> extends AbstractDetector<ImpulseManeuver<T>> {

  67.     /** Serializable UID. */
  68.     private static final long serialVersionUID = 20131118L;

  70.     /** The attitude to override during the maneuver, if set. */
  71.     private final AttitudeProvider attitudeOverride;

  73.     /** Triggering event. */
  74.     private final T trigger;

  76.     /** Velocity increment in satellite frame. */
  77.     private final Vector3D deltaVSat;

  79.     /** Specific impulse. */
  80.     private final double isp;

  82.     /** Engine exhaust velocity. */
  83.     private final double vExhaust;

  85.     /** Indicator for forward propagation. */
  86.     private boolean forward;

  88.     /** Build a new instance.
  89.      * @param trigger triggering event
  90.      * @param deltaVSat velocity increment in satellite frame
  91.      * @param isp engine specific impulse (s)
  92.      */
  93.     public ImpulseManeuver(final T trigger, final Vector3D deltaVSat, final double isp) {
  94.         this(trigger.getMaxCheckInterval(), trigger.getThreshold(),
  95.              trigger.getMaxIterationCount(), new Handler<T>(),
  96.              trigger, null, deltaVSat, isp);
  97.     }


  100.     /** Build a new instance.
  101.      * @param trigger triggering event
  102.      * @param attitudeOverride the attitude provider to use for the maneuver
  103.      * @param deltaVSat velocity increment in satellite frame
  104.      * @param isp engine specific impulse (s)
  105.      */
  106.     public ImpulseManeuver(final T trigger, final AttitudeProvider attitudeOverride, final Vector3D deltaVSat, final double isp) {
  107.         this(trigger.getMaxCheckInterval(), trigger.getThreshold(),
  108.              trigger.getMaxIterationCount(), new Handler<T>(),
  109.              trigger, attitudeOverride, deltaVSat, isp);
  110.     }

  112.     /** Private constructor with full parameters.
  113.      * <p>
  114.      * This constructor is private as users are expected to use the builder
  115.      * API with the various {@code withXxx()} methods to set up the instance
  116.      * in a readable manner without using a huge amount of parameters.
  117.      * </p>
  118.      * @param maxCheck maximum checking interval (s)
  119.      * @param threshold convergence threshold (s)
  120.      * @param maxIter maximum number of iterations in the event time search
  121.      * @param handler event handler to call at event occurrences
  122.      * @param trigger triggering event
  123.      * @param attitudeOverride the attitude provider to use for the maneuver
  124.      * @param deltaVSat velocity increment in satellite frame
  125.      * @param isp engine specific impulse (s)
  126.      * @since 6.1
  127.      */
  128.     private ImpulseManeuver(final double maxCheck, final double threshold,
  129.                             final int maxIter, final EventHandler<? super ImpulseManeuver<T>> handler,
  130.                             final T trigger, final AttitudeProvider attitudeOverride, final Vector3D deltaVSat,
  131.                             final double isp) {
  132.         super(maxCheck, threshold, maxIter, handler);
  133.         this.attitudeOverride = attitudeOverride;
  134.         this.trigger   = trigger;
  135.         this.deltaVSat = deltaVSat;
  136.         this.isp       = isp;
  137.         this.vExhaust  = Constants.G0_STANDARD_GRAVITY * isp;
  138.     }

  140.     /** {@inheritDoc} */
  141.     @Override
  142.     protected ImpulseManeuver<T> create(final double newMaxCheck, final double newThreshold,
  143.                                         final int newMaxIter, final EventHandler<? super ImpulseManeuver<T>> newHandler) {
  144.         return new ImpulseManeuver<T>(newMaxCheck, newThreshold, newMaxIter, newHandler,
  145.                                       trigger, attitudeOverride, deltaVSat, isp);
  146.     }

  148.     /** {@inheritDoc} */
  149.     public void init(final SpacecraftState s0, final AbsoluteDate t) {
  150.         forward = t.durationFrom(s0.getDate()) >= 0;
  151.     }

  153.     /** {@inheritDoc} */
  154.     public double g(final SpacecraftState s) throws OrekitException {
  155.         return trigger.g(s);
  156.     }

  158.     /**
  159.      * Get the Attitude Provider to use during maneuver.
  160.      * @return the attitude provider
  161.      */
  162.     public AttitudeProvider getAttitudeOverride() {
  163.         return attitudeOverride;
  164.     }

  166.     /** Get the triggering event.
  167.      * @return triggering event
  168.      */
  169.     public T getTrigger() {
  170.         return trigger;
  171.     }

  173.     /** Get the velocity increment in satellite frame.
  174.     * @return velocity increment in satellite frame
  175.     */
  176.     public Vector3D getDeltaVSat() {
  177.         return deltaVSat;
  178.     }

  180.     /** Get the specific impulse.
  181.     * @return specific impulse
  182.     */
  183.     public double getIsp() {
  184.         return isp;
  185.     }

  187.     /** Local handler.
  188.      * @param <T> class type for the generic version
  189.      */
  190.     private static class Handler<T extends EventDetector> implements EventHandler<ImpulseManeuver<T>> {

  192.         /** {@inheritDoc} */
  193.         public EventHandler.Action eventOccurred(final SpacecraftState s, final ImpulseManeuver<T> im,
  194.                                                  final boolean increasing)
  195.             throws OrekitException {

  197.             // filter underlying event
  198.             final EventHandler.Action underlyingAction = im.trigger.eventOccurred(s, increasing);

  200.             return (underlyingAction == Action.STOP) ? Action.RESET_STATE : Action.CONTINUE;

  202.         }

  204.         /** {@inheritDoc} */
  205.         @Override
  206.         public SpacecraftState resetState(final ImpulseManeuver<T> im, final SpacecraftState oldState)
  207.             throws OrekitException {

  209.             final AbsoluteDate date = oldState.getDate();
  210.             final AttitudeProvider override = im.getAttitudeOverride();
  211.             final Attitude attitude;

  213.             if (override == null) {
  214.                 attitude = oldState.getAttitude();
  215.             } else {
  216.                 attitude = override.getAttitude(oldState.getOrbit(), date, oldState.getFrame());
  217.             }

  219.             // convert velocity increment in inertial frame
  220.             final Vector3D deltaV = attitude.getRotation().applyInverseTo(im.deltaVSat);
  221.             final double sign     = im.forward ? +1 : -1;

  223.             // apply increment to position/velocity
  224.             final PVCoordinates oldPV = oldState.getPVCoordinates();
  225.             final PVCoordinates newPV =
  226.                             new PVCoordinates(oldPV.getPosition(),
  227.                                               new Vector3D(1, oldPV.getVelocity(), sign, deltaV));
  228.             final CartesianOrbit newOrbit =
  229.                     new CartesianOrbit(newPV, oldState.getFrame(), date, oldState.getMu());

  231.             // compute new mass
  232.             final double newMass = oldState.getMass() * FastMath.exp(-sign * deltaV.getNorm() / im.vExhaust);

  234.             // pack everything in a new state
  235.             SpacecraftState newState = new SpacecraftState(oldState.getOrbit().getType().convertType(newOrbit),
  236.                                                            attitude, newMass);
  237.             for (final Map.Entry<String, double[]> entry : oldState.getAdditionalStates().entrySet()) {
  238.                 newState = newState.addAdditionalState(entry.getKey(), entry.getValue());
  239.             }
  240.             return newState;


  243.         }

  245.     }

  247. }
Created with JaCoCo 0.7.9.201702052155