EstimatedMeasurement.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.IdentityHashMap;
  20. import java.util.Map;
  21. import java.util.stream.Stream;

  23. import org.orekit.errors.OrekitIllegalArgumentException;
  24. import org.orekit.errors.OrekitMessages;
  25. import org.orekit.propagation.SpacecraftState;
  26. import org.orekit.time.AbsoluteDate;
  27. import org.orekit.utils.ParameterDriver;
  28. import org.orekit.utils.TimeStampedPVCoordinates;

  30. /** Class holding an estimated theoretical value associated to an {@link ObservedMeasurement observed measurement}.
  31.  * @param <T> the type of the measurement
  32.  * @author Luc Maisonobe
  33.  * @since 8.0
  34.  */
  35. public class EstimatedMeasurement<T extends ObservedMeasurement<T>> implements ComparableMeasurement {

  37.     /** Associated observed measurement. */
  38.     private final T observedMeasurement;

  40.     /** Iteration number. */
  41.     private final int iteration;

  43.     /** Evaluations counter. */
  44.     private final int count;

  46.     /** States of the spacecrafts. */
  47.     private final SpacecraftState[] states;

  49.     /** Coordinates of the participants in signal travel order. */
  50.     private final TimeStampedPVCoordinates[] participants;

  52.     /** Estimated value. */
  53.     private double[] estimatedValue;

  55.     /** Current weight.
  56.      * @deprecated as of 9.2, weight should not be changed anymore,
  57.      * rejected measurements are identified by their {@link #getStatus() status}
  58.      */
  59.     @Deprecated
  60.     private double[] currentWeight;

  62.     /** Measurement status. */
  63.     private Status status;

  65.     /** Partial derivatives with respect to states. */
  66.     private double[][][] stateDerivatives;

  68.     /** Partial derivatives with respect to parameters. */
  69.     private final Map<ParameterDriver, double[]> parametersDerivatives;

  71.     /** Simple constructor.
  72.      * @param observedMeasurement associated observed measurement
  73.      * @param iteration iteration number
  74.      * @param count evaluations counter
  75.      * @param states states of the spacecrafts
  76.      * @param participants coordinates of the participants in signal travel order
  77.      * in inertial frame
  78.      */
  79.     public EstimatedMeasurement(final T observedMeasurement,
  80.                                 final int iteration, final int count,
  81.                                 final SpacecraftState[] states,
  82.                                 final TimeStampedPVCoordinates[] participants) {
  83.         this.observedMeasurement   = observedMeasurement;
  84.         this.iteration             = iteration;
  85.         this.count                 = count;
  86.         this.states                = states.clone();
  87.         this.participants          = participants.clone();
  88.         this.status                = Status.PROCESSED;
  89.         this.stateDerivatives      = new double[states.length][][];
  90.         this.parametersDerivatives = new IdentityHashMap<ParameterDriver, double[]>();
  91.     }

  93.     /** Get the associated observed measurement.
  94.      * @return associated observed measurement
  95.      */
  96.     public T getObservedMeasurement() {
  97.         return observedMeasurement;
  98.     }

  100.     /** {@inheritDoc} */
  101.     @Override
  102.     public AbsoluteDate getDate() {
  103.         return observedMeasurement.getDate();
  104.     }

  106.     /** Get the iteration number.
  107.      * @return iteration number
  108.      */
  109.     public int getIteration() {
  110.         return iteration;
  111.     }

  113.     /** Get the evaluations counter.
  114.      * @return evaluations counter
  115.      */
  116.     public int getCount() {
  117.         return count;
  118.     }

  120.     /** Get the states of the spacecrafts.
  121.      * @return states of the spacecrafts
  122.      */
  123.     public SpacecraftState[] getStates() {
  124.         return states.clone();
  125.     }

  127.     /** Get the coordinates of the measurements participants in signal travel order.
  128.      * <p>
  129.      * First participant (at index 0) emits the signal (it is for example a ground
  130.      * station for two-way range measurement). Last participant receives the signal
  131.      * (it is also the ground station for two-way range measurement, but a few
  132.      * milliseconds later). Intermediate participants relfect the signal (it is the
  133.      * spacecraft for two-way range measurement).
  134.      * </p>
  135.      * @return coordinates of the measurements participants in signal travel order
  136.      * in inertial frame
  137.      */
  138.     public TimeStampedPVCoordinates[] getParticipants() {
  139.         return participants.clone();
  140.     }

  142.     /** Get the time offset from first state date to measurement date.
  143.      * @return time offset from first state date to measurement date
  144.      */
  145.     public double getTimeOffset() {
  146.         return observedMeasurement.getDate().durationFrom(states[0].getDate());
  147.     }

  149.     /** {@inheritDoc} */
  150.     @Override
  151.     public double[] getObservedValue() {
  152.         return observedMeasurement.getObservedValue();
  153.     }

  155.     /** Get the estimated value.
  156.      * @return estimated value
  157.      */
  158.     public double[] getEstimatedValue() {
  159.         return estimatedValue.clone();
  160.     }

  162.     /** Set the estimated value.
  163.      * @param estimatedValue estimated value
  164.      */
  165.     public void setEstimatedValue(final double... estimatedValue) {
  166.         this.estimatedValue = estimatedValue.clone();
  167.     }

  169.     /** Get the current weight.
  170.      * <p>
  171.      * By default, the current weight is measurement {@link
  172.      * ObservedMeasurement#getBaseWeight() base weight}.
  173.      * </p>
  174.      * @return current weight
  175.      * @deprecated as of 9.2, weight should not be changed anymore,
  176.      * rejected measurements are identified by their {@link #getStatus() status}
  177.      */
  178.     @Deprecated
  179.     public double[] getCurrentWeight() {
  180.         return currentWeight == null ? observedMeasurement.getBaseWeight() : currentWeight.clone();
  181.     }

  183.     /** Set the current weight.
  184.      * @param currentWeight current weight
  185.      * @deprecated as of 9.2, weight should not be changed anymore,
  186.      * rejected measurements are identified by their {@link #getStatus() status}
  187.      */
  188.     @Deprecated
  189.     public void setCurrentWeight(final double... currentWeight) {
  190.         this.currentWeight = currentWeight.clone();
  191.     }

  193.     /** Get the status.
  194.      * <p>
  195.      * The status is set to {@link Status#PROCESSED PROCESSED} at construction, and
  196.      * can be reset to {@link Status#REJECTED REJECTED} later on, typically by
  197.      * {@link org.orekit.estimation.measurements.modifiers.OutlierFilter OutlierFilter}
  198.      * or {@link org.orekit.estimation.measurements.modifiers.DynamicOutlierFilter DynamicOutlierFilter}
  199.      * </p>
  200.      * @return status
  201.      */
  202.     public Status getStatus() {
  203.         return status;
  204.     }

  206.     /** Set the status.
  207.      * @param status status to set
  208.      */
  209.     public void setStatus(final Status status) {
  210.         this.status = status;
  211.     }

  213.     /** Get the partial derivatives of the {@link #getEstimatedValue()
  214.      * simulated measurement} with respect to state Cartesian coordinates.
  215.      * @param index index of the state, according to the {@code states}
  216.      * passed at construction
  217.      * @return partial derivatives of the simulated value (array of size
  218.      * {@link ObservedMeasurement#getDimension() dimension} x 6)
  219.      */
  220.     public double[][] getStateDerivatives(final int index) {
  221.         final double[][] sd = new double[observedMeasurement.getDimension()][];
  222.         for (int i = 0; i < observedMeasurement.getDimension(); ++i) {
  223.             sd[i] = stateDerivatives[index][i].clone();
  224.         }
  225.         return sd;
  226.     }

  228.     /** Set the partial derivatives of the {@link #getEstimatedValue()
  229.      * simulated measurement} with respect to state Cartesian coordinates.
  230.      * @param index index of the state, according to the {@code states}
  231.      * passed at construction
  232.      * @param derivatives partial derivatives with respect to state
  233.      */
  234.     public void setStateDerivatives(final int index, final double[]... derivatives) {
  235.         this.stateDerivatives[index] = new double[observedMeasurement.getDimension()][];
  236.         for (int i = 0; i < observedMeasurement.getDimension(); ++i) {
  237.             this.stateDerivatives[index][i] = derivatives[i].clone();
  238.         }
  239.     }

  241.     /** Get all the drivers with set derivatives.
  242.      * @return all the drivers with set derivatives
  243.      * @since 9.0
  244.      */
  245.     public Stream<ParameterDriver> getDerivativesDrivers() {
  246.         return parametersDerivatives.entrySet().stream().map(entry -> entry.getKey());
  247.     }

  249.     /** Get the partial derivatives of the {@link #getEstimatedValue()
  250.      * simulated measurement} with respect to a parameter.
  251.      * @param driver driver for the parameter
  252.      * @return partial derivatives of the simulated value
  253.      * @exception OrekitIllegalArgumentException if parameter is unknown
  254.      */
  255.     public double[] getParameterDerivatives(final ParameterDriver driver)
  256.         throws OrekitIllegalArgumentException {
  257.         final double[] p = parametersDerivatives.get(driver);
  258.         if (p == null) {
  259.             final StringBuilder builder = new StringBuilder();
  260.             for (final Map.Entry<ParameterDriver, double[]> entry : parametersDerivatives.entrySet()) {
  261.                 if (builder.length() > 0) {
  262.                     builder.append(", ");
  263.                 }
  264.                 builder.append(entry.getKey().getName());
  265.             }
  266.             throw new OrekitIllegalArgumentException(OrekitMessages.UNSUPPORTED_PARAMETER_NAME,
  267.                                                      driver.getName(),
  268.                                                      builder.length() > 0 ? builder.toString() : "<none>");
  269.         }
  270.         return p;
  271.     }

  273.     /** Set the partial derivatives of the {@link #getEstimatedValue()
  274.      * simulated measurement} with respect to parameter.
  275.      * @param driver driver for the parameter
  276.      * @param parameterDerivatives partial derivatives with respect to parameter
  277.      */
  278.     public void setParameterDerivatives(final ParameterDriver driver, final double... parameterDerivatives) {
  279.         parametersDerivatives.put(driver, parameterDerivatives);
  280.     }

  282.     /** Enumerate for the status of the measurement. */
  283.     public enum Status {

  285.         /** Status for processed measurements. */
  286.         PROCESSED,

  288.         /** Status for rejected measurements. */
  289.         REJECTED;

  291.     }

  293. }
Created with JaCoCo 0.7.9.201702052155