Range.java

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

  19. import java.util.Arrays;
  20. import java.util.HashMap;
  21. import java.util.Map;

  23. import org.hipparchus.Field;
  24. import org.hipparchus.analysis.differentiation.DSFactory;
  25. import org.hipparchus.analysis.differentiation.DerivativeStructure;
  26. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.frames.FieldTransform;
  29. import org.orekit.propagation.SpacecraftState;
  30. import org.orekit.time.AbsoluteDate;
  31. import org.orekit.time.FieldAbsoluteDate;
  32. import org.orekit.utils.Constants;
  33. import org.orekit.utils.ParameterDriver;
  34. import org.orekit.utils.TimeStampedFieldPVCoordinates;
  35. import org.orekit.utils.TimeStampedPVCoordinates;

  37. /** Class modeling a range measurement from a ground station or
  38.  * from a satellite.
  39.  * <p>
  40.  * For two-way measurements, the measurement is considered
  41.  * to be a signal emitted from a ground station, reflected
  42.  * on spacecraft, and received on the same ground station.
  43.  * Its value is the elapsed time between emission and reception
  44.  * divided by 2c were c is the speed of light.
  45.  * </p>
  46.  * <p>
  47.  * For one-way measurements, a signal is emitted by the satellite
  48.  * and received by the ground station. The measurement value
  49.  * is the elapsed time between emission and reception divided by
  50.  * the speed of light.
  51.  * </p>
  52.  * <p>
  53.  * The motion of both the station and the
  54.  * spacecraft during the signal flight time are taken into
  55.  * account. The date of the measurement corresponds to the
  56.  * reception on ground of the emitted or reflected signal.
  57.  * </p>
  58.  * @author Thierry Ceolin
  59.  * @author Luc Maisonobe
  60.  * @author Maxime Journot
  61.  * @since 8.0
  62.  */
  63. public class Range extends AbstractMeasurement<Range> {

  65.     /** Ground station from which measurement is performed. */
  66.     private final GroundStation station;

  68.     /** Flag indicating whether it is a two-way measurement. */
  69.     private final boolean twoway;

  71.     /** Simple constructor.
  72.      * <p>
  73.      * This constructor uses 0 as the index of the propagator related
  74.      * to this measurement, thus being well suited for mono-satellite
  75.      * orbit determination.
  76.      * </p>
  77.      * @param station ground station from which measurement is performed
  78.      * @param date date of the measurement
  79.      * @param range observed value
  80.      * @param sigma theoretical standard deviation
  81.      * @param baseWeight base weight
  82.      * @exception OrekitException if a {@link org.orekit.utils.ParameterDriver}
  83.      * name conflict occurs
  84.      */
  85.     public Range(final GroundStation station, final AbsoluteDate date,
  86.                  final double range, final double sigma, final double baseWeight)
  87.         throws OrekitException {
  88.         this(station, true, date, range, sigma, baseWeight, 0);
  89.     }

  91.     /** Simple constructor.
  92.      * <p>
  93.      * This constructor uses 0 as the index of the propagator related
  94.      * to this measurement, thus being well suited for mono-satellite
  95.      * orbit determination.
  96.      * </p>
  97.      * @param station ground station from which measurement is performed
  98.      * @param date date of the measurement
  99.      * @param range observed value
  100.      * @param sigma theoretical standard deviation
  101.      * @param baseWeight base weight
  102.      * @param twoWay flag indicating whether it is a two-way measurement
  103.      * @exception OrekitException if a {@link org.orekit.utils.ParameterDriver}
  104.      * name conflict occurs
  105.      */
  106.     public Range(final GroundStation station, final AbsoluteDate date, final double range,
  107.                  final double sigma, final double baseWeight, final boolean twoWay)
  108.         throws OrekitException {
  109.         this(station, twoWay, date, range, sigma, baseWeight, 0);
  110.     }

  112.     /** Simple constructor.
  113.      * @param station ground station from which measurement is performed
  114.      * @param date date of the measurement
  115.      * @param range observed value
  116.      * @param sigma theoretical standard deviation
  117.      * @param baseWeight base weight
  118.      * @param propagatorIndex index of the propagator related to this measurement
  119.      * @exception OrekitException if a {@link org.orekit.utils.ParameterDriver}
  120.      * name conflict occurs
  121.      * @since 9.0
  122.      */
  123.     public Range(final GroundStation station, final AbsoluteDate date,
  124.                  final double range, final double sigma, final double baseWeight,
  125.                  final int propagatorIndex)
  126.         throws OrekitException {
  127.         this(station, true, date, range, sigma, baseWeight, 0);
  128.     }

  130.     /** Simple constructor.
  131.      * @param station ground station from which measurement is performed
  132.      * @param twoWay flag indicating whether it is a two-way measurement
  133.      * @param date date of the measurement
  134.      * @param range observed value
  135.      * @param sigma theoretical standard deviation
  136.      * @param baseWeight base weight
  137.      * @param propagatorIndex index of the propagator related to this measurement
  138.      * @exception OrekitException if a {@link org.orekit.utils.ParameterDriver}
  139.      * name conflict occurs
  140.      * @since 9.0
  141.      */
  142.     public Range(final GroundStation station, final boolean twoWay, final AbsoluteDate date,
  143.                  final double range, final double sigma, final double baseWeight,
  144.                  final int propagatorIndex)
  145.         throws OrekitException {
  146.         super(date, range, sigma, baseWeight, Arrays.asList(propagatorIndex),
  147.               station.getEastOffsetDriver(),
  148.               station.getNorthOffsetDriver(),
  149.               station.getZenithOffsetDriver(),
  150.               station.getPrimeMeridianOffsetDriver(),
  151.               station.getPrimeMeridianDriftDriver(),
  152.               station.getPolarOffsetXDriver(),
  153.               station.getPolarDriftXDriver(),
  154.               station.getPolarOffsetYDriver(),
  155.               station.getPolarDriftYDriver());
  156.         this.station = station;
  157.         this.twoway = twoWay;
  158.     }

  160.     /** Get the ground station from which measurement is performed.
  161.      * @return ground station from which measurement is performed
  162.      */
  163.     public GroundStation getStation() {
  164.         return station;
  165.     }

  167.     /** Check if the instance represents a two-way measurement.
  168.      * @return true if the instance represents a two-way measurement
  169.      */
  170.     public boolean isTwoWay() {
  171.         return twoway;
  172.     }

  174.     /** {@inheritDoc} */
  175.     @Override
  176.     protected EstimatedMeasurement<Range> theoreticalEvaluation(final int iteration,
  177.                                                                 final int evaluation,
  178.                                                                 final SpacecraftState[] states)
  179.         throws OrekitException {

  181.         final SpacecraftState state = states[getPropagatorsIndices().get(0)];

  183.         // Range derivatives are computed with respect to spacecraft state in inertial frame
  184.         // and station parameters
  185.         // ----------------------
  186.         //
  187.         // Parameters:
  188.         //  - 0..2 - Position of the spacecraft in inertial frame
  189.         //  - 3..5 - Velocity of the spacecraft in inertial frame
  190.         //  - 6..n - station parameters (station offsets, pole, prime meridian...)
  191.         int nbParams = 6;
  192.         final Map<String, Integer> indices = new HashMap<>();
  193.         for (ParameterDriver driver : getParametersDrivers()) {
  194.             if (driver.isSelected()) {
  195.                 indices.put(driver.getName(), nbParams++);
  196.             }
  197.         }
  198.         final DSFactory                          factory = new DSFactory(nbParams, 1);
  199.         final Field<DerivativeStructure>         field   = factory.getDerivativeField();
  200.         final FieldVector3D<DerivativeStructure> zero    = FieldVector3D.getZero(field);

  202.         // Coordinates of the spacecraft expressed as a derivative structure
  203.         final TimeStampedFieldPVCoordinates<DerivativeStructure> pvaDS = getCoordinates(state, 0, factory);

  205.         // transform between station and inertial frame, expressed as a derivative structure
  206.         // The components of station's position in offset frame are the 3 last derivative parameters
  207.         final AbsoluteDate downlinkDate = getDate();
  208.         final FieldAbsoluteDate<DerivativeStructure> downlinkDateDS =
  209.                         new FieldAbsoluteDate<>(field, downlinkDate);
  210.         final FieldTransform<DerivativeStructure> offsetToInertialDownlink =
  211.                         station.getOffsetToInertial(state.getFrame(), downlinkDateDS, factory, indices);

  213.         // Station position in inertial frame at end of the downlink leg
  214.         final TimeStampedFieldPVCoordinates<DerivativeStructure> stationDownlink =
  215.                         offsetToInertialDownlink.transformPVCoordinates(new TimeStampedFieldPVCoordinates<>(downlinkDateDS,
  216.                                                                                                             zero, zero, zero));

  218.         // Compute propagation times
  219.         // (if state has already been set up to pre-compensate propagation delay,
  220.         //  we will have delta == tauD and transitState will be the same as state)

  222.         // Downlink delay
  223.         final DerivativeStructure tauD = signalTimeOfFlight(pvaDS, stationDownlink.getPosition(), downlinkDateDS);

  225.         // Transit state & Transit state (re)computed with derivative structures
  226.         final double                delta        = downlinkDate.durationFrom(state.getDate());
  227.         final DerivativeStructure   deltaMTauD   = tauD.negate().add(delta);
  228.         final SpacecraftState       transitState = state.shiftedBy(deltaMTauD.getValue());
  229.         final TimeStampedFieldPVCoordinates<DerivativeStructure> transitStateDS = pvaDS.shiftedBy(deltaMTauD);

  231.         // prepare the evaluation
  232.         final EstimatedMeasurement<Range> estimated;
  233.         final DerivativeStructure range;

  235.         if (twoway) {

  237.             // Station at transit state date (derivatives of tauD taken into account)
  238.             final TimeStampedFieldPVCoordinates<DerivativeStructure> stationAtTransitDate =
  239.                             stationDownlink.shiftedBy(tauD.negate());
  240.             // Uplink delay
  241.             final DerivativeStructure tauU =
  242.                             signalTimeOfFlight(stationAtTransitDate, transitStateDS.getPosition(), transitStateDS.getDate());
  243.             final TimeStampedFieldPVCoordinates<DerivativeStructure> stationUplink =
  244.                             stationDownlink.shiftedBy(-tauD.getValue() - tauU.getValue());

  246.             // Prepare the evaluation
  247.             estimated = new EstimatedMeasurement<Range>(this, iteration, evaluation,
  248.                                                             new SpacecraftState[] {
  249.                                                                 transitState
  250.                                                             }, new TimeStampedPVCoordinates[] {
  251.                                                                 stationUplink.toTimeStampedPVCoordinates(),
  252.                                                                 transitStateDS.toTimeStampedPVCoordinates(),
  253.                                                                 stationDownlink.toTimeStampedPVCoordinates()
  254.                                                             });

  256.             // Range value
  257.             final double              cOver2 = 0.5 * Constants.SPEED_OF_LIGHT;
  258.             final DerivativeStructure tau    = tauD.add(tauU);
  259.             range                            = tau.multiply(cOver2);

  261.         } else {

  263.             estimated = new EstimatedMeasurement<Range>(this, iteration, evaluation,
  264.                             new SpacecraftState[] {
  265.                                 transitState
  266.                             }, new TimeStampedPVCoordinates[] {
  267.                                 transitStateDS.toTimeStampedPVCoordinates(),
  268.                                 stationDownlink.toTimeStampedPVCoordinates()
  269.                             });

  271.             // Range value
  272.             range = tauD.multiply(Constants.SPEED_OF_LIGHT);
  273.         }

  275.         estimated.setEstimatedValue(range.getValue());

  277.         // Range partial derivatives with respect to state
  278.         final double[] derivatives = range.getAllDerivatives();
  279.         estimated.setStateDerivatives(0, Arrays.copyOfRange(derivatives, 1, 7));

  281.         // set partial derivatives with respect to parameters
  282.         // (beware element at index 0 is the value, not a derivative)
  283.         for (final ParameterDriver driver : getParametersDrivers()) {
  284.             final Integer index = indices.get(driver.getName());
  285.             if (index != null) {
  286.                 estimated.setParameterDerivatives(driver, derivatives[index + 1]);
  287.             }
  288.         }

  290.         return estimated;

  292.     }

  294. }
Created with JaCoCo 0.7.9.201702052155