FieldSpacecraftState.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;


  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.OrekitExceptionWrapper;
  38. import org.orekit.errors.OrekitIllegalArgumentException;
  39. import org.orekit.errors.OrekitMessages;
  40. import org.orekit.frames.FieldTransform;
  41. import org.orekit.frames.Frame;
  42. import org.orekit.frames.LOFType;
  43. import org.orekit.orbits.FieldOrbit;
  44. import org.orekit.orbits.PositionAngle;
  45. import org.orekit.time.FieldAbsoluteDate;
  46. import org.orekit.time.FieldTimeInterpolable;
  47. import org.orekit.time.FieldTimeShiftable;
  48. import org.orekit.time.FieldTimeStamped;
  49. import org.orekit.utils.TimeStampedFieldPVCoordinates;


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

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

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

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

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

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

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

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

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

  125.     /** Create a new instance from orbit and mass.
  126.      * <p>FieldAttitude<T> law is set to an unspecified default attitude.</p>
  127.      * @param orbit the orbit
  128.      * @param mass the mass (kg)
  129.      * @exception OrekitException if default attitude cannot be computed
  130.      */
  131.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final T mass)
  132.         throws OrekitException {
  133.         this(orbit,
  134.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  135.              mass, null);
  136.     }

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

  150.     /** Build a spacecraft state from orbit only.
  151.      * <p>FieldAttitude<T> and mass are set to unspecified non-null arbitrary values.</p>
  152.      * @param orbit the orbit
  153.      * @param additional additional states
  154.      * @exception OrekitException if default attitude cannot be computed
  155.      */
  156.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final Map<String, T[]> additional)
  157.         throws OrekitException {
  158.         this(orbit,
  159.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  160.              orbit.getA().getField().getZero().add(DEFAULT_MASS), additional);
  161.     }

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

  176.     /** Create a new instance from orbit and mass.
  177.      * <p>FieldAttitude<T> law is set to an unspecified default attitude.</p>
  178.      * @param orbit the orbit
  179.      * @param mass the mass (kg)
  180.      * @param additional additional states
  181.      * @exception OrekitException if default attitude cannot be computed
  182.      */
  183.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final T mass, final Map<String, T[]> additional)
  184.         throws OrekitException {
  185.         this(orbit,
  186.              new LofOffset(orbit.getFrame(), LOFType.VVLH).getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  187.              mass, additional);
  188.     }

  190.     /** Build a spacecraft state from orbit, attitude provider and mass.
  191.      * @param orbit the orbit
  192.      * @param attitude attitude
  193.      * @param mass the mass (kg)
  194.      * @param additional additional states (may be null if no additional states are available)
  195.      * @exception IllegalArgumentException if orbit and attitude dates
  196.      * or frames are not equal
  197.      */
  198.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude,
  199.                                 final T mass, final Map<String, T[]> additional)
  200.         throws IllegalArgumentException {
  201.         checkConsistency(orbit, attitude);
  202.         this.orbit      = orbit;
  203.         this.attitude   = attitude;
  204.         this.mass       = mass;


  207.         if (additional == null) {
  208.             this.additional = Collections.emptyMap();
  209.         } else {

  211.             this.additional = new HashMap<String, T[]>(additional.size());
  212.             for (final Map.Entry<String, T[]> entry : additional.entrySet()) {
  213.                 this.additional.put(entry.getKey(), entry.getValue().clone());
  214.             }
  215.         }
  216.     }

  218.     /** Convert a {@link SpacecraftState}.
  219.      * @param field field to which the elements belong
  220.      * @param state state to convert
  221.      */
  222.     public FieldSpacecraftState(final Field<T> field, final SpacecraftState state) {

  224.         final double[] stateD    = new double[6];
  225.         final double[] stateDotD = state.getOrbit().hasDerivatives() ? new double[6] : null;
  226.         state.getOrbit().getType().mapOrbitToArray(state.getOrbit(), PositionAngle.TRUE, stateD, stateDotD);
  227.         final T[] stateF    = MathArrays.buildArray(field, 6);
  228.         for (int i = 0; i < stateD.length; ++i) {
  229.             stateF[i]    = field.getZero().add(stateD[i]);
  230.         }
  231.         final T[] stateDotF;
  232.         if (stateDotD == null) {
  233.             stateDotF = null;
  234.         } else {
  235.             stateDotF = MathArrays.buildArray(field, 6);
  236.             for (int i = 0; i < stateDotD.length; ++i) {
  237.                 stateDotF[i] = field.getZero().add(stateDotD[i]);
  238.             }
  239.         }

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

  243.         this.orbit    = state.getOrbit().getType().mapArrayToOrbit(stateF, stateDotF,
  244.                                                                    PositionAngle.TRUE,
  245.                                                                    dateF, state.getMu(), state.getFrame());
  246.         this.attitude = new FieldAttitude<>(field, state.getAttitude());
  247.         this.mass     = field.getZero().add(state.getMass());

  249.         final Map<String, double[]> additionalD = state.getAdditionalStates();
  250.         if (additionalD.isEmpty()) {
  251.             this.additional = Collections.emptyMap();
  252.         } else {
  253.             this.additional = new HashMap<String, T[]>(additionalD.size());
  254.             for (final Map.Entry<String, double[]> entry : additionalD.entrySet()) {
  255.                 final T[] array = MathArrays.buildArray(field, entry.getValue().length);
  256.                 for (int k = 0; k < array.length; ++k) {
  257.                     array[k] = field.getZero().add(entry.getValue()[k]);
  258.                 }
  259.                 this.additional.put(entry.getKey(), array);
  260.             }
  261.         }

  263.     }

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

  291.     /** Check orbit and attitude dates are equal.
  292.      * @param orbitN the orbit
  293.      * @param attitudeN attitude
  294.      * @exception IllegalArgumentException if orbit and attitude dates
  295.      * are not equal
  296.      */
  297.     private void checkConsistency(final FieldOrbit<T> orbitN, final FieldAttitude<T> attitudeN)
  298.         throws IllegalArgumentException {
  299.         if (orbitN.getDate().durationFrom(attitudeN.getDate()).abs().getReal() >
  300.             DATE_INCONSISTENCY_THRESHOLD) {

  302.             throw new OrekitIllegalArgumentException(OrekitMessages.ORBIT_AND_ATTITUDE_DATES_MISMATCH,
  303.                                                      orbitN.getDate(), attitudeN.getDate());
  304.         }

  306.         if (orbitN.getFrame() != attitudeN.getReferenceFrame()) {
  307.             throw new OrekitIllegalArgumentException(OrekitMessages.FRAMES_MISMATCH,
  308.                                                      orbitN.getFrame().getName(),
  309.                                                      attitudeN.getReferenceFrame().getName());
  310.         }
  311.     }

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

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

  385.     /** Get an interpolated instance.
  386.      * <p>
  387.      * The additional states that are interpolated are the ones already present
  388.      * in the instance. The sample instances must therefore have at least the same
  389.      * additional states has the instance. They may have more additional states,
  390.      * but the extra ones will be ignored.
  391.      * </p>
  392.      * <p>
  393.      * As this implementation of interpolation is polynomial, it should be used only
  394.      * with small samples (about 10-20 points) in order to avoid <a
  395.      * href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's phenomenon</a>
  396.      * and numerical problems (including NaN appearing).
  397.      * </p>
  398.      * @param date interpolation date
  399.      * @param sample sample points on which interpolation should be done
  400.      * @return a new instance, interpolated at specified date
  401.      * @exception OrekitException if the number of point is too small for interpolating
  402.      */
  403.     public FieldSpacecraftState<T> interpolate(final FieldAbsoluteDate<T> date,
  404.                                                final Stream<FieldSpacecraftState<T>> sample)
  405.         throws OrekitException {

  407.         // prepare interpolators
  408.         final List<FieldOrbit<T>> orbits = new ArrayList<>();
  409.         final List<FieldAttitude<T>> attitudes = new ArrayList<>();
  410.         final FieldHermiteInterpolator<T> massInterpolator = new FieldHermiteInterpolator<>();
  411.         final Map<String, FieldHermiteInterpolator<T>> additionalInterpolators =
  412.                 new HashMap<String, FieldHermiteInterpolator<T>>(additional.size());
  413.         for (final String name : additional.keySet()) {
  414.             additionalInterpolators.put(name, new FieldHermiteInterpolator<>());
  415.         }

  417.         // extract sample data
  418.         try {
  419.             sample.forEach(state -> {
  420.                 try {
  421.                     final T deltaT = state.getDate().durationFrom(date);
  422.                     orbits.add(state.getOrbit());
  423.                     attitudes.add(state.getAttitude());
  424.                     final T[] mm = MathArrays.buildArray(orbit.getA().getField(), 1);
  425.                     mm[0] = state.getMass();
  426.                     massInterpolator.addSamplePoint(deltaT,
  427.                                                     mm);
  428.                     for (final Map.Entry<String, FieldHermiteInterpolator<T>> entry : additionalInterpolators.entrySet()) {
  429.                         entry.getValue().addSamplePoint(deltaT, state.getAdditionalState(entry.getKey()));
  430.                     }
  431.                 } catch (OrekitException oe) {
  432.                     throw new OrekitExceptionWrapper(oe);
  433.                 }
  434.             });
  435.         } catch (OrekitExceptionWrapper oew) {
  436.             throw oew.getException();
  437.         }

  439.         // perform interpolations
  440.         final FieldOrbit<T> interpolatedOrbit       = orbit.interpolate(date, orbits);
  441.         final FieldAttitude<T> interpolatedAttitude = attitude.interpolate(date, attitudes);
  442.         final T interpolatedMass       = massInterpolator.value(orbit.getA().getField().getZero())[0];
  443.         final Map<String, T[]> interpolatedAdditional;
  444.         if (additional.isEmpty()) {
  445.             interpolatedAdditional = null;
  446.         } else {
  447.             interpolatedAdditional = new HashMap<String, T[]>(additional.size());
  448.             for (final Map.Entry<String, FieldHermiteInterpolator<T>> entry : additionalInterpolators.entrySet()) {
  449.                 interpolatedAdditional.put(entry.getKey(), entry.getValue().value(orbit.getA().getField().getZero()));
  450.             }
  451.         }

  453.         // create the complete interpolated state
  454.         return new FieldSpacecraftState<>(interpolatedOrbit, interpolatedAttitude,
  455.                                           interpolatedMass, interpolatedAdditional);

  457.     }

  459.     /** Gets the current orbit.
  460.      * @return the orbit
  461.      */
  462.     public FieldOrbit<T> getOrbit() {
  463.         return orbit;
  464.     }

  466.     /** Get the date.
  467.      * @return date
  468.      */
  469.     public FieldAbsoluteDate<T> getDate() {
  470.         return orbit.getDate();
  471.     }

  473.     /** Get the inertial frame.
  474.      * @return the frame
  475.      */
  476.     public Frame getFrame() {
  477.         return orbit.getFrame();
  478.     }

  480.     /** Check if an additional state is available.
  481.      * @param name name of the additional state
  482.      * @return true if the additional state is available
  483.      * @see #addAdditionalState(String, RealFieldElement...)
  484.      * @see #getAdditionalState(String)
  485.      * @see #getAdditionalStates()
  486.      */
  487.     public boolean hasAdditionalState(final String name) {
  488.         return additional.containsKey(name);
  489.     }

  491.     /** Check if two instances have the same set of additional states available.
  492.      * <p>
  493.      * Only the names and dimensions of the additional states are compared,
  494.      * not their values.
  495.      * </p>
  496.      * @param state state to compare to instance
  497.      * @exception OrekitException if either instance or state supports an additional
  498.      * state not supported by the other one
  499.      * @exception MathIllegalArgumentException if an additional state does not have
  500.      * the same dimension in both states
  501.      */
  502.     public void ensureCompatibleAdditionalStates(final FieldSpacecraftState<T> state)
  503.         throws OrekitException, MathIllegalArgumentException {

  505.         // check instance additional states is a subset of the other one
  506.         for (final Map.Entry<String, T[]> entry : additional.entrySet()) {
  507.             final T[] other = state.additional.get(entry.getKey());
  508.             if (other == null) {
  509.                 throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  510.                                           entry.getKey());
  511.             }
  512.             if (other.length != entry.getValue().length) {
  513.                 throw new MathIllegalStateException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
  514.                                                     other.length, entry.getValue().length);
  515.             }
  516.         }

  518.         if (state.additional.size() > additional.size()) {
  519.             // the other state has more additional states
  520.             for (final String name : state.additional.keySet()) {
  521.                 if (!additional.containsKey(name)) {
  522.                     throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  523.                                               name);
  524.                 }
  525.             }
  526.         }

  528.     }

  530.     /** Get an additional state.
  531.      * @param name name of the additional state
  532.      * @return value of the additional state
  533.      * @exception OrekitException if no additional state with that name exists
  534.      * @see #addAdditionalState(String, RealFieldElement...)
  535.      * @see #hasAdditionalState(String)
  536.      * @see #getAdditionalStates()
  537.      */
  538.     public T[] getAdditionalState(final String name) throws OrekitException {
  539.         if (!additional.containsKey(name)) {
  540.             throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE, name);
  541.         }
  542.         return additional.get(name).clone();
  543.     }

  545.     /** Get an unmodifiable map of additional states.
  546.      * @return unmodifiable map of additional states
  547.      * @see #addAdditionalState(String, RealFieldElement...)
  548.      * @see #hasAdditionalState(String)
  549.      * @see #getAdditionalState(String)
  550.      */
  551.     public Map<String, T[]> getAdditionalStates() {
  552.         return Collections.unmodifiableMap(additional);
  553.     }

  555.     /** Compute the transform from orbite/attitude reference frame to spacecraft frame.
  556.      * <p>The spacecraft frame origin is at the point defined by the orbit,
  557.      * and its orientation is defined by the attitude.</p>
  558.      * @return transform from specified frame to current spacecraft frame
  559.      */
  560.     public FieldTransform<T> toTransform() {
  561.         final FieldAbsoluteDate<T> date = orbit.getDate();
  562.         return new FieldTransform<>(date,
  563.                                     new FieldTransform<>(date, orbit.getPVCoordinates().negate()),
  564.                                     new FieldTransform<>(date, attitude.getOrientation()));
  565.     }

  567.     /** Get the central attraction coefficient.
  568.      * @return mu central attraction coefficient (m^3/s^2)
  569.      */
  570.     public double getMu() {
  571.         return orbit.getMu();
  572.     }

  574.     /** Get the Keplerian period.
  575.      * <p>The Keplerian period is computed directly from semi major axis
  576.      * and central acceleration constant.</p>
  577.      * @return Keplerian period in seconds
  578.      */
  579.     public T getKeplerianPeriod() {
  580.         return orbit.getKeplerianPeriod();
  581.     }

  583.     /** Get the Keplerian mean motion.
  584.      * <p>The Keplerian mean motion is computed directly from semi major axis
  585.      * and central acceleration constant.</p>
  586.      * @return Keplerian mean motion in radians per second
  587.      */
  588.     public T getKeplerianMeanMotion() {
  589.         return orbit.getKeplerianMeanMotion();
  590.     }

  592.     /** Get the semi-major axis.
  593.      * @return semi-major axis (m)
  594.      */
  595.     public T getA() {
  596.         return orbit.getA();
  597.     }

  599.     /** Get the first component of the eccentricity vector (as per equinoctial parameters).
  600.      * @return e cos(ω + Ω), first component of eccentricity vector
  601.      * @see #getE()
  602.      */
  603.     public T getEquinoctialEx() {
  604.         return orbit.getEquinoctialEx();
  605.     }

  607.     /** Get the second component of the eccentricity vector (as per equinoctial parameters).
  608.      * @return e sin(ω + Ω), second component of the eccentricity vector
  609.      * @see #getE()
  610.      */
  611.     public T getEquinoctialEy() {
  612.         return orbit.getEquinoctialEy();
  613.     }

  615.     /** Get the first component of the inclination vector (as per equinoctial parameters).
  616.      * @return tan(i/2) cos(Ω), first component of the inclination vector
  617.      * @see #getI()
  618.      */
  619.     public T getHx() {
  620.         return orbit.getHx();
  621.     }

  623.     /** Get the second component of the inclination vector (as per equinoctial parameters).
  624.      * @return tan(i/2) sin(Ω), second component of the inclination vector
  625.      * @see #getI()
  626.      */
  627.     public T getHy() {
  628.         return orbit.getHy();
  629.     }

  631.     /** Get the true latitude argument (as per equinoctial parameters).
  632.      * @return v + ω + Ω true latitude argument (rad)
  633.      * @see #getLE()
  634.      * @see #getLM()
  635.      */
  636.     public T getLv() {
  637.         return orbit.getLv();
  638.     }

  640.     /** Get the eccentric latitude argument (as per equinoctial parameters).
  641.      * @return E + ω + Ω eccentric latitude argument (rad)
  642.      * @see #getLv()
  643.      * @see #getLM()
  644.      */
  645.     public T getLE() {
  646.         return orbit.getLE();
  647.     }

  649.     /** Get the mean latitude argument (as per equinoctial parameters).
  650.      * @return M + ω + Ω mean latitude argument (rad)
  651.      * @see #getLv()
  652.      * @see #getLE()
  653.      */
  654.     public T getLM() {
  655.         return orbit.getLM();
  656.     }

  658.     // Additional orbital elements

  660.     /** Get the eccentricity.
  661.      * @return eccentricity
  662.      * @see #getEquinoctialEx()
  663.      * @see #getEquinoctialEy()
  664.      */
  665.     public T getE() {
  666.         return orbit.getE();
  667.     }

  669.     /** Get the inclination.
  670.      * @return inclination (rad)
  671.      * @see #getHx()
  672.      * @see #getHy()
  673.      */
  674.     public T getI() {
  675.         return orbit.getI();
  676.     }

  678.     /** Get the {@link TimeStampedFieldPVCoordinates} in orbit definition frame.
  679.      * Compute the position and velocity of the satellite. This method caches its
  680.      * results, and recompute them only when the method is called with a new value
  681.      * for mu. The result is provided as a reference to the internally cached
  682.      * {@link TimeStampedFieldPVCoordinates}, so the caller is responsible to copy it in a separate
  683.      * {@link TimeStampedFieldPVCoordinates} if it needs to keep the value for a while.
  684.      * @return pvCoordinates in orbit definition frame
  685.      */
  686.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates() {
  687.         return orbit.getPVCoordinates();
  688.     }

  690.     /** Get the {@link TimeStampedFieldPVCoordinates} in given output frame.
  691.      * Compute the position and velocity of the satellite. This method caches its
  692.      * results, and recompute them only when the method is called with a new value
  693.      * for mu. The result is provided as a reference to the internally cached
  694.      * {@link TimeStampedFieldPVCoordinates}, so the caller is responsible to copy it in a separate
  695.      * {@link TimeStampedFieldPVCoordinates} if it needs to keep the value for a while.
  696.      * @param outputFrame frame in which coordinates should be defined
  697.      * @return pvCoordinates in orbit definition frame
  698.      * @exception OrekitException if the transformation between frames cannot be computed
  699.      */
  700.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final Frame outputFrame)
  701.         throws OrekitException {
  702.         return orbit.getPVCoordinates(outputFrame);
  703.     }

  705.     /** Get the attitude.
  706.      * @return the attitude.
  707.      */
  708.     public FieldAttitude<T> getAttitude() {
  709.         return attitude;
  710.     }

  712.     /** Gets the current mass.
  713.      * @return the mass (kg)
  714.      */
  715.     public T getMass() {
  716.         return mass;
  717.     }

  719.     /**To convert a FieldSpacecraftState instance into a SpacecraftState instance.
  720.      *
  721.      * @return SpacecraftState instance with the same properties
  722.      */
  723.     public SpacecraftState toSpacecraftState() {
  724.         final Map<String, double[]> map;
  725.         if (additional.isEmpty()) {
  726.             map = Collections.emptyMap();
  727.         } else {
  728.             map = new HashMap<>(additional.size());
  729.             for (final Map.Entry<String, T[]> entry : additional.entrySet()) {
  730.                 final double[] array = new double[entry.getValue().length];
  731.                 for (int k = 0; k < array.length; ++k) {
  732.                     array[k] = entry.getValue()[k].getReal();
  733.                 }
  734.                 map.put(entry.getKey(), array);
  735.             }
  736.         }
  737.         return new SpacecraftState(orbit.toOrbit(), attitude.toAttitude(), mass.getReal(), map);
  738.     }

  740. }
Created with JaCoCo 0.7.9.201702052155