TimeStampedFieldPVCoordinates.java

  1. /* Copyright 2002-2017 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.interpolation.FieldHermiteInterpolator;
  24. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  25. import org.orekit.errors.OrekitInternalError;
  26. import org.orekit.time.AbsoluteDate;
  27. import org.orekit.time.FieldAbsoluteDate;
  28. import org.orekit.time.TimeStamped;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  570.     /** Get the date.
  571.      * @return date
  572.      */
  573.     public FieldAbsoluteDate<T> getDate() {
  574.         return date;
  575.     }

  577.     /** Get a time-shifted state.
  578.      * <p>
  579.      * The state can be slightly shifted to close dates. This shift is based on
  580.      * a simple linear model. It is <em>not</em> intended as a replacement for
  581.      * proper orbit propagation (it is not even Keplerian!) but should be sufficient
  582.      * for either small time shifts or coarse accuracy.
  583.      * </p>
  584.      * @param dt time shift in seconds
  585.      * @return a new state, shifted with respect to the instance (which is immutable)
  586.      */
  587.     public TimeStampedFieldPVCoordinates<T> shiftedBy(final double dt) {
  588.         final FieldPVCoordinates<T> spv = super.shiftedBy(dt);
  589.         return new TimeStampedFieldPVCoordinates<>(date.shiftedBy(dt),
  590.                                                    spv.getPosition(), spv.getVelocity(), spv.getAcceleration());
  591.     }

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

  609.     /** Interpolate position-velocity.
  610.      * <p>
  611.      * The interpolated instance is created by polynomial Hermite interpolation
  612.      * ensuring velocity remains the exact derivative of position.
  613.      * </p>
  614.      * <p>
  615.      * Note that even if first time derivatives (velocities)
  616.      * from sample can be ignored, the interpolated instance always includes
  617.      * interpolated derivatives. This feature can be used explicitly to
  618.      * compute these derivatives when it would be too complex to compute them
  619.      * from an analytical formula: just compute a few sample points from the
  620.      * explicit formula and set the derivatives to zero in these sample points,
  621.      * then use interpolation to add derivatives consistent with the positions.
  622.      * </p>
  623.      * @param date interpolation date
  624.      * @param filter filter for derivatives from the sample to use in interpolation
  625.      * @param sample sample points on which interpolation should be done
  626.      * @param <T> the type of the field elements
  627.      * @return a new position-velocity, interpolated at specified date
  628.      */
  629.     public static <T extends RealFieldElement<T>>
  630.         TimeStampedFieldPVCoordinates<T> interpolate(final FieldAbsoluteDate<T> date,
  631.                                                      final CartesianDerivativesFilter filter,
  632.                                                      final Collection<TimeStampedFieldPVCoordinates<T>> sample) {
  633.         return interpolate(date, filter, sample.stream());
  634.     }

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

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

  664.         // add sample points
  665.         switch (filter) {
  666.             case USE_P :
  667.                 // populate sample with position data, ignoring velocity
  668.                 sample.forEach(pv -> {
  669.                     final FieldVector3D<T> position = pv.getPosition();
  670.                     interpolator.addSamplePoint(pv.getDate().durationFrom(date),
  671.                                                 position.toArray());
  672.                 });
  673.                 break;
  674.             case USE_PV :
  675.                 // populate sample with position and velocity data
  676.                 sample.forEach(pv -> {
  677.                     final FieldVector3D<T> position = pv.getPosition();
  678.                     final FieldVector3D<T> velocity = pv.getVelocity();
  679.                     interpolator.addSamplePoint(pv.getDate().durationFrom(date),
  680.                                                 position.toArray(), velocity.toArray());
  681.                 });
  682.                 break;
  683.             case USE_PVA :
  684.                 // populate sample with position, velocity and acceleration data
  685.                 sample.forEach(pv -> {
  686.                     final FieldVector3D<T> position     = pv.getPosition();
  687.                     final FieldVector3D<T> velocity     = pv.getVelocity();
  688.                     final FieldVector3D<T> acceleration = pv.getAcceleration();
  689.                     interpolator.addSamplePoint(pv.getDate().durationFrom(date),
  690.                                                 position.toArray(), velocity.toArray(), acceleration.toArray());
  691.                 });
  692.                 break;
  693.             default :
  694.                 // this should never happen
  695.                 throw new OrekitInternalError(null);
  696.         }

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

  701.         // build a new interpolated instance

  703.         return new TimeStampedFieldPVCoordinates<>(date,
  704.                                                    new FieldVector3D<>(p[0]),
  705.                                                    new FieldVector3D<>(p[1]),
  706.                                                    new FieldVector3D<>(p[2]));

  708.     }

  710.     /** Convert to a constant position-velocity.
  711.      * @return a constant position-velocity
  712.      * @since 9.0
  713.      */
  714.     public TimeStampedPVCoordinates toTimeStampedPVCoordinates() {
  715.         return new TimeStampedPVCoordinates(date.toAbsoluteDate(),
  716.                                             getPosition().toVector3D(),
  717.                                             getVelocity().toVector3D(),
  718.                                             getAcceleration().toVector3D());
  719.     }

  721.     /** Return a string representation of this position/velocity pair.
  722.      * @return string representation of this position/velocity pair
  723.      */
  724.     public String toString() {
  725.         final String comma = ", ";
  726.         return new StringBuffer().append('{').append(date).append(", P(").
  727.                                   append(getPosition().getX().getReal()).append(comma).
  728.                                   append(getPosition().getY().getReal()).append(comma).
  729.                                   append(getPosition().getZ().getReal()).append("), V(").
  730.                                   append(getVelocity().getX().getReal()).append(comma).
  731.                                   append(getVelocity().getY().getReal()).append(comma).
  732.                                   append(getVelocity().getZ().getReal()).append("), A(").
  733.                                   append(getAcceleration().getX().getReal()).append(comma).
  734.                                   append(getAcceleration().getY().getReal()).append(comma).
  735.                                   append(getAcceleration().getZ().getReal()).append(")}").toString();
  736.     }

  738. }
Created with JaCoCo 0.7.9.201702052155