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

  19. import java.util.Map;

  21. import org.hipparchus.Field;
  22. import org.hipparchus.analysis.differentiation.DSFactory;
  23. import org.hipparchus.analysis.differentiation.DerivativeStructure;
  24. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  25. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  26. import org.hipparchus.geometry.euclidean.threed.Rotation;
  27. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  28. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  29. import org.hipparchus.util.FastMath;
  30. import org.orekit.bodies.BodyShape;
  31. import org.orekit.bodies.FieldGeodeticPoint;
  32. import org.orekit.bodies.GeodeticPoint;
  33. import org.orekit.bodies.OneAxisEllipsoid;
  34. import org.orekit.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;
  36. import org.orekit.frames.FieldTransform;
  37. import org.orekit.frames.Frame;
  38. import org.orekit.frames.TopocentricFrame;
  39. import org.orekit.frames.Transform;
  40. import org.orekit.time.AbsoluteDate;
  41. import org.orekit.time.FieldAbsoluteDate;
  42. import org.orekit.utils.ParameterDriver;

  44. /** Class modeling a ground station that can perform some measurements.
  45.  * <p>
  46.  * This class adds a position offset parameter to a base {@link TopocentricFrame
  47.  * topocentric frame}.
  48.  * </p>
  49.  * <p>
  50.  * Since 9.0, this class also adds parameters for an additional polar motion
  51.  * and an additional prime meridian orientation. Since these parameters will
  52.  * have the same name for all ground stations, they will be managed consistently
  53.  * and allow to estimate Earth orientation precisely (this is needed for precise
  54.  * orbit determination). The polar motion and prime meridian orientation will
  55.  * be applied <em>after</em> regular Earth orientation parameters, so the value
  56.  * of the estimated parameters will be correction to EOP, they will not be the
  57.  * complete EOP values by themselves. Basically, this means that for Earth, the
  58.  * following transforms are applied in order, between inertial frame and ground
  59.  * station frame (for non-Earth based ground stations, different precession nutation
  60.  * models and associated planet oritentation parameters would be applied, if available):
  61.  * </p>
  62.  * <ol>
  63.  *   <li>precession/nutation, as theoretical model plus celestial pole EOP parameters</li>
  64.  *   <li>body rotation, as theoretical model plus prime meridian EOP parameters</li>
  65.  *   <li>polar motion, which is only from EOP parameters (no theoretical models)</li>
  66.  *   <li>additional body rotation, controlled by {@link #getPrimeMeridianOffsetDriver()} and {@link #getPrimeMeridianDriftDriver()}</li>
  67.  *   <li>additional polar motion, controlled by {@link #getPolarOffsetXDriver()}, {@link #getPolarDriftXDriver()},
  68.  *   {@link #getPolarOffsetYDriver()} and {@link #getPolarDriftYDriver()}</li>
  69.  *   <li>station position offset, controlled by {@link #getEastOffsetDriver()},
  70.  *   {@link #getNorthOffsetDriver()} and {@link #getZenithOffsetDriver()}</li>
  71.  * </ol>
  72.  * @author Luc Maisonobe
  73.  * @since 8.0
  74.  */
  75. public class GroundStation {

  77.     /** Suffix for ground station position offset parameter name. */
  78.     public static final String OFFSET_SUFFIX = "-offset";

  80.     /** Suffix for ground station intermediate frame name. */
  81.     public static final String INTERMEDIATE_SUFFIX = "-intermediate";

  83.     /** Offsets scaling factor.
  84.      * <p>
  85.      * We use a power of 2 (in fact really 1.0 here) to avoid numeric noise introduction
  86.      * in the multiplications/divisions sequences.
  87.      * </p>
  88.      */
  89.     private static final double OFFSET_SCALE = FastMath.scalb(1.0, 0);

  91.     /** Angular scaling factor.
  92.      * <p>
  93.      * We use a power of 2 to avoid numeric noise introduction
  94.      * in the multiplications/divisions sequences.
  95.      * </p>
  96.      */
  97.     private static final double ANGULAR_SCALE = FastMath.scalb(1.0, -22);

  99.     /** Base frame associated with the station. */
  100.     private final TopocentricFrame baseFrame;

  102.     /** Driver for position offset along the East axis. */
  103.     private final ParameterDriver eastOffsetDriver;

  105.     /** Driver for position offset along the North axis. */
  106.     private final ParameterDriver northOffsetDriver;

  108.     /** Driver for position offset along the zenith axis. */
  109.     private final ParameterDriver zenithOffsetDriver;

  111.     /** Driver for prime meridian offset. */
  112.     private final ParameterDriver primeMeridianOffsetDriver;

  114.     /** Driver for prime meridian drift. */
  115.     private final ParameterDriver primeMeridianDriftDriver;

  117.     /** Driver for pole offset along X. */
  118.     private final ParameterDriver polarOffsetXDriver;

  120.     /** Driver for pole drift along X. */
  121.     private final ParameterDriver polarDriftXDriver;

  123.     /** Driver for pole offset along Y. */
  124.     private final ParameterDriver polarOffsetYDriver;

  126.     /** Driver for pole drift along Y. */
  127.     private final ParameterDriver polarDriftYDriver;

  129.     /** Simple constructor.
  130.      * <p>
  131.      * The initial values for the pole and prime meridian parametric linear models
  132.      * ({@link #getPrimeMeridianOffsetDriver()}, {@link #getPrimeMeridianDriftDriver()},
  133.      * {@link #getPolarOffsetXDriver()}, {@link #getPolarDriftXDriver()},
  134.      * {@link #getPolarOffsetXDriver()}, {@link #getPolarDriftXDriver()}) are set to 0.
  135.      * The initial values for the station offset model ({@link #getEastOffsetDriver()},
  136.      * {@link #getNorthOffsetDriver()}, {@link #getZenithOffsetDriver()}) are set to 0.
  137.      * This implies that as long as these values are not changed, the offset frame is
  138.      * the same as the {@link #getBaseFrame() base frame}. As soon as some of these models
  139.      * are changed, the offset frame moves away from the {@link #getBaseFrame() base frame}.
  140.      * </p>
  141.      * @param baseFrame base frame associated with the station, without *any* parametric
  142.      * model (no station offset, no polar motion, no meridian shift)
  143.      * @exception OrekitException if some frame transforms cannot be computed
  144.      * or if the ground station is not defined on a {@link OneAxisEllipsoid ellipsoid}.
  145.      */
  146.     public GroundStation(final TopocentricFrame baseFrame)
  147.         throws OrekitException {

  149.         this.baseFrame = baseFrame;

  151.         this.eastOffsetDriver = new ParameterDriver(baseFrame.getName() + OFFSET_SUFFIX + "-East",
  152.                                                     0.0, OFFSET_SCALE,
  153.                                                     Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  155.         this.northOffsetDriver = new ParameterDriver(baseFrame.getName() + OFFSET_SUFFIX + "-North",
  156.                                                      0.0, OFFSET_SCALE,
  157.                                                      Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  159.         this.zenithOffsetDriver = new ParameterDriver(baseFrame.getName() + OFFSET_SUFFIX + "-Zenith",
  160.                                                       0.0, OFFSET_SCALE,
  161.                                                       Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  163.         this.primeMeridianOffsetDriver = new ParameterDriver("prime-meridian-offset",
  164.                                                              0.0, ANGULAR_SCALE,
  165.                                                             -FastMath.PI, FastMath.PI);

  167.         this.primeMeridianDriftDriver = new ParameterDriver("prime-meridian-drift",
  168.                                                             0.0, ANGULAR_SCALE,
  169.                                                             Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  171.         this.polarOffsetXDriver = new ParameterDriver("polar-offset-X",
  172.                                                       0.0, ANGULAR_SCALE,
  173.                                                       -FastMath.PI, FastMath.PI);

  175.         this.polarDriftXDriver = new ParameterDriver("polar-drift-X",
  176.                                                      0.0, ANGULAR_SCALE,
  177.                                                      Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  179.         this.polarOffsetYDriver = new ParameterDriver("polar-offset-Y",
  180.                                                       0.0, ANGULAR_SCALE,
  181.                                                       -FastMath.PI, FastMath.PI);

  183.         this.polarDriftYDriver = new ParameterDriver("polar-drift-Y",
  184.                                                      0.0, ANGULAR_SCALE,
  185.                                                      Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);

  187.     }

  189.     /** Get a driver allowing to change station position along East axis.
  190.      * @return driver for station position offset along East axis
  191.      */
  192.     public ParameterDriver getEastOffsetDriver() {
  193.         return eastOffsetDriver;
  194.     }

  196.     /** Get a driver allowing to change station position along North axis.
  197.      * @return driver for station position offset along North axis
  198.      */
  199.     public ParameterDriver getNorthOffsetDriver() {
  200.         return northOffsetDriver;
  201.     }

  203.     /** Get a driver allowing to change station position along Zenith axis.
  204.      * @return driver for station position offset along Zenith axis
  205.      */
  206.     public ParameterDriver getZenithOffsetDriver() {
  207.         return zenithOffsetDriver;
  208.     }

  210.     /** Get a driver allowing to add a prime meridian rotation.
  211.      * <p>
  212.      * The parameter is an angle in radians. In order to convert this
  213.      * value to a DUT1 in seconds, the value must be divided by
  214.      * {@code ave = 7.292115146706979e-5} (which is the nominal Angular Velocity
  215.      * of Earth from the TIRF model).
  216.      * </p>
  217.      * @return driver for prime meridian rotation
  218.      */
  219.     public ParameterDriver getPrimeMeridianOffsetDriver() {
  220.         return primeMeridianOffsetDriver;
  221.     }

  223.     /** Get a driver allowing to add a prime meridian rotation rate.
  224.      * <p>
  225.      * The parameter is an angle rate in radians per second. In order to convert this
  226.      * value to a LOD in seconds, the value must be multiplied by -86400 and divided by
  227.      * {@code ave = 7.292115146706979e-5} (which is the nominal Angular Velocity
  228.      * of Earth from the TIRF model).
  229.      * </p>
  230.      * @return driver for prime meridian rotation rate
  231.      */
  232.     public ParameterDriver getPrimeMeridianDriftDriver() {
  233.         return primeMeridianDriftDriver;
  234.     }

  236.     /** Get a driver allowing to add a polar offset along X.
  237.      * <p>
  238.      * The parameter is an angle in radians
  239.      * </p>
  240.      * @return driver for polar offset along X
  241.      */
  242.     public ParameterDriver getPolarOffsetXDriver() {
  243.         return polarOffsetXDriver;
  244.     }

  246.     /** Get a driver allowing to add a polar drift along X.
  247.      * <p>
  248.      * The parameter is an angle rate in radians per second
  249.      * </p>
  250.      * @return driver for polar drift along X
  251.      */
  252.     public ParameterDriver getPolarDriftXDriver() {
  253.         return polarDriftXDriver;
  254.     }

  256.     /** Get a driver allowing to add a polar offset along Y.
  257.      * <p>
  258.      * The parameter is an angle in radians
  259.      * </p>
  260.      * @return driver for polar offset along Y
  261.      */
  262.     public ParameterDriver getPolarOffsetYDriver() {
  263.         return polarOffsetYDriver;
  264.     }

  266.     /** Get a driver allowing to add a polar drift along Y.
  267.      * <p>
  268.      * The parameter is an angle rate in radians per second
  269.      * </p>
  270.      * @return driver for polar drift along Y
  271.      */
  272.     public ParameterDriver getPolarDriftYDriver() {
  273.         return polarDriftYDriver;
  274.     }

  276.     /** Get the base frame associated with the station.
  277.      * <p>
  278.      * The base frame corresponds to a null position offset, null
  279.      * polar motion, null meridian shift
  280.      * </p>
  281.      * @return base frame associated with the station
  282.      */
  283.     public TopocentricFrame getBaseFrame() {
  284.         return baseFrame;
  285.     }

  287.     /** Get the geodetic point at the center of the offset frame.
  288.      * @return geodetic point at the center of the offset frame
  289.      * @exception OrekitException if frames transforms cannot be computed
  290.      */
  291.     public GeodeticPoint getOffsetGeodeticPoint()
  292.         throws OrekitException {

  294.         // take station offset into account
  295.         final double    x          = parametricModel(eastOffsetDriver);
  296.         final double    y          = parametricModel(northOffsetDriver);
  297.         final double    z          = parametricModel(zenithOffsetDriver);
  298.         final BodyShape baseShape  = baseFrame.getParentShape();
  299.         final Transform baseToBody = baseFrame.getTransformTo(baseShape.getBodyFrame(), (AbsoluteDate) null);
  300.         final Vector3D  origin     = baseToBody.transformPosition(new Vector3D(x, y, z));

  302.         return baseShape.transform(origin, baseShape.getBodyFrame(), null);

  304.     }

  306.     /** Get the transform between offset frame and inertial frame.
  307.      * <p>
  308.      * The offset frame takes the <em>current</em> position offset,
  309.      * polar motion and the meridian shift into account. The frame
  310.      * returned is disconnected from later changes in the parameters.
  311.      * When the {@link ParameterDriver parameters} managing these
  312.      * offsets are changed, the method must be called again to retrieve
  313.      * a new offset frame.
  314.      * </p>
  315.      * @param inertial inertial frame to transform to
  316.      * @param date date of the transform
  317.      * @return offset frame defining vectors
  318.      * @exception OrekitException if offset frame cannot be computed for current offset values
  319.      */
  320.     public Transform getOffsetToInertial(final Frame inertial, final AbsoluteDate date)
  321.         throws OrekitException {

  323.         // take parametric prime meridian shift into account
  324.         final double theta    = linearModel(date, primeMeridianOffsetDriver, primeMeridianDriftDriver);
  325.         final double thetaDot = parametricModel(primeMeridianDriftDriver);
  326.         final Transform meridianShift =
  327.                         new Transform(date,
  328.                                       new Rotation(Vector3D.PLUS_K, -theta, RotationConvention.FRAME_TRANSFORM),
  329.                                       new Vector3D(-thetaDot, Vector3D.PLUS_K));

  331.         // take parametric pole shift into account
  332.         final double xp     = linearModel(date, polarOffsetXDriver, polarDriftXDriver);
  333.         final double yp     = linearModel(date, polarOffsetYDriver, polarDriftYDriver);
  334.         final double xpDot  = parametricModel(polarDriftXDriver);
  335.         final double ypDot  = parametricModel(polarDriftYDriver);
  336.         final Transform poleShift =
  337.                         new Transform(date,
  338.                                       new Transform(date,
  339.                                                     new Rotation(Vector3D.PLUS_I, yp, RotationConvention.FRAME_TRANSFORM),
  340.                                                     new Vector3D(ypDot, 0.0, 0.0)),
  341.                                       new Transform(date,
  342.                                                     new Rotation(Vector3D.PLUS_J, xp, RotationConvention.FRAME_TRANSFORM),
  343.                                                     new Vector3D(0.0, xpDot, 0.0)));

  345.         // take station offset into account
  346.         final double    x          = parametricModel(eastOffsetDriver);
  347.         final double    y          = parametricModel(northOffsetDriver);
  348.         final double    z          = parametricModel(zenithOffsetDriver);
  349.         final BodyShape baseShape  = baseFrame.getParentShape();
  350.         final Transform baseToBody = baseFrame.getTransformTo(baseShape.getBodyFrame(), (AbsoluteDate) null);

  352.         final Vector3D      origin   = baseToBody.transformPosition(new Vector3D(x, y, z));
  353.         final GeodeticPoint originGP = baseShape.transform(origin, baseShape.getBodyFrame(), date);
  354.         final Transform offsetToIntermediate =
  355.                         new Transform(date,
  356.                                       new Transform(date,
  357.                                                     new Rotation(Vector3D.PLUS_I, Vector3D.PLUS_K,
  358.                                                                  originGP.getEast(), originGP.getZenith()),
  359.                                                     Vector3D.ZERO),
  360.                                       new Transform(date, origin));

  362.         // combine all transforms together
  363.         final Transform intermediateToBody = new Transform(date, poleShift, meridianShift);
  364.         final Transform bodyToInert        = baseFrame.getParent().getTransformTo(inertial, date);

  366.         return new Transform(date, offsetToIntermediate, new Transform(date, intermediateToBody, bodyToInert));

  368.     }

  370.     /** Get the transform between offset frame and inertial frame with derivatives.
  371.      * <p>
  372.      * As the East and North vector are not well defined at pole, the derivatives
  373.      * of these two vectors diverge to infinity as we get closer to the pole.
  374.      * So this method should not be used for stations less than 0.0001 degree from
  375.      * either poles.
  376.      * </p>
  377.      * @param inertial inertial frame to transform to
  378.      * @param date date of the transform
  379.      * @param factory factory for the derivatives
  380.      * @param indices indices of the estimated parameters in derivatives computations
  381.      * @return offset frame defining vectors with derivatives
  382.      * @exception OrekitException if some frame transforms cannot be computed
  383.      * @since 9.0
  384.      */
  385.     public FieldTransform<DerivativeStructure> getOffsetToInertial(final Frame inertial,
  386.                                                                    final FieldAbsoluteDate<DerivativeStructure> date,
  387.                                                                    final DSFactory factory,
  388.                                                                    final Map<String, Integer> indices)
  389.         throws OrekitException {

  391.         final Field<DerivativeStructure>         field = date.getField();
  392.         final FieldVector3D<DerivativeStructure> zero  = FieldVector3D.getZero(field);
  393.         final FieldVector3D<DerivativeStructure> plusI = FieldVector3D.getPlusI(field);
  394.         final FieldVector3D<DerivativeStructure> plusJ = FieldVector3D.getPlusJ(field);
  395.         final FieldVector3D<DerivativeStructure> plusK = FieldVector3D.getPlusK(field);

  397.         // take parametric prime meridian shift into account
  398.         final DerivativeStructure theta    = linearModel(factory, date,
  399.                                                          primeMeridianOffsetDriver, primeMeridianDriftDriver,
  400.                                                          indices);
  401.         final DerivativeStructure thetaDot = parametricModel(factory, primeMeridianDriftDriver, indices);
  402.         final FieldTransform<DerivativeStructure> meridianShift =
  403.                         new FieldTransform<>(date,
  404.                                              new FieldRotation<>(plusK, theta.negate(), RotationConvention.FRAME_TRANSFORM),
  405.                                              new FieldVector3D<>(thetaDot.negate(), plusK));

  407.         // take parametric pole shift into account
  408.         final DerivativeStructure xp    = linearModel(factory, date,
  409.                                                       polarOffsetXDriver, polarDriftXDriver, indices);
  410.         final DerivativeStructure yp    = linearModel(factory, date,
  411.                                                       polarOffsetYDriver, polarDriftYDriver, indices);
  412.         final DerivativeStructure xpDot = parametricModel(factory, polarDriftXDriver, indices);
  413.         final DerivativeStructure ypDot = parametricModel(factory, polarDriftYDriver, indices);
  414.         final FieldTransform<DerivativeStructure> poleShift =
  415.                         new FieldTransform<>(date,
  416.                                              new FieldTransform<>(date,
  417.                                                              new FieldRotation<>(plusI, yp, RotationConvention.FRAME_TRANSFORM),
  418.                                                              new FieldVector3D<>(ypDot, field.getZero(), field.getZero())),
  419.                                              new FieldTransform<>(date,
  420.                                                              new FieldRotation<>(plusJ, xp, RotationConvention.FRAME_TRANSFORM),
  421.                                                              new FieldVector3D<>(field.getZero(), xpDot, field.getZero())));

  423.         // take station offset into account
  424.         final DerivativeStructure  x          = parametricModel(factory, eastOffsetDriver,   indices);
  425.         final DerivativeStructure  y          = parametricModel(factory, northOffsetDriver,  indices);
  426.         final DerivativeStructure  z          = parametricModel(factory, zenithOffsetDriver, indices);
  427.         final BodyShape            baseShape  = baseFrame.getParentShape();
  428.         final Transform            baseToBody = baseFrame.getTransformTo(baseShape.getBodyFrame(), (AbsoluteDate) null);

  430.         final FieldVector3D<DerivativeStructure>      origin   = baseToBody.transformPosition(new FieldVector3D<>(x, y, z));
  431.         final FieldGeodeticPoint<DerivativeStructure> originGP = baseShape.transform(origin, baseShape.getBodyFrame(), date);
  432.         final FieldTransform<DerivativeStructure> offsetToIntermediate =
  433.                         new FieldTransform<>(date,
  434.                                              new FieldTransform<>(date,
  435.                                                                   new FieldRotation<>(plusI, plusK,
  436.                                                                                       originGP.getEast(), originGP.getZenith()),
  437.                                                                   zero),
  438.                                              new FieldTransform<>(date, origin));

  440.         // combine all transforms together
  441.         final FieldTransform<DerivativeStructure> intermediateToBody = new FieldTransform<>(date, poleShift, meridianShift);
  442.         final FieldTransform<DerivativeStructure> bodyToInert        = baseFrame.getParent().getTransformTo(inertial, date);

  444.         return new FieldTransform<>(date, offsetToIntermediate, new FieldTransform<>(date, intermediateToBody, bodyToInert));

  446.     }

  448.     /** Evaluate a parametric linear model.
  449.      * @param date current date
  450.      * @param offsetDriver driver for the offset parameter
  451.      * @param driftDriver driver for the drift parameter
  452.      * @return current value of the linear model
  453.      * @exception OrekitException if reference date has not been set for the
  454.      * offset driver
  455.      */
  456.     private double linearModel(final AbsoluteDate date,
  457.                                final ParameterDriver offsetDriver, final ParameterDriver driftDriver)
  458.         throws OrekitException {
  459.         if (offsetDriver.getReferenceDate() == null) {
  460.             throw new OrekitException(OrekitMessages.NO_REFERENCE_DATE_FOR_PARAMETER,
  461.                                       offsetDriver.getName());
  462.         }
  463.         final double dt     = date.durationFrom(offsetDriver.getReferenceDate());
  464.         final double offset = parametricModel(offsetDriver);
  465.         final double drift  = parametricModel(driftDriver);
  466.         return dt * drift + offset;
  467.     }

  469.     /** Evaluate a parametric linear model.
  470.      * @param factory factory for the derivatives
  471.      * @param date current date
  472.      * @param offsetDriver driver for the offset parameter
  473.      * @param driftDriver driver for the drift parameter
  474.      * @param indices indices of the estimated parameters in derivatives computations
  475.      * @return current value of the linear model
  476.      * @exception OrekitException if reference date has not been set for the
  477.      * offset driver
  478.      */
  479.     private DerivativeStructure linearModel(final DSFactory factory, final FieldAbsoluteDate<DerivativeStructure> date,
  480.                                             final ParameterDriver offsetDriver, final ParameterDriver driftDriver,
  481.                                             final Map<String, Integer> indices)
  482.         throws OrekitException {
  483.         if (offsetDriver.getReferenceDate() == null) {
  484.             throw new OrekitException(OrekitMessages.NO_REFERENCE_DATE_FOR_PARAMETER,
  485.                                       offsetDriver.getName());
  486.         }
  487.         final DerivativeStructure dt     = date.durationFrom(offsetDriver.getReferenceDate());
  488.         final DerivativeStructure offset = parametricModel(factory, offsetDriver, indices);
  489.         final DerivativeStructure drift  = parametricModel(factory, driftDriver, indices);
  490.         return dt.multiply(drift).add(offset);
  491.     }

  493.     /** Evaluate a parametric model.
  494.      * @param driver driver managing the parameter
  495.      * @return value of the parametric model
  496.      */
  497.     private double parametricModel(final ParameterDriver driver) {
  498.         return driver.getValue();
  499.     }

  501.     /** Evaluate a parametric model.
  502.      * @param factory factory for the derivatives
  503.      * @param driver driver managing the parameter
  504.      * @param indices indices of the estimated parameters in derivatives computations
  505.      * @return value of the parametric model
  506.      */
  507.     private DerivativeStructure parametricModel(final DSFactory factory, final ParameterDriver driver,
  508.                                                 final Map<String, Integer> indices) {
  509.         final Integer index = indices.get(driver.getName());
  510.         return (index == null) ?
  511.              factory.constant(driver.getValue()) :
  512.              factory.variable(index, driver.getValue());
  513.     }

  515. }
Created with JaCoCo 0.7.9.201702052155