TroposphericDSConverter.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.modifiers;

  19. import java.util.ArrayList;
  20. import java.util.List;

  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.Vector3D;
  27. import org.orekit.attitudes.AttitudeProvider;
  28. import org.orekit.attitudes.FieldAttitude;
  29. import org.orekit.models.earth.troposphere.DiscreteTroposphericModel;
  30. import org.orekit.orbits.FieldCartesianOrbit;
  31. import org.orekit.orbits.FieldOrbit;
  32. import org.orekit.propagation.FieldSpacecraftState;
  33. import org.orekit.propagation.SpacecraftState;
  34. import org.orekit.utils.FieldAngularCoordinates;
  35. import org.orekit.utils.FieldPVCoordinates;
  36. import org.orekit.utils.ParameterDriver;
  37. import org.orekit.utils.TimeStampedFieldAngularCoordinates;
  38. import org.orekit.utils.TimeStampedFieldPVCoordinates;

  40. /** Converter for states and parameters arrays.
  41.  * @author Luc Maisonobe
  42.  * @deprecated as of 10.2, replaced by {@link TroposphericGradientConverter}
  43.  */
  44. @Deprecated
  45. public class TroposphericDSConverter {

  47.     /** Dimension of the state. */
  48.     private final int freeStateParameters;

  50.     /** States with various number of additional parameters for tropospheric models. */
  51.     private final List<FieldSpacecraftState<DerivativeStructure>> dsStates;

  53.     /** Simple constructor.
  54.      * @param state regular state
  55.      * @param freeStateParameters number of free parameters, either 3 (position) or 6 (position-velocity)
  56.      * @param provider provider to use if attitude needs to be recomputed
  57.      */
  58.     public TroposphericDSConverter(final SpacecraftState state, final int freeStateParameters, final AttitudeProvider provider) {

  60.         this.freeStateParameters = freeStateParameters;

  62.         // prepare derivation variables, position, optionally velocity
  63.         final DSFactory factory = new DSFactory(freeStateParameters, 1);

  65.         // position always has derivatives
  66.         final Vector3D pos = state.getPVCoordinates().getPosition();
  67.         final FieldVector3D<DerivativeStructure> posDS = new FieldVector3D<>(factory.variable(0, pos.getX()),
  68.                                                                              factory.variable(1, pos.getY()),
  69.                                                                              factory.variable(2, pos.getZ()));

  71.         // velocity may have derivatives or not
  72.         final Vector3D vel = state.getPVCoordinates().getVelocity();
  73.         final FieldVector3D<DerivativeStructure> velDS;
  74.         if (freeStateParameters > 3) {
  75.             velDS = new FieldVector3D<>(factory.variable(3, vel.getX()),
  76.                                         factory.variable(4, vel.getY()),
  77.                                         factory.variable(5, vel.getZ()));
  78.         } else {
  79.             velDS = new FieldVector3D<>(factory.constant(vel.getX()),
  80.                                         factory.constant(vel.getY()),
  81.                                         factory.constant(vel.getZ()));
  82.         }

  84.         // acceleration never has derivatives
  85.         final Vector3D acc = state.getPVCoordinates().getAcceleration();
  86.         final FieldVector3D<DerivativeStructure> accDS = new FieldVector3D<>(factory.constant(acc.getX()),
  87.                                                                              factory.constant(acc.getY()),
  88.                                                                              factory.constant(acc.getZ()));

  90.         // mass never has derivatives
  91.         final DerivativeStructure dsM = factory.constant(state.getMass());

  93.         final FieldOrbit<DerivativeStructure> dsOrbit =
  94.                         new FieldCartesianOrbit<>(new TimeStampedFieldPVCoordinates<>(state.getDate(), posDS, velDS, accDS),
  95.                                                   state.getFrame(),
  96.                                                   factory.getDerivativeField().getZero().add(state.getMu()));

  98.         final FieldAttitude<DerivativeStructure> dsAttitude;
  99.         if (freeStateParameters > 3) {
  100.             // compute attitude partial derivatives with respect to position/velocity
  101.             dsAttitude = provider.getAttitude(dsOrbit, dsOrbit.getDate(), dsOrbit.getFrame());
  102.         } else {
  103.             // force model does not depend on attitude, don't bother recomputing it
  104.             dsAttitude = new FieldAttitude<>(factory.getDerivativeField(), state.getAttitude());
  105.         }

  107.         // initialize the list with the state having 0 formce model parameters
  108.         dsStates = new ArrayList<>();
  109.         dsStates.add(new FieldSpacecraftState<>(dsOrbit, dsAttitude, dsM));

  111.     }

  113.     /** Get the number of free state parameters.
  114.      * @return number of free state parameters
  115.      */
  116.     public int getFreeStateParameters() {
  117.         return freeStateParameters;
  118.     }

  120.     /** Get the state with the number of parameters consistent with tropospheric model.
  121.      * @param tropoModel tropospheric model
  122.      * @return state with the number of parameters consistent with tropospheric model
  123.      */
  124.     public FieldSpacecraftState<DerivativeStructure> getState(final DiscreteTroposphericModel tropoModel) {

  126.         // count the required number of parameters
  127.         int nbParams = 0;
  128.         for (final ParameterDriver driver : tropoModel.getParametersDrivers()) {
  129.             if (driver.isSelected()) {
  130.                 ++nbParams;
  131.             }
  132.         }

  134.         // fill in intermediate slots
  135.         while (dsStates.size() < nbParams + 1) {
  136.             dsStates.add(null);
  137.         }

  139.         if (dsStates.get(nbParams) == null) {
  140.             // it is the first time we need this number of parameters
  141.             // we need to create the state
  142.             final DSFactory factory = new DSFactory(freeStateParameters + nbParams, 1);
  143.             final FieldSpacecraftState<DerivativeStructure> s0 = dsStates.get(0);

  145.             // orbit
  146.             final FieldPVCoordinates<DerivativeStructure> pv0 = s0.getPVCoordinates();
  147.             final FieldOrbit<DerivativeStructure> dsOrbit =
  148.                             new FieldCartesianOrbit<>(new TimeStampedFieldPVCoordinates<>(s0.getDate().toAbsoluteDate(),
  149.                                                                                           extend(pv0.getPosition(),     factory),
  150.                                                                                           extend(pv0.getVelocity(),     factory),
  151.                                                                                           extend(pv0.getAcceleration(), factory)),
  152.                                                       s0.getFrame(), extend(s0.getMu(), factory));

  154.             // attitude
  155.             final FieldAngularCoordinates<DerivativeStructure> ac0 = s0.getAttitude().getOrientation();
  156.             final FieldAttitude<DerivativeStructure> dsAttitude =
  157.                             new FieldAttitude<>(s0.getAttitude().getReferenceFrame(),
  158.                                                 new TimeStampedFieldAngularCoordinates<>(dsOrbit.getDate(),
  159.                                                                                          extend(ac0.getRotation(), factory),
  160.                                                                                          extend(ac0.getRotationRate(), factory),
  161.                                                                                          extend(ac0.getRotationAcceleration(), factory)));

  163.             // mass
  164.             final DerivativeStructure dsM = extend(s0.getMass(), factory);

  166.             dsStates.set(nbParams, new FieldSpacecraftState<>(dsOrbit, dsAttitude, dsM));

  168.         }

  170.         return dsStates.get(nbParams);

  172.     }

  174.     /** Add zero derivatives.
  175.      * @param original original scalar
  176.      * @param factory factory for the extended derivatives
  177.      * @return extended scalar
  178.      */
  179.     private DerivativeStructure extend(final DerivativeStructure original, final DSFactory factory) {
  180.         final double[] originalDerivatives = original.getAllDerivatives();
  181.         final double[] extendedDerivatives = new double[factory.getCompiler().getSize()];
  182.         System.arraycopy(originalDerivatives, 0, extendedDerivatives, 0, originalDerivatives.length);
  183.         return factory.build(extendedDerivatives);
  184.     }

  186.     /** Add zero derivatives.
  187.      * @param original original vector
  188.      * @param factory factory for the extended derivatives
  189.      * @return extended vector
  190.      */
  191.     private FieldVector3D<DerivativeStructure> extend(final FieldVector3D<DerivativeStructure> original, final DSFactory factory) {
  192.         return new FieldVector3D<>(extend(original.getX(), factory),
  193.                         extend(original.getY(), factory),
  194.                         extend(original.getZ(), factory));
  195.     }

  197.     /** Add zero derivatives.
  198.      * @param original original rotation
  199.      * @param factory factory for the extended derivatives
  200.      * @return extended rotation
  201.      */
  202.     private FieldRotation<DerivativeStructure> extend(final FieldRotation<DerivativeStructure> original, final DSFactory factory) {
  203.         return new FieldRotation<>(extend(original.getQ0(), factory),
  204.                         extend(original.getQ1(), factory),
  205.                         extend(original.getQ2(), factory),
  206.                         extend(original.getQ3(), factory),
  207.                         false);
  208.     }

  210.     /** Get the tropospheric model parameters.
  211.      * @param state state as returned by {@link #getState(DiscreteTroposphericModel)}
  212.      * @param tropoModel tropospheric model associated with the parameters
  213.      * @return tropospheric model parameters
  214.      */
  215.     public DerivativeStructure[] getParameters(final FieldSpacecraftState<DerivativeStructure> state,
  216.                                                final DiscreteTroposphericModel tropoModel) {
  217.         final DSFactory factory = state.getMass().getFactory();
  218.         final List<ParameterDriver> drivers = tropoModel.getParametersDrivers();
  219.         final DerivativeStructure[] parameters = new DerivativeStructure[drivers.size()];
  220.         int index = freeStateParameters;
  221.         for (int i = 0; i < drivers.size(); ++i) {
  222.             parameters[i] = drivers.get(i).isSelected() ?
  223.                             factory.variable(index++, drivers.get(i).getValue()) :
  224.                             factory.constant(drivers.get(i).getValue());
  225.         }
  226.         return parameters;
  227.     }

  229. }
Created with JaCoCo 0.8.6.202009150832