FieldSpacecraftState.java

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


  20. import org.hipparchus.CalculusFieldElement;
  21. import org.hipparchus.Field;
  22. import org.hipparchus.exception.LocalizedCoreFormats;
  23. import org.hipparchus.exception.MathIllegalArgumentException;
  24. import org.hipparchus.exception.MathIllegalStateException;
  25. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  26. import org.hipparchus.util.FastMath;
  27. import org.hipparchus.util.MathArrays;
  28. import org.orekit.attitudes.FieldAttitude;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitIllegalArgumentException;
  31. import org.orekit.errors.OrekitIllegalStateException;
  32. import org.orekit.errors.OrekitMessages;
  33. import org.orekit.frames.FieldStaticTransform;
  34. import org.orekit.frames.FieldTransform;
  35. import org.orekit.frames.Frame;
  36. import org.orekit.orbits.FieldOrbit;
  37. import org.orekit.orbits.PositionAngleType;
  38. import org.orekit.time.FieldAbsoluteDate;
  39. import org.orekit.time.FieldTimeShiftable;
  40. import org.orekit.time.FieldTimeStamped;
  41. import org.orekit.utils.DoubleArrayDictionary;
  42. import org.orekit.utils.FieldArrayDictionary;
  43. import org.orekit.utils.FieldAbsolutePVCoordinates;
  44. import org.orekit.utils.FieldPVCoordinates;
  45. import org.orekit.utils.TimeStampedFieldPVCoordinates;
  46. import org.orekit.utils.TimeStampedPVCoordinates;

  48. /** This class is the representation of a complete state holding orbit, attitude
  49.  * and mass information at a given date, meant primarily for propagation.
  50.  *
  51.  * <p>It contains an {@link FieldOrbit}, or a {@link FieldAbsolutePVCoordinates} if there
  52.  * is no definite central body, plus the current mass and attitude at the intrinsic
  53.  * {@link FieldAbsoluteDate}. Quantities are guaranteed to be consistent in terms
  54.  * of date and reference frame. The spacecraft state may also contain additional
  55.  * states, which are simply named double arrays which can hold any user-defined
  56.  * data.
  57.  * </p>
  58.  * <p>
  59.  * The state can be slightly shifted to close dates. This actual shift varies
  60.  * between {@link FieldOrbit} and {@link FieldAbsolutePVCoordinates}.
  61.  * For attitude it is a linear extrapolation taking the spin rate into account
  62.  * and no mass change. It is <em>not</em> intended as a replacement for proper
  63.  * orbit and attitude propagation but should be sufficient for either small
  64.  * time shifts or coarse accuracy.
  65.  * </p>
  66.  * <p>
  67.  * The instance {@code FieldSpacecraftState} is guaranteed to be immutable.
  68.  * </p>
  69.  * @see org.orekit.propagation.numerical.NumericalPropagator
  70.  * @see SpacecraftState
  71.  * @author Fabien Maussion
  72.  * @author V&eacute;ronique Pommier-Maurussane
  73.  * @author Luc Maisonobe
  74.  * @author Vincent Mouraux
  75.  * @param <T> type of the field elements
  76.  */
  77. public class FieldSpacecraftState <T extends CalculusFieldElement<T>>
  78.     implements FieldTimeStamped<T>, FieldTimeShiftable<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, FieldAttitude)}. 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.     /** Trajectory state, when it is not an orbit. */
  93.     private final FieldAbsolutePVCoordinates<T> absPva;

  95.     /** FieldAttitude<T>. */
  96.     private final FieldAttitude<T> attitude;

  98.     /** Current mass (kg). */
  99.     private final T mass;

  101.     /** Additional states. */
  102.     private final FieldArrayDictionary<T> additional;

  104.     /** Additional states derivatives.
  105.      * @since 11.1
  106.      */
  107.     private final FieldArrayDictionary<T> additionalDot;

  109.     /** Build a spacecraft state from orbit only.
  110.      * <p>FieldAttitude and mass are set to unspecified non-null arbitrary values.</p>
  111.      * @param orbit the orbit
  112.      */
  113.     public FieldSpacecraftState(final FieldOrbit<T> orbit) {
  114.         this(orbit, SpacecraftState.getDefaultAttitudeProvider(orbit.getFrame())
  115.                         .getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  116.              orbit.getA().getField().getZero().add(DEFAULT_MASS), (FieldArrayDictionary<T>) null);
  117.     }

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

  131.     /** Create a new instance from orbit and mass.
  132.      * <p>FieldAttitude law is set to an unspecified default attitude.</p>
  133.      * @param orbit the orbit
  134.      * @param mass the mass (kg)
  135.      */
  136.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final T mass) {
  137.         this(orbit, SpacecraftState.getDefaultAttitudeProvider(orbit.getFrame())
  138.                         .getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  139.              mass, (FieldArrayDictionary<T>) null);
  140.     }

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

  154.     /** Build a spacecraft state from orbit and additional states.
  155.      * <p>FieldAttitude and mass are set to unspecified non-null arbitrary values.</p>
  156.      * @param orbit the orbit
  157.      * @param additional additional states
  158.      * @since 11.1
  159.      */
  160.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldArrayDictionary<T> additional) {
  161.         this(orbit, SpacecraftState.getDefaultAttitudeProvider(orbit.getFrame())
  162.                         .getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  163.              orbit.getA().getField().getZero().add(DEFAULT_MASS), additional);
  164.     }

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

  180.     /** Create a new instance from orbit, mass and additional states.
  181.      * <p>FieldAttitude law is set to an unspecified default attitude.</p>
  182.      * @param orbit the orbit
  183.      * @param mass the mass (kg)
  184.      * @param additional additional states
  185.      * @since 11.1
  186.      */
  187.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final T mass, final FieldArrayDictionary<T> additional) {
  188.         this(orbit, SpacecraftState.getDefaultAttitudeProvider(orbit.getFrame())
  189.                         .getAttitude(orbit, orbit.getDate(), orbit.getFrame()),
  190.              mass, additional);
  191.     }

  193.     /** Build a spacecraft state from orbit, attitude, mass and additional states.
  194.      * @param orbit the orbit
  195.      * @param attitude attitude
  196.      * @param mass the mass (kg)
  197.      * @param additional additional states (may be null if no additional states are available)
  198.      * @since 11.1
  199.      */
  200.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude,
  201.                                 final T mass, final FieldArrayDictionary<T> additional) {
  202.         this(orbit, attitude, mass, additional, null);
  203.     }

  205.     /** Build a spacecraft state from orbit, attitude, mass, additional states and derivatives.
  206.      * @param orbit the orbit
  207.      * @param attitude attitude
  208.      * @param mass the mass (kg)
  209.      * @param additional additional states (may be null if no additional states are available)
  210.      * @param additionalDot additional states derivatives(may be null if no additional states derivative sare available)
  211.      * @exception IllegalArgumentException if orbit and attitude dates
  212.      * or frames are not equal
  213.      * @since 11.1
  214.      */
  215.     public FieldSpacecraftState(final FieldOrbit<T> orbit, final FieldAttitude<T> attitude, final T mass,
  216.                                 final FieldArrayDictionary<T> additional,
  217.                                 final FieldArrayDictionary<T> additionalDot)
  218.         throws IllegalArgumentException {
  219.         checkConsistency(orbit, attitude);
  220.         this.orbit      = orbit;
  221.         this.attitude   = attitude;
  222.         this.mass       = mass;
  223.         this.absPva     = null;

  225.         if (additional == null) {
  226.             this.additional = new FieldArrayDictionary<>(orbit.getDate().getField());
  227.         } else {
  228.             this.additional = new FieldArrayDictionary<>(additional);
  229.         }

  231.         if (additionalDot == null) {
  232.             this.additionalDot = new FieldArrayDictionary<>(orbit.getDate().getField());
  233.         } else {

  235.             this.additionalDot = new FieldArrayDictionary<>(additionalDot);
  236.         }

  238.     }

  240.     /** Convert a {@link FieldSpacecraftState}.
  241.      * @param field field to which the elements belong
  242.      * @param state state to convert
  243.      */
  244.     public FieldSpacecraftState(final Field<T> field, final SpacecraftState state) {

  246.         if (state.isOrbitDefined()) {
  247.             final double[] stateD    = new double[6];
  248.             final double[] stateDotD = state.getOrbit().hasDerivatives() ? new double[6] : null;
  249.             final PositionAngleType positionAngleType = PositionAngleType.TRUE;
  250.             state.getOrbit().getType().mapOrbitToArray(state.getOrbit(), positionAngleType, stateD, stateDotD);
  251.             final T[] stateF    = MathArrays.buildArray(field, 6);
  252.             for (int i = 0; i < stateD.length; ++i) {
  253.                 stateF[i]    = field.getZero().add(stateD[i]);
  254.             }
  255.             final T[] stateDotF;
  256.             if (stateDotD == null) {
  257.                 stateDotF = null;
  258.             } else {
  259.                 stateDotF = MathArrays.buildArray(field, 6);
  260.                 for (int i = 0; i < stateDotD.length; ++i) {
  261.                     stateDotF[i] = field.getZero().add(stateDotD[i]);
  262.                 }
  263.             }

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

  267.             this.orbit    = state.getOrbit().getType().mapArrayToOrbit(stateF, stateDotF, positionAngleType, dateF,
  268.                                                                        field.getZero().add(state.getMu()), state.getFrame());
  269.             this.absPva   = null;

  271.         } else {
  272.             final TimeStampedPVCoordinates tspva = state.getPVCoordinates();
  273.             final FieldVector3D<T> position = new FieldVector3D<>(field, tspva.getPosition());
  274.             final FieldVector3D<T> velocity = new FieldVector3D<>(field, tspva.getVelocity());
  275.             final FieldVector3D<T> acceleration = new FieldVector3D<>(field, tspva.getAcceleration());
  276.             final FieldPVCoordinates<T> pva = new FieldPVCoordinates<>(position, velocity, acceleration);
  277.             final FieldAbsoluteDate<T> dateF = new FieldAbsoluteDate<>(field, state.getDate());
  278.             this.orbit  = null;
  279.             this.absPva = new FieldAbsolutePVCoordinates<>(state.getFrame(), dateF, pva);
  280.         }

  282.         this.attitude = new FieldAttitude<>(field, state.getAttitude());
  283.         this.mass     = field.getZero().add(state.getMass());

  285.         final DoubleArrayDictionary additionalD = state.getAdditionalStatesValues();
  286.         if (additionalD.size() == 0) {
  287.             this.additional = new FieldArrayDictionary<>(field);
  288.         } else {
  289.             this.additional = new FieldArrayDictionary<>(field, additionalD.size());
  290.             for (final DoubleArrayDictionary.Entry entry : additionalD.getData()) {
  291.                 this.additional.put(entry.getKey(), entry.getValue());
  292.             }
  293.         }
  294.         final DoubleArrayDictionary additionalDotD = state.getAdditionalStatesDerivatives();
  295.         if (additionalDotD.size() == 0) {
  296.             this.additionalDot = new FieldArrayDictionary<>(field);
  297.         } else {
  298.             this.additionalDot = new FieldArrayDictionary<>(field, additionalDotD.size());
  299.             for (final DoubleArrayDictionary.Entry entry : additionalDotD.getData()) {
  300.                 this.additionalDot.put(entry.getKey(), entry.getValue());
  301.             }
  302.         }

  304.     }

  306.     /** Build a spacecraft state from orbit only.
  307.      * <p>Attitude and mass are set to unspecified non-null arbitrary values.</p>
  308.      * @param absPva position-velocity-acceleration
  309.      */
  310.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva) {
  311.         this(absPva,
  312.              SpacecraftState.getDefaultAttitudeProvider(absPva.getFrame()).
  313.                      getAttitude(absPva, absPva.getDate(), absPva.getFrame()),
  314.              absPva.getDate().getField().getZero().add(DEFAULT_MASS), (FieldArrayDictionary<T>) null);
  315.     }

  317.     /** Build a spacecraft state from orbit and attitude.
  318.      * <p>Mass is set to an unspecified non-null arbitrary value.</p>
  319.      * @param absPva position-velocity-acceleration
  320.      * @param attitude attitude
  321.      * @exception IllegalArgumentException if orbit and attitude dates
  322.      * or frames are not equal
  323.      */
  324.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final FieldAttitude<T> attitude)
  325.         throws IllegalArgumentException {
  326.         this(absPva, attitude, absPva.getDate().getField().getZero().add(DEFAULT_MASS), (FieldArrayDictionary<T>) null);
  327.     }

  329.     /** Create a new instance from orbit and mass.
  330.      * <p>Attitude law is set to an unspecified default attitude.</p>
  331.      * @param absPva position-velocity-acceleration
  332.      * @param mass the mass (kg)
  333.      */
  334.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final T mass) {
  335.         this(absPva, SpacecraftState.getDefaultAttitudeProvider(absPva.getFrame())
  336.                         .getAttitude(absPva, absPva.getDate(), absPva.getFrame()),
  337.              mass, (FieldArrayDictionary<T>) null);
  338.     }

  340.     /** Build a spacecraft state from orbit, attitude and mass.
  341.      * @param absPva position-velocity-acceleration
  342.      * @param attitude attitude
  343.      * @param mass the mass (kg)
  344.      * @exception IllegalArgumentException if orbit and attitude dates
  345.      * or frames are not equal
  346.      */
  347.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final FieldAttitude<T> attitude, final T mass)
  348.         throws IllegalArgumentException {
  349.         this(absPva, attitude, mass, (FieldArrayDictionary<T>) null);
  350.     }

  352.     /** Build a spacecraft state from orbit only.
  353.      * <p>Attitude and mass are set to unspecified non-null arbitrary values.</p>
  354.      * @param absPva position-velocity-acceleration
  355.      * @param additional additional states
  356.      * @since 11.1
  357.      */
  358.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final FieldArrayDictionary<T> additional) {
  359.         this(absPva, SpacecraftState.getDefaultAttitudeProvider(absPva.getFrame())
  360.                         .getAttitude(absPva, absPva.getDate(), absPva.getFrame()),
  361.              absPva.getDate().getField().getZero().add(DEFAULT_MASS), additional);
  362.     }

  364.     /** Build a spacecraft state from orbit and attitude.
  365.      * <p>Mass is set to an unspecified non-null arbitrary value.</p>
  366.      * @param absPva position-velocity-acceleration
  367.      * @param attitude attitude
  368.      * @param additional additional states
  369.      * @exception IllegalArgumentException if orbit and attitude dates
  370.      * or frames are not equal
  371.      * @since 11.1
  372.      */
  373.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final FieldAttitude<T> attitude,
  374.                                 final FieldArrayDictionary<T> additional)
  375.         throws IllegalArgumentException {
  376.         this(absPva, attitude, absPva.getDate().getField().getZero().add(DEFAULT_MASS), additional);
  377.     }

  379.     /** Create a new instance from orbit and mass.
  380.      * <p>Attitude law is set to an unspecified default attitude.</p>
  381.      * @param absPva position-velocity-acceleration
  382.      * @param mass the mass (kg)
  383.      * @param additional additional states
  384.      * @since 11.1
  385.      */
  386.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final T mass, final FieldArrayDictionary<T> additional) {
  387.         this(absPva, SpacecraftState.getDefaultAttitudeProvider(absPva.getFrame())
  388.                         .getAttitude(absPva, absPva.getDate(), absPva.getFrame()),
  389.              mass, additional);
  390.     }

  392.     /** Build a spacecraft state from orbit, attitude and mass.
  393.      * @param absPva position-velocity-acceleration
  394.      * @param attitude attitude
  395.      * @param mass the mass (kg)
  396.      * @param additional additional states (may be null if no additional states are available)
  397.      * @since 11.1
  398.      */
  399.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final FieldAttitude<T> attitude,
  400.                            final T mass, final FieldArrayDictionary<T> additional) {
  401.         this(absPva, attitude, mass, additional, null);
  402.     }

  404.     /** Build a spacecraft state from orbit, attitude and mass.
  405.      * @param absPva position-velocity-acceleration
  406.      * @param attitude attitude
  407.      * @param mass the mass (kg)
  408.      * @param additional additional states (may be null if no additional states are available)
  409.      * @param additionalDot additional states derivatives(may be null if no additional states derivatives are available)
  410.      * @exception IllegalArgumentException if orbit and attitude dates
  411.      * or frames are not equal
  412.      * @since 11.1
  413.      */
  414.     public FieldSpacecraftState(final FieldAbsolutePVCoordinates<T> absPva, final FieldAttitude<T> attitude, final T mass,
  415.                                 final FieldArrayDictionary<T> additional, final FieldArrayDictionary<T> additionalDot)
  416.         throws IllegalArgumentException {
  417.         checkConsistency(absPva, attitude);
  418.         this.orbit      = null;
  419.         this.absPva     = absPva;
  420.         this.attitude   = attitude;
  421.         this.mass       = mass;
  422.         if (additional == null) {
  423.             this.additional = new FieldArrayDictionary<>(absPva.getDate().getField());
  424.         } else {
  425.             this.additional = new FieldArrayDictionary<>(additional);
  426.         }
  427.         if (additionalDot == null) {
  428.             this.additionalDot = new FieldArrayDictionary<>(absPva.getDate().getField());
  429.         } else {
  430.             this.additionalDot = new FieldArrayDictionary<>(additionalDot);
  431.         }
  432.     }

  434.     /** Add an additional state.
  435.      * <p>
  436.      * {@link FieldSpacecraftState SpacecraftState} instances are immutable,
  437.      * so this method does <em>not</em> change the instance, but rather
  438.      * creates a new instance, which has the same orbit, attitude, mass
  439.      * and additional states as the original instance, except it also
  440.      * has the specified state. If the original instance already had an
  441.      * additional state with the same name, it will be overridden. If it
  442.      * did not have any additional state with that name, the new instance
  443.      * will have one more additional state than the original instance.
  444.      * </p>
  445.      * @param name name of the additional state
  446.      * @param value value of the additional state
  447.      * @return a new instance, with the additional state added
  448.      * @see #hasAdditionalState(String)
  449.      * @see #getAdditionalState(String)
  450.      * @see #getAdditionalStatesValues()
  451.      */
  452.     @SafeVarargs
  453.     public final FieldSpacecraftState<T> addAdditionalState(final String name, final T... value) {
  454.         final FieldArrayDictionary<T> newDict = new FieldArrayDictionary<>(additional);
  455.         newDict.put(name, value.clone());
  456.         if (isOrbitDefined()) {
  457.             return new FieldSpacecraftState<>(orbit, attitude, mass, newDict, additionalDot);
  458.         } else {
  459.             return new FieldSpacecraftState<>(absPva, attitude, mass, newDict, additionalDot);
  460.         }
  461.     }

  463.     /** Add an additional state derivative.
  464.     * {@link FieldSpacecraftState FieldSpacecraftState} instances are immutable,
  465.      * so this method does <em>not</em> change the instance, but rather
  466.      * creates a new instance, which has the same components as the original
  467.      * instance, except it also has the specified state derivative. If the
  468.      * original instance already had an additional state derivative with the
  469.      * same name, it will be overridden. If it did not have any additional
  470.      * state derivative with that name, the new instance will have one more
  471.      * additional state derivative than the original instance.
  472.      * @param name name of the additional state derivative
  473.      * @param value value of the additional state derivative
  474.      * @return a new instance, with the additional state derivative added
  475.      * @see #hasAdditionalStateDerivative(String)
  476.      * @see #getAdditionalStateDerivative(String)
  477.      * @see #getAdditionalStatesDerivatives()
  478.      */
  479.     @SafeVarargs
  480.     public final FieldSpacecraftState<T> addAdditionalStateDerivative(final String name, final T... value) {
  481.         final FieldArrayDictionary<T> newDict = new FieldArrayDictionary<>(additionalDot);
  482.         newDict.put(name, value.clone());
  483.         if (isOrbitDefined()) {
  484.             return new FieldSpacecraftState<>(orbit, attitude, mass, additional, newDict);
  485.         } else {
  486.             return new FieldSpacecraftState<>(absPva, attitude, mass, additional, newDict);
  487.         }
  488.     }

  490.     /** Check orbit and attitude dates are equal.
  491.      * @param orbitN the orbit
  492.      * @param attitudeN attitude
  493.      * @exception IllegalArgumentException if orbit and attitude dates
  494.      * are not equal
  495.      */
  496.     private void checkConsistency(final FieldOrbit<T> orbitN, final FieldAttitude<T> attitudeN)
  497.         throws IllegalArgumentException {
  498.         if (orbitN.getDate().durationFrom(attitudeN.getDate()).abs().getReal() >
  499.             DATE_INCONSISTENCY_THRESHOLD) {

  501.             throw new OrekitIllegalArgumentException(OrekitMessages.ORBIT_AND_ATTITUDE_DATES_MISMATCH,
  502.                                                      orbitN.getDate(), attitudeN.getDate());
  503.         }

  505.         if (orbitN.getFrame() != attitudeN.getReferenceFrame()) {
  506.             throw new OrekitIllegalArgumentException(OrekitMessages.FRAMES_MISMATCH,
  507.                                                      orbitN.getFrame().getName(),
  508.                                                      attitudeN.getReferenceFrame().getName());
  509.         }
  510.     }

  512.     /** Check if the state contains an orbit part.
  513.      * <p>
  514.      * A state contains either an {@link FieldAbsolutePVCoordinates absolute
  515.      * position-velocity-acceleration} or an {@link FieldOrbit orbit}.
  516.      * </p>
  517.      * @return true if state contains an orbit (in which case {@link #getOrbit()}
  518.      * will not throw an exception), or false if the state contains an
  519.      * absolut position-velocity-acceleration (in which case {@link #getAbsPVA()}
  520.      * will not throw an exception)
  521.      */
  522.     public boolean isOrbitDefined() {
  523.         return orbit != null;
  524.     }

  526.     /**
  527.      * Check FieldAbsolutePVCoordinates and attitude dates are equal.
  528.      * @param absPva   position-velocity-acceleration
  529.      * @param attitude attitude
  530.      * @param <T>      the type of the field elements
  531.      * @exception IllegalArgumentException if orbit and attitude dates are not equal
  532.      */
  533.     private static <T extends CalculusFieldElement<T>> void checkConsistency(final FieldAbsolutePVCoordinates<T> absPva, final FieldAttitude<T> attitude)
  534.         throws IllegalArgumentException {
  535.         if (FastMath.abs(absPva.getDate().durationFrom(attitude.getDate())).getReal() >
  536.             DATE_INCONSISTENCY_THRESHOLD) {
  537.             throw new OrekitIllegalArgumentException(OrekitMessages.ORBIT_AND_ATTITUDE_DATES_MISMATCH,
  538.                                                      absPva.getDate(), attitude.getDate());
  539.         }
  540.         if (absPva.getFrame() != attitude.getReferenceFrame()) {
  541.             throw new OrekitIllegalArgumentException(OrekitMessages.FRAMES_MISMATCH,
  542.                                                      absPva.getFrame().getName(),
  543.                                                      attitude.getReferenceFrame().getName());
  544.         }
  545.     }

  547.     /** Get a time-shifted state.
  548.      * <p>
  549.      * The state can be slightly shifted to close dates. This shift is based on
  550.      * a simple Keplerian model for orbit, a linear extrapolation for attitude
  551.      * taking the spin rate into account and neither mass nor additional states
  552.      * changes. It is <em>not</em> intended as a replacement for proper orbit
  553.      * and attitude propagation but should be sufficient for small time shifts
  554.      * or coarse accuracy.
  555.      * </p>
  556.      * <p>
  557.      * As a rough order of magnitude, the following table shows the extrapolation
  558.      * errors obtained between this simple shift method and an {@link
  559.      * org.orekit.propagation.numerical.FieldNumericalPropagator numerical
  560.      * propagator} for a low Earth Sun Synchronous Orbit, with a 20x20 gravity field,
  561.      * Sun and Moon third bodies attractions, drag and solar radiation pressure.
  562.      * Beware that these results will be different for other orbits.
  563.      * </p>
  564.      * <table border="1">
  565.      * <caption>Extrapolation Error</caption>
  566.      * <tr style="background-color: #ccccff;"><th>interpolation time (s)</th>
  567.      * <th>position error without derivatives (m)</th><th>position error with derivatives (m)</th></tr>
  568.      * <tr><td style="background-color: #eeeeff; padding:5px"> 60</td><td>  18</td><td> 1.1</td></tr>
  569.      * <tr><td style="background-color: #eeeeff; padding:5px">120</td><td>  72</td><td> 9.1</td></tr>
  570.      * <tr><td style="background-color: #eeeeff; padding:5px">300</td><td> 447</td><td> 140</td></tr>
  571.      * <tr><td style="background-color: #eeeeff; padding:5px">600</td><td>1601</td><td>1067</td></tr>
  572.      * <tr><td style="background-color: #eeeeff; padding:5px">900</td><td>3141</td><td>3307</td></tr>
  573.      * </table>
  574.      * @param dt time shift in seconds
  575.      * @return a new state, shifted with respect to the instance (which is immutable)
  576.      * except for the mass which stay unchanged
  577.      */
  578.     @Override
  579.     public FieldSpacecraftState<T> shiftedBy(final double dt) {
  580.         if (isOrbitDefined()) {
  581.             return new FieldSpacecraftState<>(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
  582.                                               mass, shiftAdditional(dt), additionalDot);
  583.         } else {
  584.             return new FieldSpacecraftState<>(absPva.shiftedBy(dt), attitude.shiftedBy(dt),
  585.                                               mass, shiftAdditional(dt), additionalDot);
  586.         }
  587.     }

  589.     /** Get a time-shifted state.
  590.      * <p>
  591.      * The state can be slightly shifted to close dates. This shift is based on
  592.      * a simple Keplerian model for orbit, a linear extrapolation for attitude
  593.      * taking the spin rate into account and neither mass nor additional states
  594.      * changes. It is <em>not</em> intended as a replacement for proper orbit
  595.      * and attitude propagation but should be sufficient for small time shifts
  596.      * or coarse accuracy.
  597.      * </p>
  598.      * <p>
  599.      * As a rough order of magnitude, the following table shows the extrapolation
  600.      * errors obtained between this simple shift method and an {@link
  601.      * org.orekit.propagation.numerical.FieldNumericalPropagator numerical
  602.      * propagator} for a low Earth Sun Synchronous Orbit, with a 20x20 gravity field,
  603.      * Sun and Moon third bodies attractions, drag and solar radiation pressure.
  604.      * Beware that these results will be different for other orbits.
  605.      * </p>
  606.      * <table border="1">
  607.      * <caption>Extrapolation Error</caption>
  608.      * <tr style="background-color: #ccccff;"><th>interpolation time (s)</th>
  609.      * <th>position error without derivatives (m)</th><th>position error with derivatives (m)</th></tr>
  610.      * <tr><td style="background-color: #eeeeff; padding:5px"> 60</td><td>  18</td><td> 1.1</td></tr>
  611.      * <tr><td style="background-color: #eeeeff; padding:5px">120</td><td>  72</td><td> 9.1</td></tr>
  612.      * <tr><td style="background-color: #eeeeff; padding:5px">300</td><td> 447</td><td> 140</td></tr>
  613.      * <tr><td style="background-color: #eeeeff; padding:5px">600</td><td>1601</td><td>1067</td></tr>
  614.      * <tr><td style="background-color: #eeeeff; padding:5px">900</td><td>3141</td><td>3307</td></tr>
  615.      * </table>
  616.      * @param dt time shift in seconds
  617.      * @return a new state, shifted with respect to the instance (which is immutable)
  618.      * except for the mass which stay unchanged
  619.      */
  620.     @Override
  621.     public FieldSpacecraftState<T> shiftedBy(final T dt) {
  622.         if (isOrbitDefined()) {
  623.             return new FieldSpacecraftState<>(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
  624.                                               mass, shiftAdditional(dt), additionalDot);
  625.         } else {
  626.             return new FieldSpacecraftState<>(absPva.shiftedBy(dt), attitude.shiftedBy(dt),
  627.                                               mass, shiftAdditional(dt), additionalDot);
  628.         }
  629.     }

  631.     /** Shift additional states.
  632.      * @param dt time shift in seconds
  633.      * @return shifted additional states
  634.      * @since 11.1.1
  635.      */
  636.     private FieldArrayDictionary<T> shiftAdditional(final double dt) {

  638.         // fast handling when there are no derivatives at all
  639.         if (additionalDot.size() == 0) {
  640.             return additional;
  641.         }

  643.         // there are derivatives, we need to take them into account in the additional state
  644.         final FieldArrayDictionary<T> shifted = new FieldArrayDictionary<>(additional);
  645.         for (final FieldArrayDictionary<T>.Entry dotEntry : additionalDot.getData()) {
  646.             final FieldArrayDictionary<T>.Entry entry = shifted.getEntry(dotEntry.getKey());
  647.             if (entry != null) {
  648.                 entry.scaledIncrement(dt, dotEntry);
  649.             }
  650.         }

  652.         return shifted;

  654.     }

  656.     /** Shift additional states.
  657.      * @param dt time shift in seconds
  658.      * @return shifted additional states
  659.      * @since 11.1.1
  660.      */
  661.     private FieldArrayDictionary<T> shiftAdditional(final T dt) {

  663.         // fast handling when there are no derivatives at all
  664.         if (additionalDot.size() == 0) {
  665.             return additional;
  666.         }

  668.         // there are derivatives, we need to take them into account in the additional state
  669.         final FieldArrayDictionary<T> shifted = new FieldArrayDictionary<>(additional);
  670.         for (final FieldArrayDictionary<T>.Entry dotEntry : additionalDot.getData()) {
  671.             final FieldArrayDictionary<T>.Entry entry = shifted.getEntry(dotEntry.getKey());
  672.             if (entry != null) {
  673.                 entry.scaledIncrement(dt, dotEntry);
  674.             }
  675.         }

  677.         return shifted;

  679.     }

  681.     /** Get the absolute position-velocity-acceleration.
  682.      * <p>
  683.      * A state contains either an {@link FieldAbsolutePVCoordinates absolute
  684.      * position-velocity-acceleration} or an {@link FieldOrbit orbit}. Which
  685.      * one is present can be checked using {@link #isOrbitDefined()}.
  686.      * </p>
  687.      * @return absolute position-velocity-acceleration
  688.      * @exception OrekitIllegalStateException if position-velocity-acceleration is null,
  689.      * which mean the state rather contains an {@link FieldOrbit}
  690.      * @see #isOrbitDefined()
  691.      * @see #getOrbit()
  692.      */
  693.     public FieldAbsolutePVCoordinates<T> getAbsPVA() throws OrekitIllegalStateException {
  694.         if (isOrbitDefined()) {
  695.             throw new OrekitIllegalStateException(OrekitMessages.UNDEFINED_ABSOLUTE_PVCOORDINATES);
  696.         }
  697.         return absPva;
  698.     }

  700.     /** Get the current orbit.
  701.      * <p>
  702.      * A state contains either an {@link FieldAbsolutePVCoordinates absolute
  703.      * position-velocity-acceleration} or an {@link FieldOrbit orbit}. Which
  704.      * one is present can be checked using {@link #isOrbitDefined()}.
  705.      * </p>
  706.      * @return the orbit
  707.      * @exception OrekitIllegalStateException if orbit is null,
  708.      * which means the state rather contains an {@link FieldAbsolutePVCoordinates absolute
  709.      * position-velocity-acceleration}
  710.      * @see #isOrbitDefined()
  711.      * @see #getAbsPVA()
  712.      */
  713.     public FieldOrbit<T> getOrbit() throws OrekitIllegalStateException {
  714.         if (orbit == null) {
  715.             throw new OrekitIllegalStateException(OrekitMessages.UNDEFINED_ORBIT);
  716.         }
  717.         return orbit;
  718.     }

  720.     /** {@inheritDoc} */
  721.     @Override
  722.     public FieldAbsoluteDate<T> getDate() {
  723.         return isOrbitDefined() ? orbit.getDate() : absPva.getDate();
  724.     }

  726.     /** Get the defining frame.
  727.      * @return the frame in which state is defined
  728.      */
  729.     public Frame getFrame() {
  730.         return isOrbitDefined() ? orbit.getFrame() : absPva.getFrame();
  731.     }


  734.     /** Check if an additional state is available.
  735.      * @param name name of the additional state
  736.      * @return true if the additional state is available
  737.      * @see #addAdditionalState(String, CalculusFieldElement...)
  738.      * @see #getAdditionalState(String)
  739.      * @see #getAdditionalStatesValues()
  740.      */
  741.     public boolean hasAdditionalState(final String name) {
  742.         return additional.getEntry(name) != null;
  743.     }

  745.     /** Check if an additional state derivative is available.
  746.      * @param name name of the additional state derivative
  747.      * @return true if the additional state derivative is available
  748.      * @see #addAdditionalStateDerivative(String, CalculusFieldElement...)
  749.      * @see #getAdditionalStateDerivative(String)
  750.      * @see #getAdditionalStatesDerivatives()
  751.      */
  752.     public boolean hasAdditionalStateDerivative(final String name) {
  753.         return additionalDot.getEntry(name) != null;
  754.     }

  756.     /** Check if two instances have the same set of additional states available.
  757.      * <p>
  758.      * Only the names and dimensions of the additional states are compared,
  759.      * not their values.
  760.      * </p>
  761.      * @param state state to compare to instance
  762.      * @exception MathIllegalArgumentException if an additional state does not have
  763.      * the same dimension in both states
  764.      */
  765.     public void ensureCompatibleAdditionalStates(final FieldSpacecraftState<T> state)
  766.         throws MathIllegalArgumentException {

  768.         // check instance additional states is a subset of the other one
  769.         for (final FieldArrayDictionary<T>.Entry entry : additional.getData()) {
  770.             final T[] other = state.additional.get(entry.getKey());
  771.             if (other == null) {
  772.                 throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  773.                                           entry.getKey());
  774.             }
  775.             if (other.length != entry.getValue().length) {
  776.                 throw new MathIllegalStateException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
  777.                                                     other.length, entry.getValue().length);
  778.             }
  779.         }

  781.         // check instance additional states derivatives is a subset of the other one
  782.         for (final FieldArrayDictionary<T>.Entry entry : additionalDot.getData()) {
  783.             final T[] other = state.additionalDot.get(entry.getKey());
  784.             if (other == null) {
  785.                 throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  786.                                           entry.getKey());
  787.             }
  788.             if (other.length != entry.getValue().length) {
  789.                 throw new MathIllegalStateException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
  790.                                                     other.length, entry.getValue().length);
  791.             }
  792.         }

  794.         if (state.additional.size() > additional.size()) {
  795.             // the other state has more additional states
  796.             for (final FieldArrayDictionary<T>.Entry entry : state.additional.getData()) {
  797.                 if (additional.getEntry(entry.getKey()) == null) {
  798.                     throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  799.                                               entry.getKey());
  800.                 }
  801.             }
  802.         }

  804.         if (state.additionalDot.size() > additionalDot.size()) {
  805.             // the other state has more additional states
  806.             for (final FieldArrayDictionary<T>.Entry entry : state.additionalDot.getData()) {
  807.                 if (additionalDot.getEntry(entry.getKey()) == null) {
  808.                     throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE,
  809.                                               entry.getKey());
  810.                 }
  811.             }
  812.         }

  814.     }

  816.     /** Get an additional state.
  817.      * @param name name of the additional state
  818.      * @return value of the additional state
  819.           * @see #addAdditionalState(String, CalculusFieldElement...)
  820.      * @see #hasAdditionalState(String)
  821.      * @see #getAdditionalStatesValues()
  822.      */
  823.     public T[] getAdditionalState(final String name) {
  824.         final FieldArrayDictionary<T>.Entry entry = additional.getEntry(name);
  825.         if (entry == null) {
  826.             throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE, name);
  827.         }
  828.         return entry.getValue();
  829.     }

  831.     /** Get an additional state derivative.
  832.      * @param name name of the additional state derivative
  833.      * @return value of the additional state derivative
  834.      * @see #addAdditionalStateDerivative(String, CalculusFieldElement...)
  835.      * @see #hasAdditionalStateDerivative(String)
  836.      * @see #getAdditionalStatesDerivatives()
  837.      * @since 11.1
  838.      */
  839.     public T[] getAdditionalStateDerivative(final String name) {
  840.         final FieldArrayDictionary<T>.Entry entry = additionalDot.getEntry(name);
  841.         if (entry == null) {
  842.             throw new OrekitException(OrekitMessages.UNKNOWN_ADDITIONAL_STATE, name);
  843.         }
  844.         return entry.getValue();
  845.     }

  847.     /** Get an unmodifiable map of additional states.
  848.      * @return unmodifiable map of additional states
  849.      * @see #addAdditionalState(String, CalculusFieldElement...)
  850.      * @see #hasAdditionalState(String)
  851.      * @see #getAdditionalState(String)
  852.      * @since 11.1
  853.      */
  854.     public FieldArrayDictionary<T> getAdditionalStatesValues() {
  855.         return additional.unmodifiableView();
  856.     }

  858.     /** Get an unmodifiable map of additional states derivatives.
  859.      * @return unmodifiable map of additional states derivatives
  860.      * @see #addAdditionalStateDerivative(String, CalculusFieldElement...)
  861.      * @see #hasAdditionalStateDerivative(String)
  862.      * @see #getAdditionalStateDerivative(String)
  863.     * @since 11.1
  864.       */
  865.     public FieldArrayDictionary<T> getAdditionalStatesDerivatives() {
  866.         return additionalDot.unmodifiableView();
  867.     }

  869.     /** Compute the transform from state defining frame to spacecraft frame.
  870.      * <p>The spacecraft frame origin is at the point defined by the orbit,
  871.      * and its orientation is defined by the attitude.</p>
  872.      * @return transform from specified frame to current spacecraft frame
  873.      */
  874.     public FieldTransform<T> toTransform() {
  875.         final TimeStampedFieldPVCoordinates<T> pv = getPVCoordinates();
  876.         return new FieldTransform<>(pv.getDate(),
  877.                                     new FieldTransform<>(pv.getDate(), pv.negate()),
  878.                                     new FieldTransform<>(pv.getDate(), attitude.getOrientation()));
  879.     }

  881.     /** Compute the static transform from state defining frame to spacecraft frame.
  882.      * @return static transform from specified frame to current spacecraft frame
  883.      * @see #toTransform()
  884.      * @since 12.0
  885.      */
  886.     public FieldStaticTransform<T> toStaticTransform() {
  887.         return FieldStaticTransform.of(getDate(), getPosition().negate(), attitude.getRotation());
  888.     }

  890.     /** Get the central attraction coefficient.
  891.      * @return mu central attraction coefficient (m^3/s^2), or {code Double.NaN} if the
  892.      * state contains an absolute position-velocity-acceleration rather than an orbit
  893.      */
  894.     public T getMu() {
  895.         return isOrbitDefined() ? orbit.getMu() : absPva.getDate().getField().getZero().add(Double.NaN);
  896.     }

  898.     /** Get the Keplerian period.
  899.      * <p>The Keplerian period is computed directly from semi major axis
  900.      * and central acceleration constant.</p>
  901.      * @return Keplerian period in seconds, or {code Double.NaN} if the
  902.      * state contains an absolute position-velocity-acceleration rather
  903.      * than an orbit
  904.      */
  905.     public T getKeplerianPeriod() {
  906.         return isOrbitDefined() ? orbit.getKeplerianPeriod() : absPva.getDate().getField().getZero().add(Double.NaN);
  907.     }

  909.     /** Get the Keplerian mean motion.
  910.      * <p>The Keplerian mean motion is computed directly from semi major axis
  911.      * and central acceleration constant.</p>
  912.      * @return Keplerian mean motion in radians per second, or {code Double.NaN} if the
  913.      * state contains an absolute position-velocity-acceleration rather
  914.      * than an orbit
  915.      */
  916.     public T getKeplerianMeanMotion() {
  917.         return isOrbitDefined() ? orbit.getKeplerianMeanMotion() : absPva.getDate().getField().getZero().add(Double.NaN);
  918.     }

  920.     /** Get the semi-major axis.
  921.      * @return semi-major axis (m), or {code Double.NaN} if the
  922.      * state contains an absolute position-velocity-acceleration rather
  923.      * than an orbit
  924.      */
  925.     public T getA() {
  926.         return isOrbitDefined() ? orbit.getA() : absPva.getDate().getField().getZero().add(Double.NaN);
  927.     }

  929.     /** Get the first component of the eccentricity vector (as per equinoctial parameters).
  930.      * @return e cos(ω + Ω), first component of eccentricity vector, or {code Double.NaN} if the
  931.      * state contains an absolute position-velocity-acceleration rather
  932.      * than an orbit
  933.      * @see #getE()
  934.      */
  935.     public T getEquinoctialEx() {
  936.         return isOrbitDefined() ? orbit.getEquinoctialEx() : absPva.getDate().getField().getZero().add(Double.NaN);
  937.     }

  939.     /** Get the second component of the eccentricity vector (as per equinoctial parameters).
  940.      * @return e sin(ω + Ω), second component of the eccentricity vector, or {code Double.NaN} if the
  941.      * state contains an absolute position-velocity-acceleration rather
  942.      * than an orbit
  943.      * @see #getE()
  944.      */
  945.     public T getEquinoctialEy() {
  946.         return isOrbitDefined() ? orbit.getEquinoctialEy() : absPva.getDate().getField().getZero().add(Double.NaN);
  947.     }

  949.     /** Get the first component of the inclination vector (as per equinoctial parameters).
  950.      * @return tan(i/2) cos(Ω), first component of the inclination vector, or {code Double.NaN} if the
  951.      * state contains an absolute position-velocity-acceleration rather
  952.      * than an orbit
  953.      * @see #getI()
  954.      */
  955.     public T getHx() {
  956.         return isOrbitDefined() ? orbit.getHx() : absPva.getDate().getField().getZero().add(Double.NaN);
  957.     }

  959.     /** Get the second component of the inclination vector (as per equinoctial parameters).
  960.      * @return tan(i/2) sin(Ω), second component of the inclination vector, or {code Double.NaN} if the
  961.      * state contains an absolute position-velocity-acceleration rather
  962.      * than an orbit
  963.      * @see #getI()
  964.      */
  965.     public T getHy() {
  966.         return isOrbitDefined() ? orbit.getHy() : absPva.getDate().getField().getZero().add(Double.NaN);
  967.     }

  969.     /** Get the true latitude argument (as per equinoctial parameters).
  970.      * @return v + ω + Ω true longitude argument (rad), or {code Double.NaN} if the
  971.      * state contains an absolute position-velocity-acceleration rather
  972.      * than an orbit
  973.      * @see #getLE()
  974.      * @see #getLM()
  975.      */
  976.     public T getLv() {
  977.         return isOrbitDefined() ? orbit.getLv() : absPva.getDate().getField().getZero().add(Double.NaN);
  978.     }

  980.     /** Get the eccentric latitude argument (as per equinoctial parameters).
  981.      * @return E + ω + Ω eccentric longitude argument (rad), or {code Double.NaN} if the
  982.      * state contains an absolute position-velocity-acceleration rather
  983.      * than an orbit
  984.      * @see #getLv()
  985.      * @see #getLM()
  986.      */
  987.     public T getLE() {
  988.         return isOrbitDefined() ? orbit.getLE() : absPva.getDate().getField().getZero().add(Double.NaN);
  989.     }

  991.     /** Get the mean longitude argument (as per equinoctial parameters).
  992.      * @return M + ω + Ω mean latitude argument (rad), or {code Double.NaN} if the
  993.      * state contains an absolute position-velocity-acceleration rather
  994.      * than an orbit
  995.      * @see #getLv()
  996.      * @see #getLE()
  997.      */
  998.     public T getLM() {
  999.         return isOrbitDefined() ? orbit.getLM() : absPva.getDate().getField().getZero().add(Double.NaN);
  1000.     }

  1002.     // Additional orbital elements

  1004.     /** Get the eccentricity.
  1005.      * @return eccentricity, or {code Double.NaN} if the
  1006.      * state contains an absolute position-velocity-acceleration rather
  1007.      * than an orbit
  1008.      * @see #getEquinoctialEx()
  1009.      * @see #getEquinoctialEy()
  1010.      */
  1011.     public T getE() {
  1012.         return isOrbitDefined() ? orbit.getE() : absPva.getDate().getField().getZero().add(Double.NaN);
  1013.     }

  1015.     /** Get the inclination.
  1016.      * @return inclination (rad)
  1017.      * @see #getHx()
  1018.      * @see #getHy()
  1019.      */
  1020.     public T getI() {
  1021.         return isOrbitDefined() ? orbit.getI() : absPva.getDate().getField().getZero().add(Double.NaN);
  1022.     }

  1024.     /** Get the position in orbit definition frame.
  1025.      * @return position in orbit definition frame
  1026.      * @since 12.0
  1027.      */
  1028.     public FieldVector3D<T> getPosition() {
  1029.         return isOrbitDefined() ? orbit.getPosition() : absPva.getPosition();
  1030.     }

  1032.     /** Get the {@link TimeStampedFieldPVCoordinates} in orbit definition frame.
  1033.      * <p>
  1034.      * Compute the position and velocity of the satellite. This method caches its
  1035.      * results, and recompute them only when the method is called with a new value
  1036.      * for mu. The result is provided as a reference to the internally cached
  1037.      * {@link TimeStampedFieldPVCoordinates}, so the caller is responsible to copy it in a separate
  1038.      * {@link TimeStampedFieldPVCoordinates} if it needs to keep the value for a while.
  1039.      * </p>
  1040.      * @return pvCoordinates in orbit definition frame
  1041.      */
  1042.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates() {
  1043.         return isOrbitDefined() ? orbit.getPVCoordinates() : absPva.getPVCoordinates();
  1044.     }

  1046.     /** Get the position in given output frame.
  1047.      * @param outputFrame frame in which position should be defined
  1048.      * @return position in given output frame
  1049.      * @since 12.0
  1050.      * @see #getPVCoordinates(Frame)
  1051.      */
  1052.     public FieldVector3D<T> getPosition(final Frame outputFrame) {
  1053.         return isOrbitDefined() ? orbit.getPosition(outputFrame) : absPva.getPosition(outputFrame);
  1054.     }

  1056.     /** Get the {@link TimeStampedFieldPVCoordinates} in given output frame.
  1057.      * <p>
  1058.      * Compute the position and velocity of the satellite. This method caches its
  1059.      * results, and recompute them only when the method is called with a new value
  1060.      * for mu. The result is provided as a reference to the internally cached
  1061.      * {@link TimeStampedFieldPVCoordinates}, so the caller is responsible to copy it in a separate
  1062.      * {@link TimeStampedFieldPVCoordinates} if it needs to keep the value for a while.
  1063.      * </p>
  1064.      * @param outputFrame frame in which coordinates should be defined
  1065.      * @return pvCoordinates in orbit definition frame
  1066.      */
  1067.     public TimeStampedFieldPVCoordinates<T> getPVCoordinates(final Frame outputFrame) {
  1068.         return isOrbitDefined() ? orbit.getPVCoordinates(outputFrame) : absPva.getPVCoordinates(outputFrame);
  1069.     }

  1071.     /** Get the attitude.
  1072.      * @return the attitude.
  1073.      */
  1074.     public FieldAttitude<T> getAttitude() {
  1075.         return attitude;
  1076.     }

  1078.     /** Gets the current mass.
  1079.      * @return the mass (kg)
  1080.      */
  1081.     public T getMass() {
  1082.         return mass;
  1083.     }

  1085.     /**To convert a FieldSpacecraftState instance into a SpacecraftState instance.
  1086.      *
  1087.      * @return SpacecraftState instance with the same properties
  1088.      */
  1089.     public SpacecraftState toSpacecraftState() {
  1090.         final DoubleArrayDictionary dictionary;
  1091.         if (additional.size() == 0) {
  1092.             dictionary = new DoubleArrayDictionary();
  1093.         } else {
  1094.             dictionary = new DoubleArrayDictionary(additional.size());
  1095.             for (final FieldArrayDictionary<T>.Entry entry : additional.getData()) {
  1096.                 final double[] array = new double[entry.getValue().length];
  1097.                 for (int k = 0; k < array.length; ++k) {
  1098.                     array[k] = entry.getValue()[k].getReal();
  1099.                 }
  1100.                 dictionary.put(entry.getKey(), array);
  1101.             }
  1102.         }
  1103.         final DoubleArrayDictionary dictionaryDot;
  1104.         if (additionalDot.size() == 0) {
  1105.             dictionaryDot = new DoubleArrayDictionary();
  1106.         } else {
  1107.             dictionaryDot = new DoubleArrayDictionary(additionalDot.size());
  1108.             for (final FieldArrayDictionary<T>.Entry entry : additionalDot.getData()) {
  1109.                 final double[] array = new double[entry.getValue().length];
  1110.                 for (int k = 0; k < array.length; ++k) {
  1111.                     array[k] = entry.getValue()[k].getReal();
  1112.                 }
  1113.                 dictionaryDot.put(entry.getKey(), array);
  1114.             }
  1115.         }
  1116.         if (isOrbitDefined()) {
  1117.             return new SpacecraftState(orbit.toOrbit(), attitude.toAttitude(),
  1118.                                        mass.getReal(), dictionary, dictionaryDot);
  1119.         } else {
  1120.             return new SpacecraftState(absPva.toAbsolutePVCoordinates(),
  1121.                                        attitude.toAttitude(), mass.getReal(),
  1122.                                        dictionary, dictionaryDot);
  1123.         }
  1124.     }

  1126.     @Override
  1127.     public String toString() {
  1128.         return "FieldSpacecraftState{" +
  1129.                 "orbit=" + orbit +
  1130.                 ", attitude=" + attitude +
  1131.                 ", mass=" + mass +
  1132.                 ", additional=" + additional +
  1133.                 ", additionalDot=" + additionalDot +
  1134.                 '}';
  1135.     }

  1137. }
Created with JaCoCo 0.8.11.202310140853