TroposphericGradientConverter.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.Field;
  23. import org.hipparchus.analysis.differentiation.Gradient;
  24. import org.hipparchus.analysis.differentiation.GradientField;
  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.propagation.integration.AbstractGradientConverter;
  35. import org.orekit.utils.FieldAngularCoordinates;
  36. import org.orekit.utils.FieldPVCoordinates;
  37. import org.orekit.utils.ParameterDriver;
  38. import org.orekit.utils.TimeStampedFieldAngularCoordinates;
  39. import org.orekit.utils.TimeStampedFieldPVCoordinates;

  41. /**
  42.  * Converter for states and parameters arrays.
  43.  * @author Bryan Cazabonne
  44.  * @since 10.2
  45.  */
  46. public class TroposphericGradientConverter extends AbstractGradientConverter {

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

  51.     /** States with various number of additional parameters for tropospheric models. */
  52.     private final List<FieldSpacecraftState<Gradient>> gStates;

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

  62.         super(freeStateParameters);
  63.         this.freeStateParameters = freeStateParameters;

  65.         // Derivative field
  66.         final Field<Gradient> field =  GradientField.getField(freeStateParameters);

  68.         // position always has derivatives
  69.         final Vector3D pos = state.getPVCoordinates().getPosition();
  70.         final FieldVector3D<Gradient> posG = new FieldVector3D<>(Gradient.variable(freeStateParameters, 0, pos.getX()),
  71.                                                                  Gradient.variable(freeStateParameters, 1, pos.getY()),
  72.                                                                  Gradient.variable(freeStateParameters, 2, pos.getZ()));

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

  87.         // acceleration never has derivatives
  88.         final Vector3D acc = state.getPVCoordinates().getAcceleration();
  89.         final FieldVector3D<Gradient> accG = new FieldVector3D<>(Gradient.constant(freeStateParameters, acc.getX()),
  90.                                                                  Gradient.constant(freeStateParameters, acc.getY()),
  91.                                                                  Gradient.constant(freeStateParameters, acc.getZ()));

  93.         // mass never has derivatives
  94.         final Gradient dsM = Gradient.constant(freeStateParameters, state.getMass());

  96.         final FieldOrbit<Gradient> gOrbit =
  97.                         new FieldCartesianOrbit<>(new TimeStampedFieldPVCoordinates<>(state.getDate(), posG, velG, accG),
  98.                                                   state.getFrame(),
  99.                                                   field.getZero().add(state.getMu()));

  101.         final FieldAttitude<Gradient> gAttitude;
  102.         if (freeStateParameters > 3) {
  103.             // compute attitude partial derivatives with respect to position/velocity
  104.             gAttitude = provider.getAttitude(gOrbit, gOrbit.getDate(), gOrbit.getFrame());
  105.         } else {
  106.             // force model does not depend on attitude, don't bother recomputing it
  107.             gAttitude = new FieldAttitude<>(field, state.getAttitude());
  108.         }

  110.         // initialize the list with the state having 0 force model parameters
  111.         gStates = new ArrayList<>();
  112.         gStates.add(new FieldSpacecraftState<>(gOrbit, gAttitude, dsM));

  114.     }

  116.     /**
  117.      * Get the number of free state parameters.
  118.      * @return number of free state parameters
  119.      */
  120.     public int getFreeStateParameters() {
  121.         return freeStateParameters;
  122.     }

  124.     /**
  125.      * Get the state with the number of parameters consistent with tropospheric model.
  126.      * @param tropoModel tropospheric model
  127.      * @return state with the number of parameters consistent with tropospheric model
  128.      */
  129.     public FieldSpacecraftState<Gradient> getState(final DiscreteTroposphericModel tropoModel) {

  131.         // count the required number of parameters
  132.         int nbParams = 0;
  133.         for (final ParameterDriver driver : tropoModel.getParametersDrivers()) {
  134.             if (driver.isSelected()) {
  135.                 ++nbParams;
  136.             }
  137.         }

  139.         // fill in intermediate slots
  140.         while (gStates.size() < nbParams + 1) {
  141.             gStates.add(null);
  142.         }

  144.         if (gStates.get(nbParams) == null) {
  145.             // it is the first time we need this number of parameters
  146.             // we need to create the state
  147.             final int freeParameters = freeStateParameters + nbParams;
  148.             final FieldSpacecraftState<Gradient> s0 = gStates.get(0);

  150.             // orbit
  151.             final FieldPVCoordinates<Gradient> pv0 = s0.getPVCoordinates();
  152.             final FieldOrbit<Gradient> gOrbit =
  153.                             new FieldCartesianOrbit<>(new TimeStampedFieldPVCoordinates<>(s0.getDate().toAbsoluteDate(),
  154.                                                                                           extend(pv0.getPosition(),     freeParameters),
  155.                                                                                           extend(pv0.getVelocity(),     freeParameters),
  156.                                                                                           extend(pv0.getAcceleration(), freeParameters)),
  157.                                                       s0.getFrame(), extend(s0.getMu(), freeParameters));

  159.             // attitude
  160.             final FieldAngularCoordinates<Gradient> ac0 = s0.getAttitude().getOrientation();
  161.             final FieldAttitude<Gradient> gAttitude =
  162.                             new FieldAttitude<>(s0.getAttitude().getReferenceFrame(),
  163.                                                 new TimeStampedFieldAngularCoordinates<>(gOrbit.getDate(),
  164.                                                                                          extend(ac0.getRotation(), freeParameters),
  165.                                                                                          extend(ac0.getRotationRate(), freeParameters),
  166.                                                                                          extend(ac0.getRotationAcceleration(), freeParameters)));

  168.             // mass
  169.             final Gradient gM = extend(s0.getMass(), freeParameters);

  171.             gStates.set(nbParams, new FieldSpacecraftState<>(gOrbit, gAttitude, gM));

  173.         }

  175.         return gStates.get(nbParams);

  177.     }

  179.     /**
  180.      * Get the tropospheric model parameters.
  181.      * @param state state as returned by {@link #getState(DiscreteTroposphericModel)}
  182.      * @param tropoModel tropospheric model associated with the parameters
  183.      * @return tropospheric model parameters
  184.      */
  185.     public Gradient[] getParameters(final FieldSpacecraftState<Gradient> state,
  186.                                     final DiscreteTroposphericModel tropoModel) {
  187.         final int freeParameters = state.getMass().getFreeParameters();
  188.         final List<ParameterDriver> drivers = tropoModel.getParametersDrivers();
  189.         final Gradient[] parameters = new Gradient[drivers.size()];
  190.         int index = freeStateParameters;
  191.         for (int i = 0; i < drivers.size(); ++i) {
  192.             parameters[i] = drivers.get(i).isSelected() ?
  193.                             Gradient.variable(freeParameters, index++, drivers.get(i).getValue()) :
  194.                             Gradient.constant(freeParameters, drivers.get(i).getValue());
  195.         }
  196.         return parameters;
  197.     }

  199. }
Created with JaCoCo 0.8.6.202009150832