TimeStampedFieldPVCoordinates.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.utils;

  19. import java.util.Collection;
  20. import java.util.stream.Stream;

  22. import org.hipparchus.RealFieldElement;
  23. import org.hipparchus.analysis.differentiation.FieldDerivativeStructure;
  24. import org.hipparchus.analysis.interpolation.FieldHermiteInterpolator;
  25. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  26. import org.orekit.annotation.DefaultDataContext;
  27. import org.orekit.data.DataContext;
  28. import org.orekit.errors.OrekitInternalError;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.FieldAbsoluteDate;
  31. import org.orekit.time.TimeScale;
  32. import org.orekit.time.TimeStamped;

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

  43.     /** The date. */
  44.     private final FieldAbsoluteDate<T> date;

  46.     /** Builds a PVCoordinates pair.
  47.      * @param date coordinates date
  48.      * @param position the position vector (m)
  49.      * @param velocity the velocity vector (m/s)
  50.      * @param acceleration the acceleration vector (m/s²)
  51.      */
  52.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  53.                                          final FieldVector3D<T> position,
  54.                                          final FieldVector3D<T> velocity,
  55.                                          final FieldVector3D<T> acceleration) {
  56.         this(new FieldAbsoluteDate<>(position.getX().getField(), date),
  57.              position, velocity, acceleration);
  58.     }

  60.     /** Builds a PVCoordinates pair.
  61.      * @param date coordinates date
  62.      * @param position the position vector (m)
  63.      * @param velocity the velocity vector (m/s)
  64.      * @param acceleration the acceleration vector (m/s²)
  65.      */
  66.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  67.                                          final FieldVector3D<T> position,
  68.                                          final FieldVector3D<T> velocity,
  69.                                          final FieldVector3D<T> acceleration) {
  70.         super(position, velocity, acceleration);
  71.         this.date = date;
  72.     }

  74.     /** Basic constructor.
  75.      * <p>Build a PVCoordinates from another one at a given date</p>
  76.      * <p>The PVCoordinates built will be pv</p>
  77.      * @param date date of the built coordinates
  78.      * @param pv base (unscaled) PVCoordinates
  79.      */
  80.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date, final FieldPVCoordinates<T> pv) {
  81.         this(new FieldAbsoluteDate<>(pv.getPosition().getX().getField(), date), pv);
  82.     }

  84.     /** Basic constructor.
  85.      * <p>Build a PVCoordinates from another one at a given date</p>
  86.      * <p>The PVCoordinates built will be pv</p>
  87.      * @param date date of the built coordinates
  88.      * @param pv base (unscaled) PVCoordinates
  89.      */
  90.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date, final FieldPVCoordinates<T> pv) {
  91.         super(pv.getPosition(),
  92.               pv.getVelocity(),
  93.               pv.getAcceleration());
  94.         this.date = date;
  95.     }

  97.     /** Multiplicative constructor
  98.      * <p>Build a PVCoordinates from another one and a scale factor.</p>
  99.      * <p>The PVCoordinates built will be a * pv</p>
  100.      * @param date date of the built coordinates
  101.      * @param a scale factor
  102.      * @param pv base (unscaled) PVCoordinates
  103.      */
  104.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  105.                                          final double a, final FieldPVCoordinates<T> pv) {
  106.         this(new FieldAbsoluteDate<>(pv.getPosition().getX().getField(), date), a, pv);
  107.     }

  109.     /** Multiplicative constructor
  110.      * <p>Build a PVCoordinates from another one and a scale factor.</p>
  111.      * <p>The PVCoordinates built will be a * pv</p>
  112.      * @param date date of the built coordinates
  113.      * @param a scale factor
  114.      * @param pv base (unscaled) PVCoordinates
  115.      */
  116.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  117.                                          final double a, final FieldPVCoordinates<T> pv) {
  118.         super(new FieldVector3D<>(a, pv.getPosition()),
  119.               new FieldVector3D<>(a, pv.getVelocity()),
  120.               new FieldVector3D<>(a, pv.getAcceleration()));
  121.         this.date = date;
  122.     }

  124.     /** Multiplicative constructor
  125.      * <p>Build a PVCoordinates from another one and a scale factor.</p>
  126.      * <p>The PVCoordinates built will be a * pv</p>
  127.      * @param date date of the built coordinates
  128.      * @param a scale factor
  129.      * @param pv base (unscaled) PVCoordinates
  130.      */
  131.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  132.                                          final T a, final FieldPVCoordinates<T> pv) {
  133.         this(new FieldAbsoluteDate<>(a.getField(), date), a, pv);
  134.     }

  136.     /** Multiplicative constructor
  137.      * <p>Build a PVCoordinates from another one and a scale factor.</p>
  138.      * <p>The PVCoordinates built will be a * pv</p>
  139.      * @param date date of the built coordinates
  140.      * @param a scale factor
  141.      * @param pv base (unscaled) PVCoordinates
  142.      */
  143.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  144.                                          final T a, final FieldPVCoordinates<T> pv) {
  145.         super(new FieldVector3D<>(a, pv.getPosition()),
  146.               new FieldVector3D<>(a, pv.getVelocity()),
  147.               new FieldVector3D<>(a, pv.getAcceleration()));
  148.         this.date = date;
  149.     }

  151.     /** Multiplicative constructor
  152.      * <p>Build a PVCoordinates from another one and a scale factor.</p>
  153.      * <p>The PVCoordinates built will be a * pv</p>
  154.      * @param date date of the built coordinates
  155.      * @param a scale factor
  156.      * @param pv base (unscaled) PVCoordinates
  157.      */
  158.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  159.                                          final T a, final PVCoordinates pv) {
  160.         this(new FieldAbsoluteDate<>(a.getField(), date), a, pv);
  161.     }

  163.     /** Multiplicative constructor
  164.      * <p>Build a PVCoordinates from another one and a scale factor.</p>
  165.      * <p>The PVCoordinates built will be a * pv</p>
  166.      * @param date date of the built coordinates
  167.      * @param a scale factor
  168.      * @param pv base (unscaled) PVCoordinates
  169.      */
  170.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  171.                                          final T a, final PVCoordinates pv) {
  172.         super(new FieldVector3D<>(a, pv.getPosition()),
  173.               new FieldVector3D<>(a, pv.getVelocity()),
  174.               new FieldVector3D<>(a, pv.getAcceleration()));
  175.         this.date = date;
  176.     }

  178.     /** Subtractive constructor
  179.      * <p>Build a relative PVCoordinates from a start and an end position.</p>
  180.      * <p>The PVCoordinates built will be end - start.</p>
  181.      * @param date date of the built coordinates
  182.      * @param start Starting PVCoordinates
  183.      * @param end ending PVCoordinates
  184.      */
  185.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  186.                                          final FieldPVCoordinates<T> start, final FieldPVCoordinates<T> end) {
  187.         this(new FieldAbsoluteDate<>(start.getPosition().getX().getField(), date), start, end);
  188.     }

  190.     /** Subtractive constructor
  191.      * <p>Build a relative PVCoordinates from a start and an end position.</p>
  192.      * <p>The PVCoordinates built will be end - start.</p>
  193.      * @param date date of the built coordinates
  194.      * @param start Starting PVCoordinates
  195.      * @param end ending PVCoordinates
  196.      */
  197.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  198.                                          final FieldPVCoordinates<T> start, final FieldPVCoordinates<T> end) {
  199.         super(end.getPosition().subtract(start.getPosition()),
  200.               end.getVelocity().subtract(start.getVelocity()),
  201.               end.getAcceleration().subtract(start.getAcceleration()));
  202.         this.date = date;
  203.     }

  205.     /** Linear constructor
  206.      * <p>Build a PVCoordinates from two other ones and corresponding scale factors.</p>
  207.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2</p>
  208.      * @param date date of the built coordinates
  209.      * @param a1 first scale factor
  210.      * @param pv1 first base (unscaled) PVCoordinates
  211.      * @param a2 second scale factor
  212.      * @param pv2 second base (unscaled) PVCoordinates
  213.      */
  214.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  215.                                          final double a1, final FieldPVCoordinates<T> pv1,
  216.                                          final double a2, final FieldPVCoordinates<T> pv2) {
  217.         this(new FieldAbsoluteDate<>(pv1.getPosition().getX().getField(), date),
  218.              a1, pv1, a2, pv2);
  219.     }

  221.     /** Linear constructor
  222.      * <p>Build a PVCoordinates from two other ones and corresponding scale factors.</p>
  223.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2</p>
  224.      * @param date date of the built coordinates
  225.      * @param a1 first scale factor
  226.      * @param pv1 first base (unscaled) PVCoordinates
  227.      * @param a2 second scale factor
  228.      * @param pv2 second base (unscaled) PVCoordinates
  229.      */
  230.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  231.                                          final double a1, final FieldPVCoordinates<T> pv1,
  232.                                          final double a2, final FieldPVCoordinates<T> pv2) {
  233.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition()),
  234.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity()),
  235.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration()));
  236.         this.date = date;
  237.     }

  239.     /** Linear constructor
  240.      * <p>Build a PVCoordinates from two other ones and corresponding scale factors.</p>
  241.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2</p>
  242.      * @param date date of the built coordinates
  243.      * @param a1 first scale factor
  244.      * @param pv1 first base (unscaled) PVCoordinates
  245.      * @param a2 second scale factor
  246.      * @param pv2 second base (unscaled) PVCoordinates
  247.      */
  248.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  249.                                          final T a1, final FieldPVCoordinates<T> pv1,
  250.                                          final T a2, final FieldPVCoordinates<T> pv2) {
  251.         this(new FieldAbsoluteDate<>(a1.getField(), date),
  252.              a1, pv1, a2, pv2);
  253.     }

  255.     /** Linear constructor
  256.      * <p>Build a PVCoordinates from two other ones and corresponding scale factors.</p>
  257.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2</p>
  258.      * @param date date of the built coordinates
  259.      * @param a1 first scale factor
  260.      * @param pv1 first base (unscaled) PVCoordinates
  261.      * @param a2 second scale factor
  262.      * @param pv2 second base (unscaled) PVCoordinates
  263.      */
  264.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  265.                                          final T a1, final FieldPVCoordinates<T> pv1,
  266.                                          final T a2, final FieldPVCoordinates<T> pv2) {
  267.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition()),
  268.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity()),
  269.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration()));
  270.         this.date = date;
  271.     }

  273.     /** Linear constructor
  274.      * <p>Build a PVCoordinates from two other ones and corresponding scale factors.</p>
  275.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2</p>
  276.      * @param date date of the built coordinates
  277.      * @param a1 first scale factor
  278.      * @param pv1 first base (unscaled) PVCoordinates
  279.      * @param a2 second scale factor
  280.      * @param pv2 second base (unscaled) PVCoordinates
  281.      */
  282.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  283.                                          final T a1, final PVCoordinates pv1,
  284.                                          final T a2, final PVCoordinates pv2) {
  285.         this(new FieldAbsoluteDate<>(a1.getField(), date),
  286.              a1, pv1, a2, pv2);
  287.     }

  289.     /** Linear constructor
  290.      * <p>Build a PVCoordinates from two other ones and corresponding scale factors.</p>
  291.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2</p>
  292.      * @param date date of the built coordinates
  293.      * @param a1 first scale factor
  294.      * @param pv1 first base (unscaled) PVCoordinates
  295.      * @param a2 second scale factor
  296.      * @param pv2 second base (unscaled) PVCoordinates
  297.      */
  298.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  299.                                          final T a1, final PVCoordinates pv1,
  300.                                          final T a2, final PVCoordinates pv2) {
  301.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition()),
  302.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity()),
  303.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration()));
  304.         this.date = date;
  305.     }

  307.     /** Linear constructor
  308.      * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
  309.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
  310.      * @param date date of the built coordinates
  311.      * @param a1 first scale factor
  312.      * @param pv1 first base (unscaled) PVCoordinates
  313.      * @param a2 second scale factor
  314.      * @param pv2 second base (unscaled) PVCoordinates
  315.      * @param a3 third scale factor
  316.      * @param pv3 third base (unscaled) PVCoordinates
  317.      */
  318.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  319.                                          final double a1, final FieldPVCoordinates<T> pv1,
  320.                                          final double a2, final FieldPVCoordinates<T> pv2,
  321.                                          final double a3, final FieldPVCoordinates<T> pv3) {
  322.         this(new FieldAbsoluteDate<>(pv1.getPosition().getX().getField(), date),
  323.              a1, pv1, a2, pv2, a3, pv3);
  324.     }

  326.     /** Linear constructor
  327.      * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
  328.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
  329.      * @param date date of the built coordinates
  330.      * @param a1 first scale factor
  331.      * @param pv1 first base (unscaled) PVCoordinates
  332.      * @param a2 second scale factor
  333.      * @param pv2 second base (unscaled) PVCoordinates
  334.      * @param a3 third scale factor
  335.      * @param pv3 third base (unscaled) PVCoordinates
  336.      */
  337.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  338.                                          final double a1, final FieldPVCoordinates<T> pv1,
  339.                                          final double a2, final FieldPVCoordinates<T> pv2,
  340.                                          final double a3, final FieldPVCoordinates<T> pv3) {
  341.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition(),     a3, pv3.getPosition()),
  342.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity(),     a3, pv3.getVelocity()),
  343.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3, pv3.getAcceleration()));
  344.         this.date = date;
  345.     }

  347.     /** Linear constructor
  348.      * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
  349.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
  350.      * @param date date of the built coordinates
  351.      * @param a1 first scale factor
  352.      * @param pv1 first base (unscaled) PVCoordinates
  353.      * @param a2 second scale factor
  354.      * @param pv2 second base (unscaled) PVCoordinates
  355.      * @param a3 third scale factor
  356.      * @param pv3 third base (unscaled) PVCoordinates
  357.      */
  358.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  359.                                          final T a1, final FieldPVCoordinates<T> pv1,
  360.                                          final T a2, final FieldPVCoordinates<T> pv2,
  361.                                          final T a3, final FieldPVCoordinates<T> pv3) {
  362.         this(new FieldAbsoluteDate<>(a1.getField(), date),
  363.              a1, pv1, a2, pv2, a3, pv3);
  364.     }

  366.     /** Linear constructor
  367.      * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
  368.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
  369.      * @param date date of the built coordinates
  370.      * @param a1 first scale factor
  371.      * @param pv1 first base (unscaled) PVCoordinates
  372.      * @param a2 second scale factor
  373.      * @param pv2 second base (unscaled) PVCoordinates
  374.      * @param a3 third scale factor
  375.      * @param pv3 third base (unscaled) PVCoordinates
  376.      */
  377.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  378.                                          final T a1, final FieldPVCoordinates<T> pv1,
  379.                                          final T a2, final FieldPVCoordinates<T> pv2,
  380.                                          final T a3, final FieldPVCoordinates<T> pv3) {
  381.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition(),     a3, pv3.getPosition()),
  382.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity(),     a3, pv3.getVelocity()),
  383.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3, pv3.getAcceleration()));
  384.         this.date = date;
  385.     }

  387.     /** Linear constructor
  388.      * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
  389.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
  390.      * @param date date of the built coordinates
  391.      * @param a1 first scale factor
  392.      * @param pv1 first base (unscaled) PVCoordinates
  393.      * @param a2 second scale factor
  394.      * @param pv2 second base (unscaled) PVCoordinates
  395.      * @param a3 third scale factor
  396.      * @param pv3 third base (unscaled) PVCoordinates
  397.      */
  398.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  399.                                          final T a1, final PVCoordinates pv1,
  400.                                          final T a2, final PVCoordinates pv2,
  401.                                          final T a3, final PVCoordinates pv3) {
  402.         this(new FieldAbsoluteDate<>(a1.getField(), date),
  403.              a1, pv1, a2, pv2, a3, pv3);
  404.     }

  406.     /** Linear constructor
  407.      * <p>Build a PVCoordinates from three other ones and corresponding scale factors.</p>
  408.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3</p>
  409.      * @param date date of the built coordinates
  410.      * @param a1 first scale factor
  411.      * @param pv1 first base (unscaled) PVCoordinates
  412.      * @param a2 second scale factor
  413.      * @param pv2 second base (unscaled) PVCoordinates
  414.      * @param a3 third scale factor
  415.      * @param pv3 third base (unscaled) PVCoordinates
  416.      */
  417.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  418.                                          final T a1, final PVCoordinates pv1,
  419.                                          final T a2, final PVCoordinates pv2,
  420.                                          final T a3, final PVCoordinates pv3) {
  421.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition(),     a3, pv3.getPosition()),
  422.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity(),     a3, pv3.getVelocity()),
  423.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(), a3, pv3.getAcceleration()));
  424.         this.date = date;
  425.     }

  427.     /** Linear constructor
  428.      * <p>Build a PVCoordinates from four other ones and corresponding scale factors.</p>
  429.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
  430.      * @param date date of the built coordinates
  431.      * @param a1 first scale factor
  432.      * @param pv1 first base (unscaled) PVCoordinates
  433.      * @param a2 second scale factor
  434.      * @param pv2 second base (unscaled) PVCoordinates
  435.      * @param a3 third scale factor
  436.      * @param pv3 third base (unscaled) PVCoordinates
  437.      * @param a4 fourth scale factor
  438.      * @param pv4 fourth base (unscaled) PVCoordinates
  439.      */
  440.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  441.                                          final double a1, final FieldPVCoordinates<T> pv1,
  442.                                          final double a2, final FieldPVCoordinates<T> pv2,
  443.                                          final double a3, final FieldPVCoordinates<T> pv3,
  444.                                          final double a4, final FieldPVCoordinates<T> pv4) {
  445.         this(new FieldAbsoluteDate<>(pv1.getPosition().getX().getField(), date),
  446.              a1, pv1, a2, pv2, a3, pv3, a4, pv4);
  447.     }

  449.     /** Linear constructor
  450.      * <p>Build a PVCoordinates from four other ones and corresponding scale factors.</p>
  451.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
  452.      * @param date date of the built coordinates
  453.      * @param a1 first scale factor
  454.      * @param pv1 first base (unscaled) PVCoordinates
  455.      * @param a2 second scale factor
  456.      * @param pv2 second base (unscaled) PVCoordinates
  457.      * @param a3 third scale factor
  458.      * @param pv3 third base (unscaled) PVCoordinates
  459.      * @param a4 fourth scale factor
  460.      * @param pv4 fourth base (unscaled) PVCoordinates
  461.      */
  462.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  463.                                          final double a1, final FieldPVCoordinates<T> pv1,
  464.                                          final double a2, final FieldPVCoordinates<T> pv2,
  465.                                          final double a3, final FieldPVCoordinates<T> pv3,
  466.                                          final double a4, final FieldPVCoordinates<T> pv4) {
  467.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition(),
  468.                                   a3, pv3.getPosition(),     a4, pv4.getPosition()),
  469.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity(),
  470.                                   a3, pv3.getVelocity(),     a4, pv4.getVelocity()),
  471.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(),
  472.                                   a3, pv3.getAcceleration(), a4, pv4.getAcceleration()));
  473.         this.date = date;
  474.     }

  476.     /** Linear constructor
  477.      * <p>Build a PVCoordinates from four other ones and corresponding scale factors.</p>
  478.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
  479.      * @param date date of the built coordinates
  480.      * @param a1 first scale factor
  481.      * @param pv1 first base (unscaled) PVCoordinates
  482.      * @param a2 second scale factor
  483.      * @param pv2 second base (unscaled) PVCoordinates
  484.      * @param a3 third scale factor
  485.      * @param pv3 third base (unscaled) PVCoordinates
  486.      * @param a4 fourth scale factor
  487.      * @param pv4 fourth base (unscaled) PVCoordinates
  488.      */
  489.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  490.                                          final T a1, final FieldPVCoordinates<T> pv1,
  491.                                          final T a2, final FieldPVCoordinates<T> pv2,
  492.                                          final T a3, final FieldPVCoordinates<T> pv3,
  493.                                          final T a4, final FieldPVCoordinates<T> pv4) {
  494.         this(new FieldAbsoluteDate<>(a1.getField(), date),
  495.              a1, pv1, a2, pv2, a3, pv3, a4, pv4);
  496.     }

  498.     /** Linear constructor
  499.      * <p>Build a PVCoordinates from four other ones and corresponding scale factors.</p>
  500.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
  501.      * @param date date of the built coordinates
  502.      * @param a1 first scale factor
  503.      * @param pv1 first base (unscaled) PVCoordinates
  504.      * @param a2 second scale factor
  505.      * @param pv2 second base (unscaled) PVCoordinates
  506.      * @param a3 third scale factor
  507.      * @param pv3 third base (unscaled) PVCoordinates
  508.      * @param a4 fourth scale factor
  509.      * @param pv4 fourth base (unscaled) PVCoordinates
  510.      */
  511.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  512.                                          final T a1, final FieldPVCoordinates<T> pv1,
  513.                                          final T a2, final FieldPVCoordinates<T> pv2,
  514.                                          final T a3, final FieldPVCoordinates<T> pv3,
  515.                                          final T a4, final FieldPVCoordinates<T> pv4) {
  516.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition(),
  517.                                   a3, pv3.getPosition(),     a4, pv4.getPosition()),
  518.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity(),
  519.                                   a3, pv3.getVelocity(),     a4, pv4.getVelocity()),
  520.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(),
  521.                                   a3, pv3.getAcceleration(), a4, pv4.getAcceleration()));
  522.         this.date = date;
  523.     }

  525.     /** Linear constructor
  526.      * <p>Build a PVCoordinates from four other ones and corresponding scale factors.</p>
  527.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
  528.      * @param date date of the built coordinates
  529.      * @param a1 first scale factor
  530.      * @param pv1 first base (unscaled) PVCoordinates
  531.      * @param a2 second scale factor
  532.      * @param pv2 second base (unscaled) PVCoordinates
  533.      * @param a3 third scale factor
  534.      * @param pv3 third base (unscaled) PVCoordinates
  535.      * @param a4 fourth scale factor
  536.      * @param pv4 fourth base (unscaled) PVCoordinates
  537.      */
  538.     public TimeStampedFieldPVCoordinates(final AbsoluteDate date,
  539.                                          final T a1, final PVCoordinates pv1,
  540.                                          final T a2, final PVCoordinates pv2,
  541.                                          final T a3, final PVCoordinates pv3,
  542.                                          final T a4, final PVCoordinates pv4) {
  543.         this(new FieldAbsoluteDate<>(a1.getField(), date),
  544.              a1, pv1, a2, pv2, a3, pv3, a4, pv4);
  545.     }

  547.     /** Linear constructor
  548.      * <p>Build a PVCoordinates from four other ones and corresponding scale factors.</p>
  549.      * <p>The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4</p>
  550.      * @param date date of the built coordinates
  551.      * @param a1 first scale factor
  552.      * @param pv1 first base (unscaled) PVCoordinates
  553.      * @param a2 second scale factor
  554.      * @param pv2 second base (unscaled) PVCoordinates
  555.      * @param a3 third scale factor
  556.      * @param pv3 third base (unscaled) PVCoordinates
  557.      * @param a4 fourth scale factor
  558.      * @param pv4 fourth base (unscaled) PVCoordinates
  559.      */
  560.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  561.                                          final T a1, final PVCoordinates pv1,
  562.                                          final T a2, final PVCoordinates pv2,
  563.                                          final T a3, final PVCoordinates pv3,
  564.                                          final T a4, final PVCoordinates pv4) {
  565.         super(new FieldVector3D<>(a1, pv1.getPosition(),     a2, pv2.getPosition(),
  566.                                   a3, pv3.getPosition(),     a4, pv4.getPosition()),
  567.               new FieldVector3D<>(a1, pv1.getVelocity(),     a2, pv2.getVelocity(),
  568.                                   a3, pv3.getVelocity(),     a4, pv4.getVelocity()),
  569.               new FieldVector3D<>(a1, pv1.getAcceleration(), a2, pv2.getAcceleration(),
  570.                                   a3, pv3.getAcceleration(), a4, pv4.getAcceleration()));
  571.         this.date = date;
  572.     }

  574.     /** Builds a TimeStampedFieldPVCoordinates triplet from  a {@link FieldVector3D}&lt;{@link FieldDerivativeStructure}&gt;.
  575.      * <p>
  576.      * The vector components must have time as their only derivation parameter and
  577.      * have consistent derivation orders.
  578.      * </p>
  579.      * @param date date of the built coordinates
  580.      * @param p vector with time-derivatives embedded within the coordinates
  581.      */
  582.     public TimeStampedFieldPVCoordinates(final FieldAbsoluteDate<T> date,
  583.                                          final FieldVector3D<FieldDerivativeStructure<T>> p) {
  584.         super(p);
  585.         this.date = date;
  586.     }

  588.     /** Get the date.
  589.      * @return date
  590.      */
  591.     public FieldAbsoluteDate<T> getDate() {
  592.         return date;
  593.     }

  595.     /** Get a time-shifted state.
  596.      * <p>
  597.      * The state can be slightly shifted to close dates. This shift is based on
  598.      * a simple linear model. It is <em>not</em> intended as a replacement for
  599.      * proper orbit propagation (it is not even Keplerian!) but should be sufficient
  600.      * for either small time shifts or coarse accuracy.
  601.      * </p>
  602.      * @param dt time shift in seconds
  603.      * @return a new state, shifted with respect to the instance (which is immutable)
  604.      */
  605.     public TimeStampedFieldPVCoordinates<T> shiftedBy(final double dt) {
  606.         final FieldPVCoordinates<T> spv = super.shiftedBy(dt);
  607.         return new TimeStampedFieldPVCoordinates<>(date.shiftedBy(dt),
  608.                                                    spv.getPosition(), spv.getVelocity(), spv.getAcceleration());
  609.     }

  611.     /** Get a time-shifted state.
  612.      * <p>
  613.      * The state can be slightly shifted to close dates. This shift is based on
  614.      * a simple linear model. It is <em>not</em> intended as a replacement for
  615.      * proper orbit propagation (it is not even Keplerian!) but should be sufficient
  616.      * for either small time shifts or coarse accuracy.
  617.      * </p>
  618.      * @param dt time shift in seconds
  619.      * @return a new state, shifted with respect to the instance (which is immutable)
  620.      */
  621.     public TimeStampedFieldPVCoordinates<T> shiftedBy(final T dt) {
  622.         final FieldPVCoordinates<T> spv = super.shiftedBy(dt);
  623.         return new TimeStampedFieldPVCoordinates<>(date.shiftedBy(dt),
  624.                                                    spv.getPosition(), spv.getVelocity(), spv.getAcceleration());
  625.     }

  627.     /** Interpolate position-velocity.
  628.      * <p>
  629.      * The interpolated instance is created by polynomial Hermite interpolation
  630.      * ensuring velocity remains the exact derivative of position.
  631.      * </p>
  632.      * <p>
  633.      * Note that even if first time derivatives (velocities)
  634.      * from sample can be ignored, the interpolated instance always includes
  635.      * interpolated derivatives. This feature can be used explicitly to
  636.      * compute these derivatives when it would be too complex to compute them
  637.      * from an analytical formula: just compute a few sample points from the
  638.      * explicit formula and set the derivatives to zero in these sample points,
  639.      * then use interpolation to add derivatives consistent with the positions.
  640.      * </p>
  641.      * @param date interpolation date
  642.      * @param filter filter for derivatives from the sample to use in interpolation
  643.      * @param sample sample points on which interpolation should be done
  644.      * @param <T> the type of the field elements
  645.      * @return a new position-velocity, interpolated at specified date
  646.      */
  647.     public static <T extends RealFieldElement<T>>
  648.         TimeStampedFieldPVCoordinates<T> interpolate(final FieldAbsoluteDate<T> date,
  649.                                                      final CartesianDerivativesFilter filter,
  650.                                                      final Collection<TimeStampedFieldPVCoordinates<T>> sample) {
  651.         return interpolate(date, filter, sample.stream());
  652.     }

  654.     /** Interpolate position-velocity.
  655.      * <p>
  656.      * The interpolated instance is created by polynomial Hermite interpolation
  657.      * ensuring velocity remains the exact derivative of position.
  658.      * </p>
  659.      * <p>
  660.      * Note that even if first time derivatives (velocities)
  661.      * from sample can be ignored, the interpolated instance always includes
  662.      * interpolated derivatives. This feature can be used explicitly to
  663.      * compute these derivatives when it would be too complex to compute them
  664.      * from an analytical formula: just compute a few sample points from the
  665.      * explicit formula and set the derivatives to zero in these sample points,
  666.      * then use interpolation to add derivatives consistent with the positions.
  667.      * </p>
  668.      * @param date interpolation date
  669.      * @param filter filter for derivatives from the sample to use in interpolation
  670.      * @param sample sample points on which interpolation should be done
  671.      * @param <T> the type of the field elements
  672.      * @return a new position-velocity, interpolated at specified date
  673.      */
  674.     public static <T extends RealFieldElement<T>>
  675.         TimeStampedFieldPVCoordinates<T> interpolate(final FieldAbsoluteDate<T> date,
  676.                                                      final CartesianDerivativesFilter filter,
  677.                                                      final Stream<TimeStampedFieldPVCoordinates<T>> sample) {

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

  682.         // add sample points
  683.         switch (filter) {
  684.             case USE_P :
  685.                 // populate sample with position data, ignoring velocity
  686.                 sample.forEach(pv -> {
  687.                     final FieldVector3D<T> position = pv.getPosition();
  688.                     interpolator.addSamplePoint(pv.getDate().durationFrom(date),
  689.                                                 position.toArray());
  690.                 });
  691.                 break;
  692.             case USE_PV :
  693.                 // populate sample with position and velocity data
  694.                 sample.forEach(pv -> {
  695.                     final FieldVector3D<T> position = pv.getPosition();
  696.                     final FieldVector3D<T> velocity = pv.getVelocity();
  697.                     interpolator.addSamplePoint(pv.getDate().durationFrom(date),
  698.                                                 position.toArray(), velocity.toArray());
  699.                 });
  700.                 break;
  701.             case USE_PVA :
  702.                 // populate sample with position, velocity and acceleration data
  703.                 sample.forEach(pv -> {
  704.                     final FieldVector3D<T> position     = pv.getPosition();
  705.                     final FieldVector3D<T> velocity     = pv.getVelocity();
  706.                     final FieldVector3D<T> acceleration = pv.getAcceleration();
  707.                     interpolator.addSamplePoint(pv.getDate().durationFrom(date),
  708.                                                 position.toArray(), velocity.toArray(), acceleration.toArray());
  709.                 });
  710.                 break;
  711.             default :
  712.                 // this should never happen
  713.                 throw new OrekitInternalError(null);
  714.         }

  716.         // interpolate
  717.         final T[][] p = interpolator.derivatives(date.getField().getZero(), 2);

  719.         // build a new interpolated instance

  721.         return new TimeStampedFieldPVCoordinates<>(date,
  722.                                                    new FieldVector3D<>(p[0]),
  723.                                                    new FieldVector3D<>(p[1]),
  724.                                                    new FieldVector3D<>(p[2]));

  726.     }

  728.     /** Convert to a constant position-velocity.
  729.      * @return a constant position-velocity
  730.      * @since 9.0
  731.      */
  732.     public TimeStampedPVCoordinates toTimeStampedPVCoordinates() {
  733.         return new TimeStampedPVCoordinates(date.toAbsoluteDate(),
  734.                                             getPosition().toVector3D(),
  735.                                             getVelocity().toVector3D(),
  736.                                             getAcceleration().toVector3D());
  737.     }

  739.     /** Return a string representation of this date, position, velocity, and acceleration.
  740.      *
  741.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  742.      *
  743.      * @return string representation of this.
  744.      */
  745.     @Override
  746.     @DefaultDataContext
  747.     public String toString() {
  748.         return toTimeStampedPVCoordinates().toString();
  749.     }

  751.     /**
  752.      * Return a string representation of this date, position, velocity, and acceleration.
  753.      *
  754.      * @param utc time scale used to print the date.
  755.      * @return string representation of this.
  756.      */
  757.     public String toString(final TimeScale utc) {
  758.         return toTimeStampedPVCoordinates().toString(utc);
  759.     }

  761. }
Created with JaCoCo 0.8.6.202009150832