JacobiansMapper.java

  1. /* Copyright 2002-2019 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.propagation.numerical;

  19. import org.hipparchus.linear.Array2DRowRealMatrix;
  20. import org.hipparchus.linear.DecompositionSolver;
  21. import org.hipparchus.linear.QRDecomposition;
  22. import org.hipparchus.linear.RealMatrix;
  23. import org.orekit.orbits.Orbit;
  24. import org.orekit.orbits.OrbitType;
  25. import org.orekit.orbits.PositionAngle;
  26. import org.orekit.propagation.SpacecraftState;
  27. import org.orekit.utils.ParameterDriversList;

  29. /** Mapper between two-dimensional Jacobian matrices and one-dimensional {@link
  30.  * SpacecraftState#getAdditionalState(String) additional state arrays}.
  31.  * <p>
  32.  * This class does not hold the states by itself. Instances of this class are guaranteed
  33.  * to be immutable.
  34.  * </p>
  35.  * @author Luc Maisonobe
  36.  * @see org.orekit.propagation.numerical.PartialDerivativesEquations
  37.  * @see org.orekit.propagation.numerical.NumericalPropagator
  38.  * @see SpacecraftState#getAdditionalState(String)
  39.  * @see org.orekit.propagation.AbstractPropagator
  40.  */
  41. public class JacobiansMapper {

  43.     /** State dimension, fixed to 6.
  44.      * @since 9.0
  45.      */
  46.     public static final int STATE_DIMENSION = 6;

  48.     /** Name. */
  49.     private String name;

  51.     /** Selected parameters for Jacobian computation. */
  52.     private final ParameterDriversList parameters;

  54.     /** Orbit type. */
  55.     private final OrbitType orbitType;

  57.     /** Position angle type. */
  58.     private final PositionAngle angleType;

  60.     /** Simple constructor.
  61.      * @param name name of the Jacobians
  62.      * @param parameters selected parameters for Jacobian computation
  63.      * @param orbitType orbit type
  64.      * @param angleType position angle type
  65.      */
  66.     JacobiansMapper(final String name, final ParameterDriversList parameters,
  67.                     final OrbitType orbitType, final PositionAngle angleType) {
  68.         this.name       = name;
  69.         this.parameters = parameters;
  70.         this.orbitType  = orbitType;
  71.         this.angleType  = angleType;
  72.     }

  74.     /** Get the name of the partial Jacobians.
  75.      * @return name of the Jacobians
  76.      */
  77.     public String getName() {
  78.         return name;
  79.     }

  81.     /** Compute the length of the one-dimensional additional state array needed.
  82.      * @return length of the one-dimensional additional state array
  83.      */
  84.     public int getAdditionalStateDimension() {
  85.         return STATE_DIMENSION * (STATE_DIMENSION + parameters.getNbParams());
  86.     }

  88.     /** Get the state vector dimension.
  89.      * @return state vector dimension
  90.      * @deprecated as of 9.0, replaced with {@link #STATE_DIMENSION}
  91.      */
  92.     @Deprecated
  93.     public int getStateDimension() {
  94.         return STATE_DIMENSION;
  95.     }

  97.     /** Get the number of parameters.
  98.      * @return number of parameters
  99.      */
  100.     public int getParameters() {
  101.         return parameters.getNbParams();
  102.     }

  104.     /** Get the conversion Jacobian between state parameters and Cartesian parameters.
  105.      * @param state spacecraft state
  106.      * @return conversion Jacobian
  107.      */
  108.     private double[][] getdYdC(final SpacecraftState state) {

  110.         final double[][] dYdC = new double[STATE_DIMENSION][STATE_DIMENSION];

  112.         // make sure the state is in the desired orbit type
  113.         final Orbit orbit = orbitType.convertType(state.getOrbit());

  115.         // compute the Jacobian, taking the position angle type into account
  116.         orbit.getJacobianWrtCartesian(angleType, dYdC);

  118.         return dYdC;

  120.     }

  122.     /** Set the Jacobian with respect to state into a one-dimensional additional state array.
  123.      * <p>
  124.      * This method converts the Jacobians to Cartesian parameters and put the converted data
  125.      * in the one-dimensional {@code p} array.
  126.      * </p>
  127.      * @param state spacecraft state
  128.      * @param dY1dY0 Jacobian of current state at time t₁
  129.      * with respect to state at some previous time t₀
  130.      * @param dY1dP Jacobian of current state at time t₁
  131.      * with respect to parameters (may be null if there are no parameters)
  132.      * @param p placeholder where to put the one-dimensional additional state
  133.      * @see #getStateJacobian(SpacecraftState, double[][])
  134.      */
  135.     void setInitialJacobians(final SpacecraftState state, final double[][] dY1dY0,
  136.                              final double[][] dY1dP, final double[] p) {

  138.         // set up a converter between state parameters and Cartesian parameters
  139.         final RealMatrix dY1dC1 = new Array2DRowRealMatrix(getdYdC(state), false);
  140.         final DecompositionSolver solver = new QRDecomposition(dY1dC1).getSolver();

  142.         // convert the provided state Jacobian to Cartesian parameters
  143.         final RealMatrix dC1dY0 = solver.solve(new Array2DRowRealMatrix(dY1dY0, false));

  145.         // map the converted state Jacobian to one-dimensional array
  146.         int index = 0;
  147.         for (int i = 0; i < STATE_DIMENSION; ++i) {
  148.             for (int j = 0; j < STATE_DIMENSION; ++j) {
  149.                 p[index++] = dC1dY0.getEntry(i, j);
  150.             }
  151.         }

  153.         if (parameters.getNbParams() != 0) {
  154.             // convert the provided state Jacobian to Cartesian parameters
  155.             final RealMatrix dC1dP = solver.solve(new Array2DRowRealMatrix(dY1dP, false));

  157.             // map the converted parameters Jacobian to one-dimensional array
  158.             for (int i = 0; i < STATE_DIMENSION; ++i) {
  159.                 for (int j = 0; j < parameters.getNbParams(); ++j) {
  160.                     p[index++] = dC1dP.getEntry(i, j);
  161.                 }
  162.             }
  163.         }

  165.     }

  167.     /** Get the Jacobian with respect to state from a one-dimensional additional state array.
  168.      * <p>
  169.      * This method extract the data from the {@code state} and put it in the
  170.      * {@code dYdY0} array.
  171.      * </p>
  172.      * @param state spacecraft state
  173.      * @param dYdY0 placeholder where to put the Jacobian with respect to state
  174.           * @see #getParametersJacobian(SpacecraftState, double[][])
  175.      */
  176.     public void getStateJacobian(final SpacecraftState state,  final double[][] dYdY0) {

  178.         // get the conversion Jacobian between state parameters and Cartesian parameters
  179.         final double[][] dYdC = getdYdC(state);

  181.         // extract the additional state
  182.         final double[] p = state.getAdditionalState(name);

  184.         // compute dYdY0 = dYdC * dCdY0, without allocating new arrays
  185.         for (int i = 0; i < STATE_DIMENSION; i++) {
  186.             final double[] rowC = dYdC[i];
  187.             final double[] rowD = dYdY0[i];
  188.             for (int j = 0; j < STATE_DIMENSION; ++j) {
  189.                 double sum = 0;
  190.                 int pIndex = j;
  191.                 for (int k = 0; k < STATE_DIMENSION; ++k) {
  192.                     sum += rowC[k] * p[pIndex];
  193.                     pIndex += STATE_DIMENSION;
  194.                 }
  195.                 rowD[j] = sum;
  196.             }
  197.         }

  199.     }

  201.     /** Get theJacobian with respect to parameters from a one-dimensional additional state array.
  202.      * <p>
  203.      * This method extract the data from the {@code state} and put it in the
  204.      * {@code dYdP} array.
  205.      * </p>
  206.      * <p>
  207.      * If no parameters have been set in the constructor, the method returns immediately and
  208.      * does not reference {@code dYdP} which can safely be null in this case.
  209.      * </p>
  210.      * @param state spacecraft state
  211.      * @param dYdP placeholder where to put the Jacobian with respect to parameters
  212.           * @see #getStateJacobian(SpacecraftState, double[][])
  213.      */
  214.     public void getParametersJacobian(final SpacecraftState state, final double[][] dYdP) {

  216.         if (parameters.getNbParams() != 0) {

  218.             // get the conversion Jacobian between state parameters and Cartesian parameters
  219.             final double[][] dYdC = getdYdC(state);

  221.             // extract the additional state
  222.             final double[] p = state.getAdditionalState(name);

  224.             // compute dYdP = dYdC * dCdP, without allocating new arrays
  225.             for (int i = 0; i < STATE_DIMENSION; i++) {
  226.                 final double[] rowC = dYdC[i];
  227.                 final double[] rowD = dYdP[i];
  228.                 for (int j = 0; j < parameters.getNbParams(); ++j) {
  229.                     double sum = 0;
  230.                     int pIndex = j + STATE_DIMENSION * STATE_DIMENSION;
  231.                     for (int k = 0; k < STATE_DIMENSION; ++k) {
  232.                         sum += rowC[k] * p[pIndex];
  233.                         pIndex += parameters.getNbParams();
  234.                     }
  235.                     rowD[j] = sum;
  236.                 }
  237.             }

  239.         }

  241.     }

  243. }
Created with JaCoCo 0.8.2.201808211720