JacobiansMapper.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.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.errors.OrekitException;
  24. import org.orekit.orbits.Orbit;
  25. import org.orekit.orbits.OrbitType;
  26. import org.orekit.orbits.PositionAngle;
  27. import org.orekit.propagation.SpacecraftState;
  28. import org.orekit.utils.ParameterDriversList;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  119.         return dYdC;

  121.     }

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

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

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

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

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

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

  166.     }

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

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

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

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

  202.     }

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

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

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

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

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

  244.         }

  246.     }

  248. }
Created with JaCoCo 0.7.9.201702052155