FieldSpacecraftState.java

  1. /* Copyright 2002-2019 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;


  20. import java.util.ArrayList;
  21. import java.util.Collections;
  22. import java.util.HashMap;
  23. import java.util.List;
  24. import java.util.Map;
  25. import java.util.stream.Stream;

  27. import org.hipparchus.Field;
  28. import org.hipparchus.RealFieldElement;
  29. import org.hipparchus.analysis.interpolation.FieldHermiteInterpolator;
  30. import org.hipparchus.exception.LocalizedCoreFormats;
  31. import org.hipparchus.exception.MathIllegalArgumentException;
  32. import org.hipparchus.exception.MathIllegalStateException;
  33. import org.hipparchus.util.MathArrays;
  34. import org.orekit.attitudes.FieldAttitude;
  35. import org.orekit.attitudes.LofOffset;
  36. import org.orekit.errors.OrekitException;
  37. import org.orekit.errors.OrekitIllegalArgumentException;
  38. import org.orekit.errors.OrekitMessages;
  39. import org.orekit.frames.FieldTransform;
  40. import org.orekit.frames.Frame;
  41. import org.orekit.frames.LOFType;
  42. import org.orekit.orbits.FieldOrbit;
  43. import org.orekit.orbits.PositionAngle;
  44. import org.orekit.time.FieldAbsoluteDate;
  45. import org.orekit.time.FieldTimeInterpolable;
  46. import org.orekit.time.FieldTimeShiftable;
  47. import org.orekit.time.FieldTimeStamped;
  48. import org.orekit.utils.TimeStampedFieldPVCoordinates;


  51. /** This class is the representation of a complete state holding orbit, attitude
  52.  * and mass information at a given date.
  53.  *
  54.  * <p>It contains an {@link FieldOrbit orbital state} at a current
  55.  * {@link FieldAbsoluteDate} both handled by an {@link FieldOrbit}, plus the current
  56.  * mass and attitude. FieldOrbitand state are guaranteed to be consistent in terms
  57.  * of date and reference frame. The spacecraft state may also contain additional
  58.  * states, which are simply named double arrays which can hold any user-defined
  59.  * data.
  60.  * </p>
  61.  * <p>
  62.  * The state can be slightly shifted to close dates. This shift is based on
  63.  * a simple Keplerian model for orbit, a linear extrapolation for attitude
  64.  * taking the spin rate into account and no mass change. It is <em>not</em>
  65.  * intended as a replacement for proper orbit and attitude propagation but
  66.  * should be sufficient for either small time shifts or coarse accuracy.
  67.  * </p>
  68.  * <p>
  69.  * The instance {@code FieldSpacecraftState} is guaranteed to be immutable.
  70.  * </p>
  71.  * @see org.orekit.propagation.numerical.NumericalPropagator
  72.  * @author Fabien Maussion
  73.  * @author V&eacute;ronique Pommier-Maurussane
  74.  * @author Luc Maisonobe
  75.  */
  76. public class FieldSpacecraftState <T extends RealFieldElement<T>>
  77.     implements FieldTimeStamped<T>, FieldTimeShiftable<FieldSpacecraftState<T>, T>, FieldTimeInterpolable<FieldSpacecraftState<T>, T> {

  79.     /** Default mass. */
  80.     private static final double DEFAULT_MASS = 1000.0;

  82.     /**
  83.      * tolerance on date comparison in {@link #checkConsistency(FieldOrbit<T>, FieldAttitude<T>)}. 100 ns
  84.      * corresponds to sub-mm accuracy at LEO orbital velocities.
  85.      */
  86.     private static final double DATE_INCONSISTENCY_THRESHOLD = 100e-9;

  88.     /** Orbital state. */
  89.     private final FieldOrbit<T> orbit;

  91.     /** FieldAttitude<T>. */
  92.     private final FieldAttitude<T> attitude;

  94.     /** Current mass (kg). */
  95.     private final T mass;

  97.     /** Additional states. */
  98.     private final Map<String, T[]> additional;

  100.     /** Build a spacecraft state from orbit only.
  101.      * <p>FieldAttitude<T> and mass are set to unspecified non-null arbitrary values.</p>
  102.      * @param orbit the orbit
  103.      */
  104.     public FieldSpacecraftState(final FieldOrbit<T> orbit) {
  105.         this(orbit,
  106.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  107.              orbit.getA().getField().getZero().add(DEFAULT_MASS), null);
  108.     }

  110.     /** Build a spacecraft state from orbit and attitude provider.
  111.      * <p>Mass is set to an unspecified non-null arbitrary value.</p>
  112.      * @param orbit the orbit
  113.      * @param attitude attitude
  114.      * @exception IllegalArgumentException if orbit and attitude dates
  115.      * or frames are not equal
  116.      */
  117.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude)
  118.         throws IllegalArgumentException {
  119.         this(orbit, attitude, orbit.getA().getField().getZero().add(DEFAULT_MASS), null);
  120.     }

  122.     /** Create a new instance from orbit and mass.
  123.      * <p>FieldAttitude<T> law is set to an unspecified default attitude.</p>
  124.      * @param orbit the orbit
  125.      * @param mass the mass (kg)
  126.      */
  127.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final T mass) {
  128.         this(orbit,
  129.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  130.              mass, null);
  131.     }

  133.     /** Build a spacecraft state from orbit, attitude provider and mass.
  134.      * @param orbit the orbit
  135.      * @param attitude attitude
  136.      * @param mass the mass (kg)
  137.      * @exception IllegalArgumentException if orbit and attitude dates
  138.      * or frames are not equal
  139.      */
  140.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude, final T mass)
  141.         throws IllegalArgumentException {
  142.         this(orbit, attitude, mass, null);
  143.     }

  145.     /** Build a spacecraft state from orbit only.
  146.      * <p>FieldAttitude<T> and mass are set to unspecified non-null arbitrary values.</p>
  147.      * @param orbit the orbit
  148.      * @param additional additional states
  149.      */
  150.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final Map<String, T[]> additional) {
  151.         this(orbit,
  152.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  153.              orbit.getA().getField().getZero().add(DEFAULT_MASS), additional);
  154.     }

  156.     /** Build a spacecraft state from orbit and attitude provider.
  157.      * <p>Mass is set to an unspecified non-null arbitrary value.</p>
  158.      * @param orbit the orbit
  159.      * @param attitude attitude
  160.      * @param additional additional states
  161.      * @exception IllegalArgumentException if orbit and attitude dates
  162.      * or frames are not equal
  163.      */
  164.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude, final Map<String, T[]> additional)
  165.         throws IllegalArgumentException {
  166.         this(orbit, attitude, orbit.getA().getField().getZero().add(DEFAULT_MASS), additional);
  167.     }

  169.     /** Create a new instance from orbit and mass.
  170.      * <p>FieldAttitude<T> law is set to an unspecified default attitude.</p>
  171.      * @param orbit the orbit
  172.      * @param mass the mass (kg)
  173.      * @param additional additional states
  174.      */
  175.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final T mass, final Map<String, T[]> additional) {
  176.         this(orbit,
  177.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  178.              mass, additional);
  179.     }

  181.     /** Build a spacecraft state from orbit, attitude provider and mass.
  182.      * @param orbit the orbit
  183.      * @param attitude attitude
  184.      * @param mass the mass (kg)
  185.      * @param additional additional states (may be null if no additional states are available)
  186.      * @exception IllegalArgumentException if orbit and attitude dates
  187.      * or frames are not equal
  188.      */
  189.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude,
  190.                                 final T mass, final Map<String, T[]> additional)
  191.         throws IllegalArgumentException {
  192.         checkConsistency(orbit, attitude);
  193.         this.orbit      = orbit;
  194.         this.attitude   = attitude;
  195.         this.mass       = mass;


  198.         if (additional == null) {
  199.             this.additional = Collections.emptyMap();
  200.         } else {

  202.             this.additional = new HashMap<String, T[]>(additional.size());
  203.             for (final Map.Entry<String, T[]> entry : additional.entrySet()) {
  204.                 this.additional.put(entry.getKey(), entry.getValue().clone());
  205.             }
  206.         }
  207.     }

  209.     /** Convert a {@link SpacecraftState}.
  210.      * @param field field to which the elements belong
  211.      * @param state state to convert
  212.      */
  213.     public FieldSpacecraftState(final Field<T> field, final SpacecraftState state) {

  215.         final double[] stateD    = new double[6];
  216.         final double[] stateDotD = state.getOrbit().hasDerivatives() ? new double[6] : null;
  217.         state.getOrbit().getType().mapOrbitToArray(state.getOrbit(), PositionAngle.TRUE, stateD, stateDotD);
  218.         final T[] stateF    = MathArrays.buildArray(field, 6);
  219.         for (int i = 0; i < stateD.length; ++i) {
  220.             stateF[i]    = field.getZero().add(stateD[i]);
  221.         }
  222.         final T[] stateDotF;
  223.         if (stateDotD == null) {
  224.             stateDotF = null;
  225.         } else {
  226.             stateDotF = MathArrays.buildArray(field, 6);
  227.             for (int i = 0; i < stateDotD.length; ++i) {
  228.                 stateDotF[i] = field.getZero().add(stateDotD[i]);
  229.             }
  230.         }

  232.         final FieldAbsoluteDate<T> dateF = new FieldAbsoluteDate<>(field, state.getDate());

  234.         this.orbit    = state.getOrbit().getType().mapArrayToOrbit(stateF, stateDotF,
  235.                                                                    PositionAngle.TRUE,
  236.                                                                    dateF, state.getMu(), state.getFrame());
  237.         this.attitude = new FieldAttitude<>(field, state.getAttitude());
  238.         this.mass     = field.getZero().add(state.getMass());

  240.         final Map<String, double[]> additionalD = state.getAdditionalStates();
  241.         if (additionalD.isEmpty()) {
  242.             this.additional = Collections.emptyMap();
  243.         } else {
  244.             this.additional = new HashMap<String, T[]>(additionalD.size());
  245.             for (final Map.Entry<String, double[]> entry : additionalD.entrySet()) {
  246.                 final T[] array = MathArrays.buildArray(field, entry.getValue().length);
  247.                 for (int k = 0; k < array.length; ++k) {
  248.                     array[k] = field.getZero().add(entry.getValue()[k]);
  249.                 }
  250.                 this.additional.put(entry.getKey(), array);
  251.             }
  252.         }

  254.     }

  256.     /** Add an additional state.
  257.      * <p>
  258.      * {@link FieldSpacecraftState SpacecraftState} instances are immutable,
  259.      * so this method does <em>not</em> change the instance, but rather
  260.      * creates a new instance, which has the same orbit, attitude, mass
  261.      * and additional states as the original instance, except it also
  262.      * has the specified state. If the original instance already had an
  263.      * additional state with the same name, it will be overridden. If it
  264.      * did not have any additional state with that name, the new instance
  265.      * will have one more additional state than the original instance.
  266.      * </p>
  267.      * @param name name of the additional state
  268.      * @param value value of the additional state
  269.      * @return a new instance, with the additional state added
  270.      * @see #hasAdditionalState(String)
  271.      * @see #getAdditionalState(String)
  272.      * @see #getAdditionalStates()
  273.      */
  274.     @SafeVarargs
  275.     public final FieldSpacecraftState<T> addAdditionalState(final String name, final T... value) {
  276.         final Map<String, T[]> newMap = new HashMap<String, T[]>(additional.size() + 1);
  277.         newMap.putAll(additional);
  278.         newMap.put(name, value.clone());
  279.         return new FieldSpacecraftState<>(orbit, attitude, mass, newMap);
  280.     }

  282.     /** Check orbit and attitude dates are equal.
  283.      * @param orbitN the orbit
  284.      * @param attitudeN attitude
  285.      * @exception IllegalArgumentException if orbit and attitude dates
  286.      * are not equal
  287.      */
  288.     private void checkConsistency(final FieldOrbit<T> orbitN, final FieldAttitude<T> attitudeN)
  289.         throws IllegalArgumentException {
  290.         if (orbitN.getDate().durationFrom(attitudeN.getDate()).abs().getReal() >
  291.             DATE_INCONSISTENCY_THRESHOLD) {

  293.             throw new OrekitIllegalArgumentException(OrekitMessages.ORBIT_AND_ATTITUDE_DATES_MISMATCH,
  294.                                                      orbitN.getDate(), attitudeN.getDate());
  295.         }

  297.         if (orbitN.getFrame() != attitudeN.getReferenceFrame()) {
  298.             throw new OrekitIllegalArgumentException(OrekitMessages.FRAMES_MISMATCH,
  299.                                                      orbitN.getFrame().getName(),
  300.                                                      attitudeN.getReferenceFrame().getName());
  301.         }
  302.     }

  304.     /** Get a time-shifted state.
  305.      * <p>
  306.      * The state can be slightly shifted to close dates. This shift is based on
  307.      * a simple Keplerian model for orbit, a linear extrapolation for attitude
  308.      * taking the spin rate into account and neither mass nor additional states
  309.      * changes. It is <em>not</em> intended as a replacement for proper orbit
  310.      * and attitude propagation but should be sufficient for small time shifts
  311.      * or coarse accuracy.
  312.      * </p>
  313.      * <p>
  314.      * As a rough order of magnitude, the following table shows the extrapolation
  315.      * errors obtained between this simple shift method and an {@link
  316.      * org.orekit.propagation.numerical.NumericalPropagator numerical
  317.      * propagator} for a low Earth Sun Synchronous Orbit, with a 20x20 gravity field,
  318.      * Sun and Moon third bodies attractions, drag and solar radiation pressure.
  319.      * Beware that these results will be different for other orbits.
  320.      * </p>
  321.      * <table border="1" cellpadding="5">
  322.      * <caption>Extrapolation Error</caption>
  323.      * <tr bgcolor="#ccccff"><th>interpolation time (s)</th>
  324.      * <th>position error without derivatives (m)</th><th>position error with derivatives (m)</th></tr>
  325.      * <tr><td bgcolor="#eeeeff"> 60</td><td>  18</td><td> 1.1</td></tr>
  326.      * <tr><td bgcolor="#eeeeff">120</td><td>  72</td><td> 9.1</td></tr>
  327.      * <tr><td bgcolor="#eeeeff">300</td><td> 447</td><td> 140</td></tr>
  328.      * <tr><td bgcolor="#eeeeff">600</td><td>1601</td><td>1067</td></tr>
  329.      * <tr><td bgcolor="#eeeeff">900</td><td>3141</td><td>3307</td></tr>
  330.      * </table>
  331.      * @param dt time shift in seconds
  332.      * @return a new state, shifted with respect to the instance (which is immutable)
  333.      * except for the mass which stay unchanged
  334.      */
  335.     public FieldSpacecraftState<T> shiftedBy(final double dt) {
  336.         return new FieldSpacecraftState<>(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
  337.                                           mass, additional);
  338.     }

  340.     /** Get a time-shifted state.
  341.      * <p>
  342.      * The state can be slightly shifted to close dates. This shift is based on
  343.      * a simple Keplerian model for orbit, a linear extrapolation for attitude
  344.      * taking the spin rate into account and neither mass nor additional states
  345.      * changes. It is <em>not</em> intended as a replacement for proper orbit
  346.      * and attitude propagation but should be sufficient for small time shifts
  347.      * or coarse accuracy.
  348.      * </p>
  349.      * <p>
  350.      * As a rough order of magnitude, the following table shows the extrapolation
  351.      * errors obtained between this simple shift method and an {@link
  352.      * org.orekit.propagation.numerical.NumericalPropagator numerical
  353.      * propagator} for a low Earth Sun Synchronous Orbit, with a 20x20 gravity field,
  354.      * Sun and Moon third bodies attractions, drag and solar radiation pressure.
  355.      * Beware that these results will be different for other orbits.
  356.      * </p>
  357.      * <table border="1" cellpadding="5">
  358.      * <caption>Extrapolation Error</caption>
  359.      * <tr bgcolor="#ccccff"><th>interpolation time (s)</th>
  360.      * <th>position error without derivatives (m)</th><th>position error with derivatives (m)</th></tr>
  361.      * <tr><td bgcolor="#eeeeff"> 60</td><td>  18</td><td> 1.1</td></tr>
  362.      * <tr><td bgcolor="#eeeeff">120</td><td>  72</td><td> 9.1</td></tr>
  363.      * <tr><td bgcolor="#eeeeff">300</td><td> 447</td><td> 140</td></tr>
  364.      * <tr><td bgcolor="#eeeeff">600</td><td>1601</td><td>1067</td></tr>
  365.      * <tr><td bgcolor="#eeeeff">900</td><td>3141</td><td>3307</td></tr>
  366.      * </table>
  367.      * @param dt time shift in seconds
  368.      * @return a new state, shifted with respect to the instance (which is immutable)
  369.      * except for the mass which stay unchanged
  370.      */
  371.     public FieldSpacecraftState<T> shiftedBy(final T dt) {
  372.         return new FieldSpacecraftState<>(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
  373.                                           mass, additional);
  374.     }

  376.     /** Get an interpolated instance.
  377.      * <p>
  378.      * The additional states that are interpolated are the ones already present
  379.      * in the instance. The sample instances must therefore have at least the same
  380.      * additional states has the instance. They may have more additional states,
  381.      * but the extra ones will be ignored.
  382.      * </p>
  383.      * <p>
  384.      * As this implementation of interpolation is polynomial, it should be used only
  385.      * with small samples (about 10-20 points) in order to avoid <a
  386.      * href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's phenomenon</a>
  387.      * and numerical problems (including NaN appearing).
  388.      * </p>
  389.      * @param date interpolation date
  390.      * @param sample sample points on which interpolation should be done
  391.      * @return a new instance, interpolated at specified date
  392.      */
  393.     public FieldSpacecraftState<T> interpolate(final FieldAbsoluteDate<T> date,
  394.                                                final Stream<FieldSpacecraftState<T>> sample) {

  396.         // prepare interpolators
  397.         final List<FieldOrbit<T>> orbits = new ArrayList<>();
  398.         final List<FieldAttitude<T>> attitudes = new ArrayList<>();
  399.         final FieldHermiteInterpolator<T> massInterpolator = new FieldHermiteInterpolator<>();
  400.         final Map<String, FieldHermiteInterpolator<T>> additionalInterpolators =
  401.                 new HashMap<String, FieldHermiteInterpolator<T>>(additional.size());
  402.         for (final String name : additional.keySet()) {
  403.             additionalInterpolators.put(name, new FieldHermiteInterpolator<>());
  404.         }

  406.         // extract sample data
  407.         sample.forEach(state -> {
  408.             final T deltaT = state.getDate().durationFrom(date);
  409.             orbits.add(state.getOrbit());
  410.             attitudes.add(state.getAttitude());
  411.             final T[] mm = MathArrays.buildArray(orbit.getA().getField(), 1);
  412.             mm[0] = state.getMass();
  413.             massInterpolator.addSamplePoint(deltaT,
  414.                                             mm);
  415.             for (final Map.Entry<String, FieldHermiteInterpolator<T>> entry : additionalInterpolators.entrySet()) {
  416.                 entry.getValue().addSamplePoint(deltaT, state.getAdditionalState(entry.getKey()));
  417.             }
  418.         });

  420.         // perform interpolations
  421.         final FieldOrbit<T> interpolatedOrbit       = orbit.interpolate(date, orbits);
  422.         final FieldAttitude<T> interpolatedAttitude = attitude.interpolate(date, attitudes);
  423.         final T interpolatedMass       = massInterpolator.value(orbit.getA().getField().getZero())[0];
  424.         final Map<String, T[]> interpolatedAdditional;
  425.         if (additional.isEmpty()) {
  426.             interpolatedAdditional = null;
  427.         } else {
  428.             interpolatedAdditional = new HashMap<String, T[]>(additional.size());
  429.             for (final Map.Entry<String, FieldHermiteInterpolator<T>> entry : additionalInterpolators.entrySet()) {
  430.                 interpolatedAdditional.put(entry.getKey(), entry.getValue().value(orbit.getA().getField().getZero()));
  431.             }
  432.         }

  434.         // create the complete interpolated state
  435.         return new FieldSpacecraftState<>(interpolatedOrbit, interpolatedAttitude,
  436.                                           interpolatedMass, interpolatedAdditional);

  438.     }

  440.     /** Gets the current orbit.
  441.      * @return the orbit
  442.      */
  443.     public FieldOrbit<T> getOrbit() {
  444.         return orbit;
  445.     }

  447.     /** Get the date.
  448.      * @return date
  449.      */
  450.     public FieldAbsoluteDate<T> getDate() {
  451.         return orbit.getDate();
  452.     }

  454.     /** Get the inertial frame.
  455.      * @return the frame
  456.      */
  457.     public Frame getFrame() {
  458.         return orbit.getFrame();
  459.     }

  461.     /** Check if an additional state is available.
  462.      * @param name name of the additional state
  463.      * @return true if the additional state is available
  464.      * @see #addAdditionalState(String, RealFieldElement...)
  465.      * @see #getAdditionalState(String)
  466.      * @see #getAdditionalStates()
  467.      */
  468.     public boolean hasAdditionalState(final String name) {
  469.         return additional.containsKey(name);
  470.     }

  472.     /** Check if two instances have the same set of additional states available.
  473.      * <p>
  474.      * Only the names and dimensions of the additional states are compared,
  475.      * not their values.
  476.      * </p>
  477.      * @param state state to compare to instance
  478.      * @exception MathIllegalArgumentException if an additional state does not have
  479.      * the same dimension in both states
  480.      */
  481.     public void ensureCompatibleAdditionalStates(final FieldSpacecraftState<T> state)
  482.         throws MathIllegalArgumentException {

  484.         // check instance additional states is a subset of the other one
  485.         for (final Map.Entry<String, T[]> entry : additional.entrySet()) {
  486.             final T[] other = state.additional.get(entry.getKey());
  487.             if (other == null) {
  488.                 throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  489.                                           entry.getKey());
  490.             }
  491.             if (other.length != entry.getValue().length) {
  492.                 throw new MathIllegalStateException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
  493.                                                     other.length, entry.getValue().length);
  494.             }
  495.         }

  497.         if (state.additional.size() > additional.size()) {
  498.             // the other state has more additional states
  499.             for (final String name : state.additional.keySet()) {
  500.                 if (!additional.containsKey(name)) {
  501.                     throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  502.                                               name);
  503.                 }
  504.             }
  505.         }

  507.     }

  509.     /** Get an additional state.
  510.      * @param name name of the additional state
  511.      * @return value of the additional state
  512.           * @see #addAdditionalState(String, RealFieldElement...)
  513.      * @see #hasAdditionalState(String)
  514.      * @see #getAdditionalStates()
  515.      */
  516.     public T[] getAdditionalState(final String name) {
  517.         if (!additional.containsKey(name)) {
  518.             throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE, name);
  519.         }
  520.         return additional.get(name).clone();
  521.     }

  523.     /** Get an unmodifiable map of additional states.
  524.      * @return unmodifiable map of additional states
  525.      * @see #addAdditionalState(String, RealFieldElement...)
  526.      * @see #hasAdditionalState(String)
  527.      * @see #getAdditionalState(String)
  528.      */
  529.     public Map<String, T[]> getAdditionalStates() {
  530.         return Collections.unmodifiableMap(additional);
  531.     }

  533.     /** Compute the transform from orbite/attitude reference frame to spacecraft frame.
  534.      * <p>The spacecraft frame origin is at the point defined by the orbit,
  535.      * and its orientation is defined by the attitude.</p>
  536.      * @return transform from specified frame to current spacecraft frame
  537.      */
  538.     public FieldTransform<T> toTransform() {
  539.         final FieldAbsoluteDate<T> date = orbit.getDate();
  540.         return new FieldTransform<>(date,
  541.                                     new FieldTransform<>(date, orbit.getPVCoordinates().negate()),
  542.                                     new FieldTransform<>(date, attitude.getOrientation()));
  543.     }

  545.     /** Get the central attraction coefficient.
  546.      * @return mu central attraction coefficient (m^3/s^2)
  547.      */
  548.     public double getMu() {
  549.         return orbit.getMu();
  550.     }

  552.     /** Get the Keplerian period.
  553.      * <p>The Keplerian period is computed directly from semi major axis
  554.      * and central acceleration constant.</p>
  555.      * @return Keplerian period in seconds
  556.      */
  557.     public T getKeplerianPeriod() {
  558.         return orbit.getKeplerianPeriod();
  559.     }

  561.     /** Get the Keplerian mean motion.
  562.      * <p>The Keplerian mean motion is computed directly from semi major axis
  563.      * and central acceleration constant.</p>
  564.      * @return Keplerian mean motion in radians per second
  565.      */
  566.     public T getKeplerianMeanMotion() {
  567.         return orbit.getKeplerianMeanMotion();
  568.     }

  570.     /** Get the semi-major axis.
  571.      * @return semi-major axis (m)
  572.      */
  573.     public T getA() {
  574.         return orbit.getA();
  575.     }

  577.     /** Get the first component of the eccentricity vector (as per equinoctial parameters).
  578.      * @return e cos(ω + Ω), first component of eccentricity vector
  579.      * @see #getE()
  580.      */
  581.     public T getEquinoctialEx() {
  582.         return orbit.getEquinoctialEx();
  583.     }

  585.     /** Get the second component of the eccentricity vector (as per equinoctial parameters).
  586.      * @return e sin(ω + Ω), second component of the eccentricity vector
  587.      * @see #getE()
  588.      */
  589.     public T getEquinoctialEy() {
  590.         return orbit.getEquinoctialEy();
  591.     }

  593.     /** Get the first component of the inclination vector (as per equinoctial parameters).
  594.      * @return tan(i/2) cos(Ω), first component of the inclination vector
  595.      * @see #getI()
  596.      */
  597.     public T getHx() {
  598.         return orbit.getHx();
  599.     }

  601.     /** Get the second component of the inclination vector (as per equinoctial parameters).
  602.      * @return tan(i/2) sin(Ω), second component of the inclination vector
  603.      * @see #getI()
  604.      */
  605.     public T getHy() {
  606.         return orbit.getHy();
  607.     }

  609.     /** Get the true latitude argument (as per equinoctial parameters).
  610.      * @return v + ω + Ω true latitude argument (rad)
  611.      * @see #getLE()
  612.      * @see #getLM()
  613.      */
  614.     public T getLv() {
  615.         return orbit.getLv();
  616.     }

  618.     /** Get the eccentric latitude argument (as per equinoctial parameters).
  619.      * @return E + ω + Ω eccentric latitude argument (rad)
  620.      * @see #getLv()
  621.      * @see #getLM()
  622.      */
  623.     public T getLE() {
  624.         return orbit.getLE();
  625.     }

  627.     /** Get the mean latitude argument (as per equinoctial parameters).
  628.      * @return M + ω + Ω mean latitude argument (rad)
  629.      * @see #getLv()
  630.      * @see #getLE()
  631.      */
  632.     public T getLM() {
  633.         return orbit.getLM();
  634.     }

  636.     // Additional orbital elements

  638.     /** Get the eccentricity.
  639.      * @return eccentricity
  640.      * @see #getEquinoctialEx()
  641.      * @see #getEquinoctialEy()
  642.      */
  643.     public T getE() {
  644.         return orbit.getE();
  645.     }

  647.     /** Get the inclination.
  648.      * @return inclination (rad)
  649.      * @see #getHx()
  650.      * @see #getHy()
  651.      */
  652.     public T getI() {
  653.         return orbit.getI();
  654.     }

  656.     /** Get the {@link TimeStampedFieldPVCoordinates} in orbit definition frame.
  657.      * Compute the position and velocity of the satellite. This method caches its
  658.      * results, and recompute them only when the method is called with a new value
  659.      * for mu. The result is provided as a reference to the internally cached
  660.      * {@link TimeStampedFieldPVCoordinates}, so the caller is responsible to copy it in a separate
  661.      * {@link TimeStampedFieldPVCoordinates} if it needs to keep the value for a while.
  662.      * @return pvCoordinates in orbit definition frame
  663.      */
  664.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates() {
  665.         return orbit.getPVCoordinates();
  666.     }

  668.     /** Get the {@link TimeStampedFieldPVCoordinates} in given output frame.
  669.      * Compute the position and velocity of the satellite. This method caches its
  670.      * results, and recompute them only when the method is called with a new value
  671.      * for mu. The result is provided as a reference to the internally cached
  672.      * {@link TimeStampedFieldPVCoordinates}, so the caller is responsible to copy it in a separate
  673.      * {@link TimeStampedFieldPVCoordinates} if it needs to keep the value for a while.
  674.      * @param outputFrame frame in which coordinates should be defined
  675.      * @return pvCoordinates in orbit definition frame
  676.      */
  677.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final Frame outputFrame) {
  678.         return orbit.getPVCoordinates(outputFrame);
  679.     }

  681.     /** Get the attitude.
  682.      * @return the attitude.
  683.      */
  684.     public FieldAttitude<T> getAttitude() {
  685.         return attitude;
  686.     }

  688.     /** Gets the current mass.
  689.      * @return the mass (kg)
  690.      */
  691.     public T getMass() {
  692.         return mass;
  693.     }

  695.     /**To convert a FieldSpacecraftState instance into a SpacecraftState instance.
  696.      *
  697.      * @return SpacecraftState instance with the same properties
  698.      */
  699.     public SpacecraftState toSpacecraftState() {
  700.         final Map<String, double[]> map;
  701.         if (additional.isEmpty()) {
  702.             map = Collections.emptyMap();
  703.         } else {
  704.             map = new HashMap<>(additional.size());
  705.             for (final Map.Entry<String, T[]> entry : additional.entrySet()) {
  706.                 final double[] array = new double[entry.getValue().length];
  707.                 for (int k = 0; k < array.length; ++k) {
  708.                     array[k] = entry.getValue()[k].getReal();
  709.                 }
  710.                 map.put(entry.getKey(), array);
  711.             }
  712.         }
  713.         return new SpacecraftState(orbit.toOrbit(), attitude.toAttitude(), mass.getReal(), map);
  714.     }

  716. }
Created with JaCoCo 0.8.2.201808211720