TimeStampedFieldPVCoordinates.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;
  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.errors.OrekitInternalError;
  27. import org.orekit.time.AbsoluteDate;
  28. import org.orekit.time.FieldAbsoluteDate;
  29. import org.orekit.time.TimeStamped;

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

  40.     /** The date. */
  41.     private final FieldAbsoluteDate<T> date;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  585.     /** Get the date.
  586.      * @return date
  587.      */
  588.     public FieldAbsoluteDate<T> getDate() {
  589.         return date;
  590.     }

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

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

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

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

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

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

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

  716.         // build a new interpolated instance

  718.         return new TimeStampedFieldPVCoordinates<>(date,
  719.                                                    new FieldVector3D<>(p[0]),
  720.                                                    new FieldVector3D<>(p[1]),
  721.                                                    new FieldVector3D<>(p[2]));

  723.     }

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

  736.     /** Return a string representation of this position/velocity pair.
  737.      * @return string representation of this position/velocity pair
  738.      */
  739.     public String toString() {
  740.         final String comma = ", ";
  741.         return new StringBuffer().append('{').append(date).append(", P(").
  742.                                   append(getPosition().getX().getReal()).append(comma).
  743.                                   append(getPosition().getY().getReal()).append(comma).
  744.                                   append(getPosition().getZ().getReal()).append("), V(").
  745.                                   append(getVelocity().getX().getReal()).append(comma).
  746.                                   append(getVelocity().getY().getReal()).append(comma).
  747.                                   append(getVelocity().getZ().getReal()).append("), A(").
  748.                                   append(getAcceleration().getX().getReal()).append(comma).
  749.                                   append(getAcceleration().getY().getReal()).append(comma).
  750.                                   append(getAcceleration().getZ().getReal()).append(")}").toString();
  751.     }

  753. }
Created with JaCoCo 0.7.9.201702052155