TimeStampedFieldAngularCoordinates.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.utils;

  19. import java.util.Collection;

  21. import org.hipparchus.Field;
  22. import org.hipparchus.RealFieldElement;
  23. import org.hipparchus.analysis.differentiation.DerivativeStructure;
  24. import org.hipparchus.analysis.differentiation.FieldDerivativeStructure;
  25. import org.hipparchus.analysis.interpolation.FieldHermiteInterpolator;
  26. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  27. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  28. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  29. import org.hipparchus.util.FastMath;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.errors.OrekitInternalError;
  32. import org.orekit.errors.OrekitMessages;
  33. import org.orekit.time.AbsoluteDate;
  34. import org.orekit.time.FieldAbsoluteDate;
  35. import org.orekit.time.TimeStamped;

  37. /** {@link TimeStamped time-stamped} version of {@link FieldAngularCoordinates}.
  38.  * <p>Instances of this class are guaranteed to be immutable.</p>
  39.  * @param <T> the type of the field elements
  40.  * @author Luc Maisonobe
  41.  * @since 7.0
  42.  */
  43. public class TimeStampedFieldAngularCoordinates<T extends RealFieldElement<T>>
  44.     extends FieldAngularCoordinates<T> {

  46.     /** The date. */
  47.     private final FieldAbsoluteDate<T> date;

  49.     /** Build the rotation that transforms a pair of pv coordinates into another pair.

  51.      * <p><em>WARNING</em>! This method requires much more stringent assumptions on
  52.      * its parameters than the similar {@link org.hipparchus.geometry.euclidean.threed.Rotation#Rotation(
  53.      * org.hipparchus.geometry.euclidean.threed.Vector3D, org.hipparchus.geometry.euclidean.threed.Vector3D,
  54.      * org.hipparchus.geometry.euclidean.threed.Vector3D, org.hipparchus.geometry.euclidean.threed.Vector3D)
  55.      * constructor} from the {@link org.hipparchus.geometry.euclidean.threed.Rotation Rotation} class.
  56.      * As far as the Rotation constructor is concerned, the {@code v₂} vector from
  57.      * the second pair can be slightly misaligned. The Rotation constructor will
  58.      * compensate for this misalignment and create a rotation that ensure {@code
  59.      * v₁ = r(u₁)} and {@code v₂ ∈ plane (r(u₁), r(u₂))}. <em>THIS IS NOT
  60.      * TRUE ANYMORE IN THIS CLASS</em>! As derivatives are involved and must be
  61.      * preserved, this constructor works <em>only</em> if the two pairs are fully
  62.      * consistent, i.e. if a rotation exists that fulfill all the requirements: {@code
  63.      * v₁ = r(u₁)}, {@code v₂ = r(u₂)}, {@code dv₁/dt = dr(u₁)/dt}, {@code dv₂/dt
  64.      * = dr(u₂)/dt}, {@code d²v₁/dt² = d²r(u₁)/dt²}, {@code d²v₂/dt² = d²r(u₂)/dt²}.</p>

  66.      * @param date coordinates date
  67.      * @param u1 first vector of the origin pair
  68.      * @param u2 second vector of the origin pair
  69.      * @param v1 desired image of u1 by the rotation
  70.      * @param v2 desired image of u2 by the rotation
  71.      * @param tolerance relative tolerance factor used to check singularities
  72.      * @exception OrekitException if the vectors components cannot be converted to
  73.      * {@link DerivativeStructure} with proper order
  74.      */
  75.     public TimeStampedFieldAngularCoordinates (final AbsoluteDate date,
  76.                                                final FieldPVCoordinates<T> u1, final FieldPVCoordinates<T> u2,
  77.                                                final FieldPVCoordinates<T> v1, final FieldPVCoordinates<T> v2,
  78.                                                final double tolerance)
  79.         throws OrekitException {
  80.         this(new FieldAbsoluteDate<>(u1.getPosition().getX().getField(), date),
  81.              u1, u2, v1, v2, tolerance);
  82.     }

  84.     /** Build the rotation that transforms a pair of pv coordinates into another pair.

  86.      * <p><em>WARNING</em>! This method requires much more stringent assumptions on
  87.      * its parameters than the similar {@link org.hipparchus.geometry.euclidean.threed.Rotation#Rotation(
  88.      * org.hipparchus.geometry.euclidean.threed.Vector3D, org.hipparchus.geometry.euclidean.threed.Vector3D,
  89.      * org.hipparchus.geometry.euclidean.threed.Vector3D, org.hipparchus.geometry.euclidean.threed.Vector3D)
  90.      * constructor} from the {@link org.hipparchus.geometry.euclidean.threed.Rotation Rotation} class.
  91.      * As far as the Rotation constructor is concerned, the {@code v₂} vector from
  92.      * the second pair can be slightly misaligned. The Rotation constructor will
  93.      * compensate for this misalignment and create a rotation that ensure {@code
  94.      * v₁ = r(u₁)} and {@code v₂ ∈ plane (r(u₁), r(u₂))}. <em>THIS IS NOT
  95.      * TRUE ANYMORE IN THIS CLASS</em>! As derivatives are involved and must be
  96.      * preserved, this constructor works <em>only</em> if the two pairs are fully
  97.      * consistent, i.e. if a rotation exists that fulfill all the requirements: {@code
  98.      * v₁ = r(u₁)}, {@code v₂ = r(u₂)}, {@code dv₁/dt = dr(u₁)/dt}, {@code dv₂/dt
  99.      * = dr(u₂)/dt}, {@code d²v₁/dt² = d²r(u₁)/dt²}, {@code d²v₂/dt² = d²r(u₂)/dt²}.</p>

  101.      * @param date coordinates date
  102.      * @param u1 first vector of the origin pair
  103.      * @param u2 second vector of the origin pair
  104.      * @param v1 desired image of u1 by the rotation
  105.      * @param v2 desired image of u2 by the rotation
  106.      * @param tolerance relative tolerance factor used to check singularities
  107.      * @exception OrekitException if the vectors components cannot be converted to
  108.      * {@link DerivativeStructure} with proper order
  109.      */
  110.     public TimeStampedFieldAngularCoordinates (final FieldAbsoluteDate<T> date,
  111.                                                final FieldPVCoordinates<T> u1, final FieldPVCoordinates<T> u2,
  112.                                                final FieldPVCoordinates<T> v1, final FieldPVCoordinates<T> v2,
  113.                                                final double tolerance)
  114.         throws OrekitException {
  115.         super(u1, u2, v1, v2, tolerance);
  116.         this.date = date;
  117.     }

  119.     /** Builds a rotation/rotation rate pair.
  120.      * @param date coordinates date
  121.      * @param rotation rotation
  122.      * @param rotationRate rotation rate Ω (rad/s)
  123.      * @param rotationAcceleration rotation acceleration dΩ/dt (rad²/s²)
  124.      */
  125.     public TimeStampedFieldAngularCoordinates(final AbsoluteDate date,
  126.                                               final FieldRotation<T> rotation,
  127.                                               final FieldVector3D<T> rotationRate,
  128.                                               final FieldVector3D<T> rotationAcceleration) {
  129.         this(new FieldAbsoluteDate<>(rotation.getQ0().getField(), date),
  130.              rotation, rotationRate, rotationAcceleration);
  131.     }

  133.     /** Builds a rotation/rotation rate pair.
  134.      * @param date coordinates date
  135.      * @param rotation rotation
  136.      * @param rotationRate rotation rate Ω (rad/s)
  137.      * @param rotationAcceleration rotation acceleration dΩ/dt (rad²/s²)
  138.      */
  139.     public TimeStampedFieldAngularCoordinates(final FieldAbsoluteDate<T> date,
  140.                                               final FieldRotation<T> rotation,
  141.                                               final FieldVector3D<T> rotationRate,
  142.                                               final FieldVector3D<T> rotationAcceleration) {
  143.         super(rotation, rotationRate, rotationAcceleration);
  144.         this.date = date;
  145.     }

  147.     /** Builds an instance for a regular {@link TimeStampedAngularCoordinates}.
  148.      * @param field fields to which the elements belong
  149.      * @param ac coordinates to convert
  150.      * @since 9.0
  151.      */
  152.     public TimeStampedFieldAngularCoordinates(final Field<T> field,
  153.                                               final TimeStampedAngularCoordinates ac) {
  154.         this(new FieldAbsoluteDate<>(field, ac.getDate()),
  155.              new FieldRotation<>(field, ac.getRotation()),
  156.              new FieldVector3D<>(field, ac.getRotationRate()),
  157.              new FieldVector3D<>(field, ac.getRotationAcceleration()));
  158.     }

  160.     /** Builds a TimeStampedFieldAngularCoordinates from  a {@link FieldRotation}&lt;{@link FieldDerivativeStructure}&gt;.
  161.      * <p>
  162.      * The rotation components must have time as their only derivation parameter and
  163.      * have consistent derivation orders.
  164.      * </p>
  165.      * @param date coordinates date
  166.      * @param r rotation with time-derivatives embedded within the coordinates
  167.      * @since 9.2
  168.      */
  169.     public TimeStampedFieldAngularCoordinates(final FieldAbsoluteDate<T> date,
  170.                                               final FieldRotation<FieldDerivativeStructure<T>> r) {
  171.         super(r);
  172.         this.date = date;
  173.     }

  175.     /** Revert a rotation/rotation rate pair.
  176.      * Build a pair which reverse the effect of another pair.
  177.      * @return a new pair whose effect is the reverse of the effect
  178.      * of the instance
  179.      */
  180.     public TimeStampedFieldAngularCoordinates<T> revert() {
  181.         return new TimeStampedFieldAngularCoordinates<>(date,
  182.                                                         getRotation().revert(),
  183.                                                         getRotation().applyInverseTo(getRotationRate().negate()),
  184.                                                         getRotation().applyInverseTo(getRotationAcceleration().negate()));
  185.     }

  187.     /** Get the date.
  188.      * @return date
  189.      */
  190.     public FieldAbsoluteDate<T> getDate() {
  191.         return date;
  192.     }

  194.     /** Get a time-shifted state.
  195.      * <p>
  196.      * The state can be slightly shifted to close dates. This shift is based on
  197.      * a simple linear model. It is <em>not</em> intended as a replacement for
  198.      * proper attitude propagation but should be sufficient for either small
  199.      * time shifts or coarse accuracy.
  200.      * </p>
  201.      * @param dt time shift in seconds
  202.      * @return a new state, shifted with respect to the instance (which is immutable)
  203.      */
  204.     public TimeStampedFieldAngularCoordinates<T> shiftedBy(final double dt) {
  205.         return shiftedBy(getDate().getField().getZero().add(dt));
  206.     }

  208.     /** Get a time-shifted state.
  209.      * <p>
  210.      * The state can be slightly shifted to close dates. This shift is based on
  211.      * a simple linear model. It is <em>not</em> intended as a replacement for
  212.      * proper attitude propagation but should be sufficient for either small
  213.      * time shifts or coarse accuracy.
  214.      * </p>
  215.      * @param dt time shift in seconds
  216.      * @return a new state, shifted with respect to the instance (which is immutable)
  217.      */
  218.     public TimeStampedFieldAngularCoordinates<T> shiftedBy(final T dt) {
  219.         final FieldAngularCoordinates<T> sac = super.shiftedBy(dt);
  220.         return new TimeStampedFieldAngularCoordinates<>(date.shiftedBy(dt),
  221.                                                         sac.getRotation(), sac.getRotationRate(), sac.getRotationAcceleration());

  223.     }

  225.     /** Add an offset from the instance.
  226.      * <p>
  227.      * We consider here that the offset rotation is applied first and the
  228.      * instance is applied afterward. Note that angular coordinates do <em>not</em>
  229.      * commute under this operation, i.e. {@code a.addOffset(b)} and {@code
  230.      * b.addOffset(a)} lead to <em>different</em> results in most cases.
  231.      * </p>
  232.      * <p>
  233.      * The two methods {@link #addOffset(FieldAngularCoordinates) addOffset} and
  234.      * {@link #subtractOffset(FieldAngularCoordinates) subtractOffset} are designed
  235.      * so that round trip applications are possible. This means that both {@code
  236.      * ac1.subtractOffset(ac2).addOffset(ac2)} and {@code
  237.      * ac1.addOffset(ac2).subtractOffset(ac2)} return angular coordinates equal to ac1.
  238.      * </p>
  239.      * @param offset offset to subtract
  240.      * @return new instance, with offset subtracted
  241.      * @see #subtractOffset(FieldAngularCoordinates)
  242.      */
  243.     public TimeStampedFieldAngularCoordinates<T> addOffset(final FieldAngularCoordinates<T> offset) {
  244.         final FieldVector3D<T> rOmega    = getRotation().applyTo(offset.getRotationRate());
  245.         final FieldVector3D<T> rOmegaDot = getRotation().applyTo(offset.getRotationAcceleration());
  246.         return new TimeStampedFieldAngularCoordinates<>(date,
  247.                                                         getRotation().compose(offset.getRotation(), RotationConvention.VECTOR_OPERATOR),
  248.                                                         getRotationRate().add(rOmega),
  249.                                                         new FieldVector3D<>( 1.0, getRotationAcceleration(),
  250.                                                                               1.0, rOmegaDot,
  251.                                                                              -1.0, FieldVector3D.crossProduct(getRotationRate(), rOmega)));
  252.     }

  254.     /** Subtract an offset from the instance.
  255.      * <p>
  256.      * We consider here that the offset Rotation is applied first and the
  257.      * instance is applied afterward. Note that angular coordinates do <em>not</em>
  258.      * commute under this operation, i.e. {@code a.subtractOffset(b)} and {@code
  259.      * b.subtractOffset(a)} lead to <em>different</em> results in most cases.
  260.      * </p>
  261.      * <p>
  262.      * The two methods {@link #addOffset(FieldAngularCoordinates) addOffset} and
  263.      * {@link #subtractOffset(FieldAngularCoordinates) subtractOffset} are designed
  264.      * so that round trip applications are possible. This means that both {@code
  265.      * ac1.subtractOffset(ac2).addOffset(ac2)} and {@code
  266.      * ac1.addOffset(ac2).subtractOffset(ac2)} return angular coordinates equal to ac1.
  267.      * </p>
  268.      * @param offset offset to subtract
  269.      * @return new instance, with offset subtracted
  270.      * @see #addOffset(FieldAngularCoordinates)
  271.      */
  272.     public TimeStampedFieldAngularCoordinates<T> subtractOffset(final FieldAngularCoordinates<T> offset) {
  273.         return addOffset(offset.revert());
  274.     }

  276.     /** Interpolate angular coordinates.
  277.      * <p>
  278.      * The interpolated instance is created by polynomial Hermite interpolation
  279.      * on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.
  280.      * </p>
  281.      * <p>
  282.      * This method is based on Sergei Tanygin's paper <a
  283.      * href="http://www.agi.com/downloads/resources/white-papers/Attitude-interpolation.pdf">Attitude
  284.      * Interpolation</a>, changing the norm of the vector to match the modified Rodrigues
  285.      * vector as described in Malcolm D. Shuster's paper <a
  286.      * href="http://www.ladispe.polito.it/corsi/Meccatronica/02JHCOR/2011-12/Slides/Shuster_Pub_1993h_J_Repsurv_scan.pdf">A
  287.      * Survey of Attitude Representations</a>. This change avoids the singularity at π.
  288.      * There is still a singularity at 2π, which is handled by slightly offsetting all rotations
  289.      * when this singularity is detected.
  290.      * </p>
  291.      * <p>
  292.      * Note that even if first time derivatives (rotation rates)
  293.      * from sample can be ignored, the interpolated instance always includes
  294.      * interpolated derivatives. This feature can be used explicitly to
  295.      * compute these derivatives when it would be too complex to compute them
  296.      * from an analytical formula: just compute a few sample points from the
  297.      * explicit formula and set the derivatives to zero in these sample points,
  298.      * then use interpolation to add derivatives consistent with the rotations.
  299.      * </p>
  300.      * @param date interpolation date
  301.      * @param filter filter for derivatives from the sample to use in interpolation
  302.      * @param sample sample points on which interpolation should be done
  303.      * @param <T> the type of the field elements
  304.      * @return a new position-velocity, interpolated at specified date
  305.      * @exception OrekitException if the number of point is too small for interpolating
  306.      */
  307.     public static <T extends RealFieldElement<T>>
  308.         TimeStampedFieldAngularCoordinates<T> interpolate(final AbsoluteDate date,
  309.                                                           final AngularDerivativesFilter filter,
  310.                                                           final Collection<TimeStampedFieldAngularCoordinates<T>> sample)
  311.         throws OrekitException {
  312.         return interpolate(new FieldAbsoluteDate<>(sample.iterator().next().getRotation().getQ0().getField(), date),
  313.                            filter, sample);
  314.     }

  316.     /** Interpolate angular coordinates.
  317.      * <p>
  318.      * The interpolated instance is created by polynomial Hermite interpolation
  319.      * on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.
  320.      * </p>
  321.      * <p>
  322.      * This method is based on Sergei Tanygin's paper <a
  323.      * href="http://www.agi.com/downloads/resources/white-papers/Attitude-interpolation.pdf">Attitude
  324.      * Interpolation</a>, changing the norm of the vector to match the modified Rodrigues
  325.      * vector as described in Malcolm D. Shuster's paper <a
  326.      * href="http://www.ladispe.polito.it/corsi/Meccatronica/02JHCOR/2011-12/Slides/Shuster_Pub_1993h_J_Repsurv_scan.pdf">A
  327.      * Survey of Attitude Representations</a>. This change avoids the singularity at π.
  328.      * There is still a singularity at 2π, which is handled by slightly offsetting all rotations
  329.      * when this singularity is detected.
  330.      * </p>
  331.      * <p>
  332.      * Note that even if first time derivatives (rotation rates)
  333.      * from sample can be ignored, the interpolated instance always includes
  334.      * interpolated derivatives. This feature can be used explicitly to
  335.      * compute these derivatives when it would be too complex to compute them
  336.      * from an analytical formula: just compute a few sample points from the
  337.      * explicit formula and set the derivatives to zero in these sample points,
  338.      * then use interpolation to add derivatives consistent with the rotations.
  339.      * </p>
  340.      * @param date interpolation date
  341.      * @param filter filter for derivatives from the sample to use in interpolation
  342.      * @param sample sample points on which interpolation should be done
  343.      * @param <T> the type of the field elements
  344.      * @return a new position-velocity, interpolated at specified date
  345.      * @exception OrekitException if the number of point is too small for interpolating
  346.      */
  347.     public static <T extends RealFieldElement<T>>
  348.         TimeStampedFieldAngularCoordinates<T> interpolate(final FieldAbsoluteDate<T> date,
  349.                                                           final AngularDerivativesFilter filter,
  350.                                                           final Collection<TimeStampedFieldAngularCoordinates<T>> sample)
  351.         throws OrekitException {

  353.         // get field properties
  354.         final Field<T> field = sample.iterator().next().getRotation().getQ0().getField();

  356.         // set up safety elements for 2π singularity avoidance
  357.         final double epsilon   = 2 * FastMath.PI / sample.size();
  358.         final double threshold = FastMath.min(-(1.0 - 1.0e-4), -FastMath.cos(epsilon / 4));

  360.         // set up a linear model canceling mean rotation rate
  361.         final FieldVector3D<T> meanRate;
  362.         if (filter != AngularDerivativesFilter.USE_R) {
  363.             FieldVector3D<T> sum = FieldVector3D.getZero(field);
  364.             for (final TimeStampedFieldAngularCoordinates<T> datedAC : sample) {
  365.                 sum = sum.add(datedAC.getRotationRate());
  366.             }
  367.             meanRate = new FieldVector3D<>(1.0 / sample.size(), sum);
  368.         } else {
  369.             if (sample.size() < 2) {
  370.                 throw new OrekitException(OrekitMessages.NOT_ENOUGH_DATA_FOR_INTERPOLATION,
  371.                                           sample.size());
  372.             }
  373.             FieldVector3D<T> sum = FieldVector3D.getZero(field);
  374.             TimeStampedFieldAngularCoordinates<T> previous = null;
  375.             for (final TimeStampedFieldAngularCoordinates<T> datedAC : sample) {
  376.                 if (previous != null) {
  377.                     sum = sum.add(estimateRate(previous.getRotation(), datedAC.getRotation(),
  378.                                                datedAC.date.durationFrom(previous.getDate())));
  379.                 }
  380.                 previous = datedAC;
  381.             }
  382.             meanRate = new FieldVector3D<>(1.0 / (sample.size() - 1), sum);
  383.         }
  384.         TimeStampedFieldAngularCoordinates<T> offset =
  385.                 new TimeStampedFieldAngularCoordinates<>(date, FieldRotation.getIdentity(field),
  386.                                                          meanRate, FieldVector3D.getZero(field));

  388.         boolean restart = true;
  389.         for (int i = 0; restart && i < sample.size() + 2; ++i) {

  391.             // offset adaptation parameters
  392.             restart = false;

  394.             // set up an interpolator taking derivatives into account
  395.             final FieldHermiteInterpolator<T> interpolator = new FieldHermiteInterpolator<>();

  397.             // add sample points
  398.             double sign = +1.0;
  399.             FieldRotation<T> previous = FieldRotation.getIdentity(field);

  401.             for (final TimeStampedFieldAngularCoordinates<T> ac : sample) {

  403.                 // remove linear offset from the current coordinates
  404.                 final T dt = ac.date.durationFrom(date);
  405.                 final TimeStampedFieldAngularCoordinates<T> fixed = ac.subtractOffset(offset.shiftedBy(dt));

  407.                 // make sure all interpolated points will be on the same branch
  408.                 final T dot = dt.linearCombination(fixed.getRotation().getQ0(), previous.getQ0(),
  409.                                                    fixed.getRotation().getQ1(), previous.getQ1(),
  410.                                                    fixed.getRotation().getQ2(), previous.getQ2(),
  411.                                                    fixed.getRotation().getQ3(), previous.getQ3());
  412.                 sign = FastMath.copySign(1.0, dot.getReal() * sign);
  413.                 previous = fixed.getRotation();

  415.                 // check modified Rodrigues vector singularity
  416.                 if (fixed.getRotation().getQ0().getReal() * sign < threshold) {
  417.                     // the sample point is close to a modified Rodrigues vector singularity
  418.                     // we need to change the linear offset model to avoid this
  419.                     restart = true;
  420.                     break;
  421.                 }

  423.                 final T[][] rodrigues = fixed.getModifiedRodrigues(sign);
  424.                 switch (filter) {
  425.                     case USE_RRA:
  426.                         // populate sample with rotation, rotation rate and acceleration data
  427.                         interpolator.addSamplePoint(dt, rodrigues[0], rodrigues[1], rodrigues[2]);
  428.                         break;
  429.                     case USE_RR:
  430.                         // populate sample with rotation and rotation rate data
  431.                         interpolator.addSamplePoint(dt, rodrigues[0], rodrigues[1]);
  432.                         break;
  433.                     case USE_R:
  434.                         // populate sample with rotation data only
  435.                         interpolator.addSamplePoint(dt, rodrigues[0]);
  436.                         break;
  437.                     default :
  438.                         // this should never happen
  439.                         throw new OrekitInternalError(null);
  440.                 }
  441.             }

  443.             if (restart) {
  444.                 // interpolation failed, some intermediate rotation was too close to 2π
  445.                 // we need to offset all rotations to avoid the singularity
  446.                 offset = offset.addOffset(new FieldAngularCoordinates<>(new FieldRotation<>(FieldVector3D.getPlusI(field),
  447.                                                                                             field.getZero().add(epsilon),
  448.                                                                                             RotationConvention.VECTOR_OPERATOR),
  449.                                                                         FieldVector3D.getZero(field),
  450.                                                                         FieldVector3D.getZero(field)));
  451.             } else {
  452.                 // interpolation succeeded with the current offset
  453.                 final T[][] p = interpolator.derivatives(field.getZero(), 2);
  454.                 final FieldAngularCoordinates<T> ac = createFromModifiedRodrigues(p);
  455.                 return new TimeStampedFieldAngularCoordinates<>(offset.getDate(),
  456.                                                                 ac.getRotation(),
  457.                                                                 ac.getRotationRate(),
  458.                                                                 ac.getRotationAcceleration()).addOffset(offset);
  459.             }

  461.         }

  463.         // this should never happen
  464.         throw new OrekitInternalError(null);

  466.     }

  468. }
Created with JaCoCo 0.7.9.201702052155