EstimatedEarthFrameProvider.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.estimation.measurements;

  19. import java.io.Serializable;
  20. import java.util.Map;

  22. import org.hipparchus.RealFieldElement;
  23. import org.hipparchus.analysis.differentiation.DSFactory;
  24. import org.hipparchus.analysis.differentiation.DerivativeStructure;
  25. import org.hipparchus.analysis.differentiation.Gradient;
  26. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  27. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  28. import org.hipparchus.geometry.euclidean.threed.Rotation;
  29. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  30. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  31. import org.hipparchus.util.FastMath;
  32. import org.orekit.errors.OrekitException;
  33. import org.orekit.errors.OrekitInternalError;
  34. import org.orekit.errors.OrekitMessages;
  35. import org.orekit.frames.FieldTransform;
  36. import org.orekit.frames.Transform;
  37. import org.orekit.frames.TransformProvider;
  38. import org.orekit.time.AbsoluteDate;
  39. import org.orekit.time.FieldAbsoluteDate;
  40. import org.orekit.time.UT1Scale;
  41. import org.orekit.utils.IERSConventions;
  42. import org.orekit.utils.ParameterDriver;

  44. /** Class modeling an Earth frame whose Earth Orientation Parameters can be estimated.
  45.  * <p>
  46.  * This class adds parameters for an additional polar motion
  47.  * and an additional prime meridian orientation on top of an underlying regular Earth
  48.  * frame like {@link org.orekit.frames.FramesFactory#getITRF(IERSConventions, boolean) ITRF}.
  49.  * The polar motion and prime meridian orientation are applied <em>after</em> regular Earth
  50.  * orientation parameters, so the value of the estimated parameters will be correction to EOP,
  51.  * they will not be the complete EOP values by themselves. Basically, this means that for
  52.  * Earth, the following transforms are applied in order, between inertial frame and this frame:
  53.  * </p>
  54.  * <ol>
  55.  *   <li>precession/nutation, as theoretical model plus celestial pole EOP parameters</li>
  56.  *   <li>body rotation, as theoretical model plus prime meridian EOP parameters</li>
  57.  *   <li>polar motion, which is only from EOP parameters (no theoretical models)</li>
  58.  *   <li>additional body rotation, controlled by {@link #getPrimeMeridianOffsetDriver()} and {@link #getPrimeMeridianDriftDriver()}</li>
  59.  *   <li>additional polar motion, controlled by {@link #getPolarOffsetXDriver()}, {@link #getPolarDriftXDriver()},
  60.  *   {@link #getPolarOffsetYDriver()} and {@link #getPolarDriftYDriver()}</li>
  61.  * </ol>
  62.  * @author Luc Maisonobe
  63.  * @since 9.1
  64.  */
  65. public class EstimatedEarthFrameProvider implements TransformProvider {

  67.     /** Earth Angular Velocity, in rad/s, from TIRF model. */
  68.     public static final double EARTH_ANGULAR_VELOCITY = 7.292115146706979e-5;

  70.     /** Serializable UID. */
  71.     private static final long serialVersionUID = 20170922L;

  73.     /** Angular scaling factor.
  74.      * <p>
  75.      * We use a power of 2 to avoid numeric noise introduction
  76.      * in the multiplications/divisions sequences.
  77.      * </p>
  78.      */
  79.     private static final double ANGULAR_SCALE = FastMath.scalb(1.0, -22);

  81.     /** Underlying raw UT1. */
  82.     private final UT1Scale baseUT1;

  84.     /** Estimated UT1. */
  85.     private final transient UT1Scale estimatedUT1;

  87.     /** Driver for prime meridian offset. */
  88.     private final transient ParameterDriver primeMeridianOffsetDriver;

  90.     /** Driver for prime meridian drift. */
  91.     private final transient ParameterDriver primeMeridianDriftDriver;

  93.     /** Driver for pole offset along X. */
  94.     private final transient ParameterDriver polarOffsetXDriver;

  96.     /** Driver for pole drift along X. */
  97.     private final transient ParameterDriver polarDriftXDriver;

  99.     /** Driver for pole offset along Y. */
  100.     private final transient ParameterDriver polarOffsetYDriver;

  102.     /** Driver for pole drift along Y. */
  103.     private final transient ParameterDriver polarDriftYDriver;

  105.     /** Build an estimated Earth frame.
  106.      * <p>
  107.      * The initial values for the pole and prime meridian parametric linear models
  108.      * ({@link #getPrimeMeridianOffsetDriver()}, {@link #getPrimeMeridianDriftDriver()},
  109.      * {@link #getPolarOffsetXDriver()}, {@link #getPolarDriftXDriver()},
  110.      * {@link #getPolarOffsetXDriver()}, {@link #getPolarDriftXDriver()}) are set to 0.
  111.      * </p>
  112.      * @param baseUT1 underlying base UT1
  113.      * @since 9.1
  114.      */
  115.     public EstimatedEarthFrameProvider(final UT1Scale baseUT1) {

  117.         this.primeMeridianOffsetDriver = new ParameterDriver("prime-meridian-offset",
  118.                                                              0.0, ANGULAR_SCALE,
  119.                                                             -FastMath.PI, FastMath.PI);

  121.         this.primeMeridianDriftDriver = new ParameterDriver("prime-meridian-drift",
  122.                                                             0.0, ANGULAR_SCALE,
  123.                                                             Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  125.         this.polarOffsetXDriver = new ParameterDriver("polar-offset-X",
  126.                                                       0.0, ANGULAR_SCALE,
  127.                                                       -FastMath.PI, FastMath.PI);

  129.         this.polarDriftXDriver = new ParameterDriver("polar-drift-X",
  130.                                                      0.0, ANGULAR_SCALE,
  131.                                                      Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  133.         this.polarOffsetYDriver = new ParameterDriver("polar-offset-Y",
  134.                                                       0.0, ANGULAR_SCALE,
  135.                                                       -FastMath.PI, FastMath.PI);

  137.         this.polarDriftYDriver = new ParameterDriver("polar-drift-Y",
  138.                                                      0.0, ANGULAR_SCALE,
  139.                                                      Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  141.         this.baseUT1      = baseUT1;
  142.         this.estimatedUT1 = new EstimatedUT1Scale();

  144.     }

  146.     /** Get a driver allowing to add a prime meridian rotation.
  147.      * <p>
  148.      * The parameter is an angle in radians. In order to convert this
  149.      * value to a DUT1 in seconds, the value must be divided by
  150.      * {@link #EARTH_ANGULAR_VELOCITY} (nominal Angular Velocity of Earth).
  151.      * </p>
  152.      * @return driver for prime meridian rotation
  153.      */
  154.     public ParameterDriver getPrimeMeridianOffsetDriver() {
  155.         return primeMeridianOffsetDriver;
  156.     }

  158.     /** Get a driver allowing to add a prime meridian rotation rate.
  159.      * <p>
  160.      * The parameter is an angle rate in radians per second. In order to convert this
  161.      * value to a LOD in seconds, the value must be multiplied by -86400 and divided by
  162.      * {@link #EARTH_ANGULAR_VELOCITY} (nominal Angular Velocity of Earth).
  163.      * </p>
  164.      * @return driver for prime meridian rotation rate
  165.      */
  166.     public ParameterDriver getPrimeMeridianDriftDriver() {
  167.         return primeMeridianDriftDriver;
  168.     }

  170.     /** Get a driver allowing to add a polar offset along X.
  171.      * <p>
  172.      * The parameter is an angle in radians
  173.      * </p>
  174.      * @return driver for polar offset along X
  175.      */
  176.     public ParameterDriver getPolarOffsetXDriver() {
  177.         return polarOffsetXDriver;
  178.     }

  180.     /** Get a driver allowing to add a polar drift along X.
  181.      * <p>
  182.      * The parameter is an angle rate in radians per second
  183.      * </p>
  184.      * @return driver for polar drift along X
  185.      */
  186.     public ParameterDriver getPolarDriftXDriver() {
  187.         return polarDriftXDriver;
  188.     }

  190.     /** Get a driver allowing to add a polar offset along Y.
  191.      * <p>
  192.      * The parameter is an angle in radians
  193.      * </p>
  194.      * @return driver for polar offset along Y
  195.      */
  196.     public ParameterDriver getPolarOffsetYDriver() {
  197.         return polarOffsetYDriver;
  198.     }

  200.     /** Get a driver allowing to add a polar drift along Y.
  201.      * <p>
  202.      * The parameter is an angle rate in radians per second
  203.      * </p>
  204.      * @return driver for polar drift along Y
  205.      */
  206.     public ParameterDriver getPolarDriftYDriver() {
  207.         return polarDriftYDriver;
  208.     }

  210.     /** Get the estimated UT1 time scale.
  211.      * @return estimated UT1 time scale
  212.      */
  213.     public UT1Scale getEstimatedUT1() {
  214.         return estimatedUT1;
  215.     }

  217.     /** {@inheritDoc} */
  218.     @Override
  219.     public Transform getTransform(final AbsoluteDate date) {

  221.         // take parametric prime meridian shift into account
  222.         final double theta    = linearModel(date, primeMeridianOffsetDriver, primeMeridianDriftDriver);
  223.         final double thetaDot = primeMeridianDriftDriver.getValue();
  224.         final Transform meridianShift =
  225.                         new Transform(date,
  226.                                       new Rotation(Vector3D.PLUS_K, theta, RotationConvention.FRAME_TRANSFORM),
  227.                                       new Vector3D(0, 0, thetaDot));

  229.         // take parametric pole shift into account
  230.         final double xpNeg     = -linearModel(date, polarOffsetXDriver, polarDriftXDriver);
  231.         final double ypNeg     = -linearModel(date, polarOffsetYDriver, polarDriftYDriver);
  232.         final double xpNegDot  = -polarDriftXDriver.getValue();
  233.         final double ypNegDot  = -polarDriftYDriver.getValue();
  234.         final Transform poleShift =
  235.                         new Transform(date,
  236.                                       new Transform(date,
  237.                                                     new Rotation(Vector3D.PLUS_J, xpNeg, RotationConvention.FRAME_TRANSFORM),
  238.                                                     new Vector3D(0.0, xpNegDot, 0.0)),
  239.                                       new Transform(date,
  240.                                                     new Rotation(Vector3D.PLUS_I, ypNeg, RotationConvention.FRAME_TRANSFORM),
  241.                                                     new Vector3D(ypNegDot, 0.0, 0.0)));

  243.         return new Transform(date, meridianShift, poleShift);

  245.     }

  247.     /** {@inheritDoc} */
  248.     @Override
  249.     public <T extends RealFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date) {

  251.         final T zero = date.getField().getZero();

  253.         // prime meridian shift parameters
  254.         final T theta    = linearModel(date, primeMeridianOffsetDriver, primeMeridianDriftDriver);
  255.         final T thetaDot = zero.add(primeMeridianDriftDriver.getValue());

  257.         // pole shift parameters
  258.         final T xpNeg    = linearModel(date, polarOffsetXDriver, polarDriftXDriver).negate();
  259.         final T ypNeg    = linearModel(date, polarOffsetYDriver, polarDriftYDriver).negate();
  260.         final T xpNegDot = zero.subtract(polarDriftXDriver.getValue());
  261.         final T ypNegDot = zero.subtract(polarDriftYDriver.getValue());

  263.         return getTransform(date, theta, thetaDot, xpNeg, xpNegDot, ypNeg, ypNegDot);

  265.     }

  267.     /** Get the transform with derivatives.
  268.      * @param date date of the transform
  269.      * @param factory factory for the derivatives
  270.      * @param indices indices of the estimated parameters in derivatives computations
  271.      * @return computed transform with derivatives
  272.      * @deprecated as of 10.2, replaced by {@link #getTransform(FieldAbsoluteDate, int, Map)}
  273.      */
  274.     @Deprecated
  275.     public FieldTransform<DerivativeStructure> getTransform(final FieldAbsoluteDate<DerivativeStructure> date,
  276.                                                             final DSFactory factory,
  277.                                                             final Map<String, Integer> indices) {

  279.         // prime meridian shift parameters
  280.         final DerivativeStructure theta    = linearModel(factory, date,
  281.                                                          primeMeridianOffsetDriver, primeMeridianDriftDriver,
  282.                                                          indices);
  283.         final DerivativeStructure thetaDot = primeMeridianDriftDriver.getValue(factory, indices);

  285.         // pole shift parameters
  286.         final DerivativeStructure xpNeg    = linearModel(factory, date,
  287.                                                          polarOffsetXDriver, polarDriftXDriver, indices).negate();
  288.         final DerivativeStructure ypNeg    = linearModel(factory, date,
  289.                                                          polarOffsetYDriver, polarDriftYDriver, indices).negate();
  290.         final DerivativeStructure xpNegDot = polarDriftXDriver.getValue(factory, indices).negate();
  291.         final DerivativeStructure ypNegDot = polarDriftYDriver.getValue(factory, indices).negate();

  293.         return getTransform(date, theta, thetaDot, xpNeg, xpNegDot, ypNeg, ypNegDot);

  295.     }

  297.     /** Get the transform with derivatives.
  298.      * @param date date of the transform
  299.      * @param freeParameters total number of free parameters in the gradient
  300.      * @param indices indices of the estimated parameters in derivatives computations
  301.      * @return computed transform with derivatives
  302.      * @since 10.2
  303.      */
  304.     public FieldTransform<Gradient> getTransform(final FieldAbsoluteDate<Gradient> date,
  305.                                                  final int freeParameters,
  306.                                                  final Map<String, Integer> indices) {

  308.         // prime meridian shift parameters
  309.         final Gradient theta    = linearModel(freeParameters, date,
  310.                                               primeMeridianOffsetDriver, primeMeridianDriftDriver,
  311.                                               indices);
  312.         final Gradient thetaDot = primeMeridianDriftDriver.getValue(freeParameters, indices);

  314.         // pole shift parameters
  315.         final Gradient xpNeg    = linearModel(freeParameters, date,
  316.                                                          polarOffsetXDriver, polarDriftXDriver, indices).negate();
  317.         final Gradient ypNeg    = linearModel(freeParameters, date,
  318.                                                          polarOffsetYDriver, polarDriftYDriver, indices).negate();
  319.         final Gradient xpNegDot = polarDriftXDriver.getValue(freeParameters, indices).negate();
  320.         final Gradient ypNegDot = polarDriftYDriver.getValue(freeParameters, indices).negate();

  322.         return getTransform(date, theta, thetaDot, xpNeg, xpNegDot, ypNeg, ypNegDot);

  324.     }

  326.     /** Get the transform with derivatives.
  327.      * @param date date of the transform
  328.      * @param theta angle of the prime meridian
  329.      * @param thetaDot angular rate of the prime meridian
  330.      * @param xpNeg opposite of the angle of the pole motion along X
  331.      * @param xpNegDot opposite of the angular rate of the pole motion along X
  332.      * @param ypNeg opposite of the angle of the pole motion along Y
  333.      * @param ypNegDot opposite of the angular rate of the pole motion along Y
  334.      * @param <T> type of the field elements
  335.      * @return computed transform with derivatives
  336.      */
  337.     private <T extends RealFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date,
  338.                                                                            final T theta, final T thetaDot,
  339.                                                                            final T xpNeg, final T xpNegDot,
  340.                                                                            final T ypNeg, final T ypNegDot) {

  342.         final T                zero  = date.getField().getZero();
  343.         final FieldVector3D<T> plusI = FieldVector3D.getPlusI(date.getField());
  344.         final FieldVector3D<T> plusJ = FieldVector3D.getPlusJ(date.getField());
  345.         final FieldVector3D<T> plusK = FieldVector3D.getPlusK(date.getField());

  347.         // take parametric prime meridian shift into account
  348.         final FieldTransform<T> meridianShift =
  349.                         new FieldTransform<>(date,
  350.                                              new FieldRotation<>(plusK, theta, RotationConvention.FRAME_TRANSFORM),
  351.                                              new FieldVector3D<>(zero, zero, thetaDot));

  353.         // take parametric pole shift into account
  354.         final FieldTransform<T> poleShift =
  355.                         new FieldTransform<>(date,
  356.                                       new FieldTransform<>(date,
  357.                                                            new FieldRotation<>(plusJ, xpNeg, RotationConvention.FRAME_TRANSFORM),
  358.                                                            new FieldVector3D<>(zero, xpNegDot, zero)),
  359.                                       new FieldTransform<>(date,
  360.                                                            new FieldRotation<>(plusI, ypNeg, RotationConvention.FRAME_TRANSFORM),
  361.                                                            new FieldVector3D<>(ypNegDot, zero, zero)));

  363.         return new FieldTransform<>(date, meridianShift, poleShift);

  365.     }

  367.     /** Evaluate a parametric linear model.
  368.      * @param date current date
  369.      * @param offsetDriver driver for the offset parameter
  370.      * @param driftDriver driver for the drift parameter
  371.      * @return current value of the linear model
  372.      */
  373.     private double linearModel(final AbsoluteDate date,
  374.                                final ParameterDriver offsetDriver, final ParameterDriver driftDriver) {
  375.         if (offsetDriver.getReferenceDate() == null) {
  376.             throw new OrekitException(OrekitMessages.NO_REFERENCE_DATE_FOR_PARAMETER,
  377.                                       offsetDriver.getName());
  378.         }
  379.         final double dt     = date.durationFrom(offsetDriver.getReferenceDate());
  380.         final double offset = offsetDriver.getValue();
  381.         final double drift  = driftDriver.getValue();
  382.         return dt * drift + offset;
  383.     }

  385.     /** Evaluate a parametric linear model.
  386.      * @param date current date
  387.      * @param offsetDriver driver for the offset parameter
  388.      * @param driftDriver driver for the drift parameter
  389.      * @return current value of the linear model
  390.      * @param <T> type of the filed elements
  391.      */
  392.     private <T extends RealFieldElement<T>> T linearModel(final FieldAbsoluteDate<T> date,
  393.                                                           final ParameterDriver offsetDriver,
  394.                                                           final ParameterDriver driftDriver) {
  395.         if (offsetDriver.getReferenceDate() == null) {
  396.             throw new OrekitException(OrekitMessages.NO_REFERENCE_DATE_FOR_PARAMETER,
  397.                                       offsetDriver.getName());
  398.         }
  399.         final T dt          = date.durationFrom(offsetDriver.getReferenceDate());
  400.         final double offset = offsetDriver.getValue();
  401.         final double drift  = driftDriver.getValue();
  402.         return dt.multiply(drift).add(offset);
  403.     }

  405.     /** Evaluate a parametric linear model.
  406.      * @param factory factory for the derivatives
  407.      * @param date current date
  408.      * @param offsetDriver driver for the offset parameter
  409.      * @param driftDriver driver for the drift parameter
  410.      * @param indices indices of the estimated parameters in derivatives computations
  411.      * @return current value of the linear model
  412.      * @deprecated as of 10.2, replaced by {@link #linearModel(int, FieldAbsoluteDate, ParameterDriver, ParameterDriver, Map)}
  413.      */
  414.     @Deprecated
  415.     private DerivativeStructure linearModel(final DSFactory factory, final FieldAbsoluteDate<DerivativeStructure> date,
  416.                                             final ParameterDriver offsetDriver, final ParameterDriver driftDriver,
  417.                                             final Map<String, Integer> indices) {
  418.         if (offsetDriver.getReferenceDate() == null) {
  419.             throw new OrekitException(OrekitMessages.NO_REFERENCE_DATE_FOR_PARAMETER,
  420.                                       offsetDriver.getName());
  421.         }
  422.         final DerivativeStructure dt     = date.durationFrom(offsetDriver.getReferenceDate());
  423.         final DerivativeStructure offset = offsetDriver.getValue(factory, indices);
  424.         final DerivativeStructure drift  = driftDriver.getValue(factory, indices);
  425.         return dt.multiply(drift).add(offset);
  426.     }

  428.     /** Evaluate a parametric linear model.
  429.      * @param freeParameters total number of free parameters in the gradient
  430.      * @param date current date
  431.      * @param offsetDriver driver for the offset parameter
  432.      * @param driftDriver driver for the drift parameter
  433.      * @param indices indices of the estimated parameters in derivatives computations
  434.      * @return current value of the linear model
  435.      * @since 10.2
  436.      */
  437.     private Gradient linearModel(final int freeParameters, final FieldAbsoluteDate<Gradient> date,
  438.                                  final ParameterDriver offsetDriver, final ParameterDriver driftDriver,
  439.                                  final Map<String, Integer> indices) {
  440.         if (offsetDriver.getReferenceDate() == null) {
  441.             throw new OrekitException(OrekitMessages.NO_REFERENCE_DATE_FOR_PARAMETER,
  442.                                       offsetDriver.getName());
  443.         }
  444.         final Gradient dt     = date.durationFrom(offsetDriver.getReferenceDate());
  445.         final Gradient offset = offsetDriver.getValue(freeParameters, indices);
  446.         final Gradient drift  = driftDriver.getValue(freeParameters, indices);
  447.         return dt.multiply(drift).add(offset);
  448.     }

  450.     /** Replace the instance with a data transfer object for serialization.
  451.      * <p>
  452.      * This intermediate class serializes the files supported names, the ephemeris type
  453.      * and the body name.
  454.      * </p>
  455.      * @return data transfer object that will be serialized
  456.      */
  457.     private Object writeReplace() {
  458.         return new DataTransferObject(baseUT1,
  459.                                       primeMeridianOffsetDriver.getValue(),
  460.                                       primeMeridianDriftDriver.getValue(),
  461.                                       polarOffsetXDriver.getValue(),
  462.                                       polarDriftXDriver.getValue(),
  463.                                       polarOffsetYDriver.getValue(),
  464.                                       polarDriftYDriver.getValue());
  465.     }

  467.     /** Local time scale for estimated UT1. */
  468.     private class EstimatedUT1Scale extends UT1Scale {

  470.         /** Serializable UID. */
  471.         private static final long serialVersionUID = 20170922L;

  473.         /** Simple constructor.
  474.          */
  475.         EstimatedUT1Scale() {
  476.             super(baseUT1.getEOPHistory(), baseUT1.getUTCScale());
  477.         }

  479.         /** {@inheritDoc} */
  480.         @Override
  481.         public <T extends RealFieldElement<T>> T offsetFromTAI(final FieldAbsoluteDate<T> date) {
  482.             final T dut1 = linearModel(date, primeMeridianOffsetDriver, primeMeridianDriftDriver).divide(EARTH_ANGULAR_VELOCITY);
  483.             return baseUT1.offsetFromTAI(date).add(dut1);
  484.         }

  486.         /** {@inheritDoc} */
  487.         @Override
  488.         public double offsetFromTAI(final AbsoluteDate date) {
  489.             final double dut1 = linearModel(date, primeMeridianOffsetDriver, primeMeridianDriftDriver) / EARTH_ANGULAR_VELOCITY;
  490.             return baseUT1.offsetFromTAI(date) + dut1;
  491.         }

  493.         /** {@inheritDoc} */
  494.         @Override
  495.         public String getName() {
  496.             return baseUT1.getName() + "/estimated";
  497.         }

  499.     }

  501.     /** Internal class used only for serialization. */
  502.     private static class DataTransferObject implements Serializable {

  504.         /** Serializable UID. */
  505.         private static final long serialVersionUID = 20171124L;

  507.         /** Underlying raw UT1. */
  508.         private final UT1Scale baseUT1;

  510.         /** Current prime meridian offset. */
  511.         private final double primeMeridianOffset;

  513.         /** Current prime meridian drift. */
  514.         private final double primeMeridianDrift;

  516.         /** Current pole offset along X. */
  517.         private final double polarOffsetX;

  519.         /** Current pole drift along X. */
  520.         private final double polarDriftX;

  522.         /** Current pole offset along Y. */
  523.         private final double polarOffsetY;

  525.         /** Current pole drift along Y. */
  526.         private final double polarDriftY;

  528.         /** Simple constructor.
  529.          * @param baseUT1 underlying raw UT1
  530.          * @param primeMeridianOffset current prime meridian offset
  531.          * @param primeMeridianDrift current prime meridian drift
  532.          * @param polarOffsetX current pole offset along X
  533.          * @param polarDriftX current pole drift along X
  534.          * @param polarOffsetY current pole offset along Y
  535.          * @param polarDriftY current pole drift along Y
  536.          */
  537.         DataTransferObject(final  UT1Scale baseUT1,
  538.                            final double primeMeridianOffset, final double primeMeridianDrift,
  539.                            final double polarOffsetX,        final double polarDriftX,
  540.                            final double polarOffsetY,        final double polarDriftY) {
  541.             this.baseUT1             = baseUT1;
  542.             this.primeMeridianOffset = primeMeridianOffset;
  543.             this.primeMeridianDrift  = primeMeridianDrift;
  544.             this.polarOffsetX        = polarOffsetX;
  545.             this.polarDriftX         = polarDriftX;
  546.             this.polarOffsetY        = polarOffsetY;
  547.             this.polarDriftY         = polarDriftY;
  548.         }

  550.         /** Replace the deserialized data transfer object with a {@link EstimatedEarthFrameProvider}.
  551.          * @return replacement {@link EstimatedEarthFrameProvider}
  552.          */
  553.         private Object readResolve() {
  554.             try {
  555.                 final EstimatedEarthFrameProvider provider = new EstimatedEarthFrameProvider(baseUT1);
  556.                 provider.getPrimeMeridianOffsetDriver().setValue(primeMeridianOffset);
  557.                 provider.getPrimeMeridianDriftDriver().setValue(primeMeridianDrift);
  558.                 provider.getPolarOffsetXDriver().setValue(polarOffsetX);
  559.                 provider.getPolarDriftXDriver().setValue(polarDriftX);
  560.                 provider.getPolarOffsetYDriver().setValue(polarOffsetY);
  561.                 provider.getPolarDriftYDriver().setValue(polarDriftY);
  562.                 return provider;
  563.             } catch (OrekitException oe) {
  564.                 // this should never happen as values already come from previous drivers
  565.                 throw new OrekitInternalError(oe);
  566.             }
  567.         }

  569.     }

  571. }
Created with JaCoCo 0.8.5.201910111838