FieldAbstractPropagator.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (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;

  19. import java.util.ArrayList;
  20. import java.util.Collection;
  21. import java.util.Collections;
  22. import java.util.HashMap;
  23. import java.util.List;
  24. import java.util.Map;

  26. import org.hipparchus.Field;
  27. import org.hipparchus.RealFieldElement;
  28. import org.orekit.attitudes.AttitudeProvider;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitMessages;
  31. import org.orekit.frames.Frame;
  32. import org.orekit.propagation.events.FieldEventDetector;
  33. import org.orekit.propagation.sampling.FieldOrekitFixedStepHandler;
  34. import org.orekit.propagation.sampling.FieldOrekitStepHandler;
  35. import org.orekit.propagation.sampling.FieldOrekitStepNormalizer;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.time.FieldAbsoluteDate;
  38. import org.orekit.utils.TimeSpanMap;
  39. import org.orekit.utils.TimeStampedFieldPVCoordinates;

  41. /** Common handling of {@link Propagator} methods for analytical propagators.
  42.  * <p>
  43.  * This abstract class allows to provide easily the full set of {@link Propagator}
  44.  * methods, including all propagation modes support and discrete events support for
  45.  * any simple propagation method.
  46.  * </p>
  47.  * @author Luc Maisonobe
  48.  */
  49. public abstract class FieldAbstractPropagator<T extends RealFieldElement<T>> implements FieldPropagator<T> {

  51.     /** Propagation mode. */
  52.     private int mode;

  54.     /** Fixed step size. */
  55.     private T fixedStepSize;

  57.     /** Step handler. */
  58.     private FieldOrekitStepHandler<T> stepHandler;

  60.     /** Start date. */
  61.     private FieldAbsoluteDate<T> startDate;

  63.     /** Attitude provider. */
  64.     private AttitudeProvider attitudeProvider;

  66.     /** Additional state providers. */
  67.     private final List<FieldAdditionalStateProvider<T>> additionalStateProviders;

  69.     /** States managed by neither additional equations nor state providers. */
  70.     private final Map<String, TimeSpanMap<T[]>> unmanagedStates;

  72.     /** Field used.*/
  73.     private final Field<T> field;

  75.     /** Initial state. */
  76.     private FieldSpacecraftState<T> initialState;

  78.     /** Build a new instance.
  79.      * @param field setting the field
  80.      */
  81.     protected FieldAbstractPropagator(final Field<T> field) {
  82.         mode                     = SLAVE_MODE;
  83.         stepHandler              = null;
  84.         this.field               = field;
  85.         fixedStepSize            = field.getZero().add(Double.NaN);
  86.         additionalStateProviders = new ArrayList<>();
  87.         unmanagedStates          = new HashMap<>();
  88.     }

  90.     /** Set a start date.
  91.      * @param startDate start date
  92.      */
  93.     protected void setStartDate(final FieldAbsoluteDate<T> startDate) {
  94.         this.startDate = startDate;
  95.     }

  97.     /** Get the start date.
  98.      * @return start date
  99.      */
  100.     protected FieldAbsoluteDate<T> getStartDate() {
  101.         return startDate;
  102.     }

  104.     /**  {@inheritDoc} */
  105.     public AttitudeProvider getAttitudeProvider() {
  106.         return attitudeProvider;
  107.     }

  109.     /**  {@inheritDoc} */
  110.     public void setAttitudeProvider(final AttitudeProvider attitudeProvider) {
  111.         this.attitudeProvider = attitudeProvider;
  112.     }

  114.     /** Field getter.
  115.      * @return field used*/
  116.     public Field<T> getField() {
  117.         return field;
  118.     }

  120.     /** {@inheritDoc} */
  121.     public FieldSpacecraftState<T> getInitialState() {
  122.         return initialState;
  123.     }

  125.     /** {@inheritDoc} */
  126.     public int getMode() {
  127.         return mode;
  128.     }

  130.     /** {@inheritDoc} */
  131.     public Frame getFrame() {
  132.         return initialState.getFrame();
  133.     }

  135.     /** {@inheritDoc} */
  136.     public void resetInitialState(final FieldSpacecraftState<T> state) {
  137.         initialState = state;
  138.         setStartDate(state.getDate());
  139.     }

  141.     /** {@inheritDoc} */
  142.     public void setSlaveMode() {
  143.         mode          = SLAVE_MODE;
  144.         stepHandler   = null;
  145.         fixedStepSize = field.getZero().add(Double.NaN);
  146.     }

  148.     /** {@inheritDoc} */
  149.     public void setMasterMode(final T h,
  150.                               final FieldOrekitFixedStepHandler<T> handler) {
  151.         setMasterMode(new FieldOrekitStepNormalizer<>(h, handler));
  152.         fixedStepSize = h;
  153.     }

  155.     /** {@inheritDoc} */
  156.     public void setMasterMode(final FieldOrekitStepHandler<T> handler) {
  157.         mode          = MASTER_MODE;
  158.         stepHandler   = handler;
  159.         fixedStepSize = field.getZero().add(Double.NaN);
  160.     }

  162.     /** {@inheritDoc} */
  163.     public void setEphemerisMode() {
  164.         mode          = EPHEMERIS_GENERATION_MODE;
  165.         stepHandler   = null;
  166.         fixedStepSize = field.getZero().add(Double.NaN);
  167.     }

  169.     /** {@inheritDoc} */
  170.     public void addAdditionalStateProvider(final FieldAdditionalStateProvider<T> additionalStateProvider) {

  172.         // check if the name is already used
  173.         if (isAdditionalStateManaged(additionalStateProvider.getName())) {
  174.             // this additional state is already registered, complain
  175.             throw new OrekitException(OrekitMessages.ADDITIONAL_STATE_NAME_ALREADY_IN_USE,
  176.                                       additionalStateProvider.getName());
  177.         }

  179.         // this is really a new name, add it
  180.         additionalStateProviders.add(additionalStateProvider);

  182.     }

  184.     /** {@inheritDoc} */
  185.     public List<FieldAdditionalStateProvider<T>> getAdditionalStateProviders() {
  186.         return Collections.unmodifiableList(additionalStateProviders);
  187.     }

  189.     /** Update state by adding all additional states.
  190.      * @param original original state
  191.      * @return updated state, with all additional states included
  192.      * @see #addAdditionalStateProvider(FieldAdditionalStateProvider)
  193.      */
  194.     protected FieldSpacecraftState<T> updateAdditionalStates(final FieldSpacecraftState<T> original) {

  196.         // start with original state,
  197.         // which may already contain additional states, for example in interpolated ephemerides
  198.         FieldSpacecraftState<T> updated = original;

  200.         // update the states not managed by providers
  201.         for (final Map.Entry<String, TimeSpanMap<T[]>> entry : unmanagedStates.entrySet()) {
  202.             updated = updated.addAdditionalState(entry.getKey(),
  203.                                                  entry.getValue().get(original.getDate().toAbsoluteDate()));
  204.         }

  206.         // update the additional states managed by providers
  207.         for (final FieldAdditionalStateProvider<T> provider : additionalStateProviders) {

  209.             updated = updated.addAdditionalState(provider.getName(),
  210.                                                  provider.getAdditionalState(updated));
  211.         }

  213.         return updated;

  215.     }

  217.     /** {@inheritDoc} */
  218.     public boolean isAdditionalStateManaged(final String name) {
  219.         for (final FieldAdditionalStateProvider<T> provider : additionalStateProviders) {
  220.             if (provider.getName().equals(name)) {
  221.                 return true;
  222.             }
  223.         }
  224.         return false;
  225.     }

  227.     /** {@inheritDoc} */
  228.     public String[] getManagedAdditionalStates() {
  229.         final String[] managed = new String[additionalStateProviders.size()];
  230.         for (int i = 0; i < managed.length; ++i) {
  231.             managed[i] = additionalStateProviders.get(i).getName();
  232.         }
  233.         return managed;
  234.     }

  236.     /** Get the fixed step size.
  237.      * @return fixed step size (or NaN if there are no fixed step size).
  238.      */
  239.     protected T getFixedStepSize() {
  240.         return fixedStepSize;
  241.     }

  243.     /** Get the step handler.
  244.      * @return step handler
  245.      */
  246.     protected FieldOrekitStepHandler<T> getStepHandler() {
  247.         return stepHandler;
  248.     }

  250.     /** {@inheritDoc} */
  251.     public abstract FieldBoundedPropagator<T> getGeneratedEphemeris();

  253.     /** {@inheritDoc} */
  254.     public abstract <D extends FieldEventDetector<T>> void addEventDetector(D detector);

  256.     /** {@inheritDoc} */
  257.     public abstract Collection<FieldEventDetector<T>> getEventsDetectors();

  259.     /** {@inheritDoc} */
  260.     public abstract void clearEventsDetectors();

  262.     /** {@inheritDoc} */
  263.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> target) {
  264.         if (startDate == null) {
  265.             startDate = getInitialState().getDate();
  266.         }
  267.         return propagate(startDate, target);
  268.     }

  270.     /** {@inheritDoc} */
  271.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final FieldAbsoluteDate<T> date, final Frame frame) {
  272.         return propagate(date).getPVCoordinates(frame);
  273.     }

  275.     /** Initialize propagation.
  276.      * @since 10.1
  277.      */
  278.     protected void initializePropagation() {

  280.         unmanagedStates.clear();

  282.         if (initialState != null) {
  283.             // there is an initial state
  284.             // (null initial states occur for example in interpolated ephemerides)
  285.             // copy the additional states present in initialState but otherwise not managed
  286.             for (final Map.Entry<String, T[]> initial : initialState.getAdditionalStates().entrySet()) {
  287.                 if (!isAdditionalStateManaged(initial.getKey())) {
  288.                     // this additional state is in the initial state, but is unknown to the propagator
  289.                     // we store it in a way event handlers may change it
  290.                     unmanagedStates.put(initial.getKey(), new TimeSpanMap<>(initial.getValue()));
  291.                 }
  292.             }
  293.         }
  294.     }

  296.     /** Notify about a state change.
  297.      * @param state new state
  298.      */
  299.     protected void stateChanged(final FieldSpacecraftState<T> state) {
  300.         final AbsoluteDate date    = state.getDate().toAbsoluteDate();
  301.         final boolean      forward = date.durationFrom(getStartDate().toAbsoluteDate()) >= 0.0;
  302.         for (final Map.Entry<String, T[]> changed : state.getAdditionalStates().entrySet()) {
  303.             final TimeSpanMap<T[]> tsm = unmanagedStates.get(changed.getKey());
  304.             if (tsm != null) {
  305.                 // this is an unmanaged state
  306.                 if (forward) {
  307.                     tsm.addValidAfter(changed.getValue(), date);
  308.                 } else {
  309.                     tsm.addValidBefore(changed.getValue(), date);
  310.                 }
  311.             }
  312.         }
  313.     }

  315. }
Created with JaCoCo 0.8.6.202009150832