Commit 3be3ea64 authored by Luc Maisonobe's avatar Luc Maisonobe
Browse files

Forced states derivatives to be dimension 6 rather than either 6 or 7.

The additional mass was not really useful, it was intended for maneuvers
calibration, but in fact during maneuver calibration we adjust either
flow rate or specific impulse but not directly mass itself. 
parent 2eb798ca
......@@ -137,7 +137,7 @@ public enum OrekitMessages implements Localizable {
UNKNOWN_MONTH("unknown month \"{0}\""),
SINGULAR_JACOBIAN_FOR_ORBIT_TYPE("Jacobian matrix for type {0} is singular with current orbit"),
STATE_JACOBIAN_NOT_INITIALIZED("state Jacobian has not been initialized yet"),
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7("state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix"),
STATE_JACOBIAN_NOT_6X6("state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix"),
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH("state Jacobian has {0} rows but parameters Jacobian has {1} rows"),
INITIAL_MATRIX_AND_PARAMETERS_NUMBER_MISMATCH("initial Jacobian matrix has {0} columns, but {1} parameters have been selected"),
ORBIT_A_E_MISMATCH_WITH_CONIC_TYPE("orbit should be either elliptic with a > 0 and e < 1 or hyperbolic with a < 0 and e > 1, a = {0}, e = {1}"),
......
......@@ -300,7 +300,7 @@ class Model implements MultivariateJacobianFunction {
// add the derivatives to the initial state
final SpacecraftState rawState = propagator.getInitialState();
final SpacecraftState stateWithDerivatives = partials.setInitialJacobians(rawState, 6);
final SpacecraftState stateWithDerivatives = partials.setInitialJacobians(rawState);
propagator.resetInitialState(stateWithDerivatives);
return partials.getMapper();
......
......@@ -132,7 +132,7 @@ public class JacobianPropagatorConverter extends AbstractPropagatorConverter {
final ParameterDriversList orbitalParameters = builder.getOrbitalParametersDrivers();
final PartialDerivativesEquations pde = new PartialDerivativesEquations("pde", prop);
final ParameterDriversList propagationParameters = pde.getSelectedParameters();
prop.setInitialState(pde.setInitialJacobians(prop.getInitialState(), stateSize));
prop.setInitialState(pde.setInitialJacobians(prop.getInitialState()));
final JacobiansMapper mapper = pde.getMapper();
final List<SpacecraftState> sample = getSample();
......@@ -219,8 +219,8 @@ public class JacobianPropagatorConverter extends AbstractPropagatorConverter {
}
// Jacobian part
final double[][] dYdY0 = new double[mapper.getStateDimension()][mapper.getStateDimension()];
final double[][] dYdP = new double[mapper.getStateDimension()][mapper.getParameters()];
final double[][] dYdY0 = new double[JacobiansMapper.STATE_DIMENSION][JacobiansMapper.STATE_DIMENSION];
final double[][] dYdP = new double[JacobiansMapper.STATE_DIMENSION][mapper.getParameters()];
mapper.getStateJacobian(state, dYdY0);
mapper.getParametersJacobian(state, dYdP);
for (int k = 0; k < stateSize; k++) {
......
......@@ -41,13 +41,14 @@ import org.orekit.utils.ParameterDriversList;
*/
public class JacobiansMapper {
/** State dimension, fixed to 6.
* @since 9.0
*/
public static final int STATE_DIMENSION = 6;
/** Name. */
private String name;
/** State vector dimension without additional parameters
* (either 6 or 7 depending on mass being included or not). */
private final int stateDimension;
/** Selected parameters for Jacobian computation. */
private final ParameterDriversList parameters;
......@@ -59,19 +60,16 @@ public class JacobiansMapper {
/** Simple constructor.
* @param name name of the Jacobians
* @param stateDimension dimension of the state (either 6 or 7 depending on mass
* being included or not)
* @param parameters selected parameters for Jacobian computation
* @param orbitType orbit type
* @param angleType position angle type
*/
JacobiansMapper(final String name, final int stateDimension, final ParameterDriversList parameters,
JacobiansMapper(final String name, final ParameterDriversList parameters,
final OrbitType orbitType, final PositionAngle angleType) {
this.name = name;
this.stateDimension = stateDimension;
this.parameters = parameters;
this.orbitType = orbitType;
this.angleType = angleType;
this.name = name;
this.parameters = parameters;
this.orbitType = orbitType;
this.angleType = angleType;
}
/** Get the name of the partial Jacobians.
......@@ -85,14 +83,16 @@ public class JacobiansMapper {
* @return length of the one-dimensional additional state array
*/
public int getAdditionalStateDimension() {
return stateDimension * (stateDimension + parameters.getNbParams());
return STATE_DIMENSION * (STATE_DIMENSION + parameters.getNbParams());
}
/** Get the state vector dimension.
* @return state vector dimension
* @deprecated as of 9.0, replaced with {@link #STATE_DIMENSION}
*/
@Deprecated
public int getStateDimension() {
return stateDimension;
return STATE_DIMENSION;
}
/** Get the number of parameters.
......@@ -108,17 +108,13 @@ public class JacobiansMapper {
*/
private double[][] getdYdC(final SpacecraftState state) {
final double[][] dYdC = new double[stateDimension][stateDimension];
final double[][] dYdC = new double[STATE_DIMENSION][STATE_DIMENSION];
// make sure the state is in the desired orbit type
final Orbit orbit = orbitType.convertType(state.getOrbit());
// compute the Jacobian, taking the position angle type into account
orbit.getJacobianWrtCartesian(angleType, dYdC);
if (stateDimension > 6) {
// add mass derivative
dYdC[6][6] = 1.0;
}
return dYdC;
......@@ -149,8 +145,8 @@ public class JacobiansMapper {
// map the converted state Jacobian to one-dimensional array
int index = 0;
for (int i = 0; i < stateDimension; ++i) {
for (int j = 0; j < stateDimension; ++j) {
for (int i = 0; i < STATE_DIMENSION; ++i) {
for (int j = 0; j < STATE_DIMENSION; ++j) {
p[index++] = dC1dY0.getEntry(i, j);
}
}
......@@ -160,7 +156,7 @@ public class JacobiansMapper {
final RealMatrix dC1dP = solver.solve(new Array2DRowRealMatrix(dY1dP, false));
// map the converted parameters Jacobian to one-dimensional array
for (int i = 0; i < stateDimension; ++i) {
for (int i = 0; i < STATE_DIMENSION; ++i) {
for (int j = 0; j < parameters.getNbParams(); ++j) {
p[index++] = dC1dP.getEntry(i, j);
}
......@@ -189,15 +185,15 @@ public class JacobiansMapper {
final double[] p = state.getAdditionalState(name);
// compute dYdY0 = dYdC * dCdY0, without allocating new arrays
for (int i = 0; i < stateDimension; i++) {
for (int i = 0; i < STATE_DIMENSION; i++) {
final double[] rowC = dYdC[i];
final double[] rowD = dYdY0[i];
for (int j = 0; j < stateDimension; ++j) {
for (int j = 0; j < STATE_DIMENSION; ++j) {
double sum = 0;
int pIndex = j;
for (int k = 0; k < stateDimension; ++k) {
for (int k = 0; k < STATE_DIMENSION; ++k) {
sum += rowC[k] * p[pIndex];
pIndex += stateDimension;
pIndex += STATE_DIMENSION;
}
rowD[j] = sum;
}
......@@ -231,13 +227,13 @@ public class JacobiansMapper {
final double[] p = state.getAdditionalState(name);
// compute dYdP = dYdC * dCdP, without allocating new arrays
for (int i = 0; i < stateDimension; i++) {
for (int i = 0; i < STATE_DIMENSION; i++) {
final double[] rowC = dYdC[i];
final double[] rowD = dYdP[i];
for (int j = 0; j < parameters.getNbParams(); ++j) {
double sum = 0;
int pIndex = j + stateDimension * stateDimension;
for (int k = 0; k < stateDimension; ++k) {
int pIndex = j + STATE_DIMENSION * STATE_DIMENSION;
for (int k = 0; k < STATE_DIMENSION; ++k) {
sum += rowC[k] * p[pIndex];
pIndex += parameters.getNbParams();
}
......
......@@ -16,7 +16,6 @@
*/
package org.orekit.propagation.numerical;
import java.util.Arrays;
import java.util.IdentityHashMap;
import java.util.Map;
......@@ -76,9 +75,8 @@ public class PartialDerivativesEquations implements AdditionalEquations {
/** Name. */
private final String name;
/** State vector dimension without additional parameters
* (either 6 or 7 depending on mass derivatives being included or not). */
private int stateDim;
/** Flag for Jacobian matrices initialization. */
private boolean initialized;
/** Simple constructor.
* <p>
......@@ -97,7 +95,7 @@ public class PartialDerivativesEquations implements AdditionalEquations {
this.selected = null;
this.map = null;
this.propagator = propagator;
this.stateDim = -1;
this.initialized = false;
propagator.addAdditionalEquations(this);
}
......@@ -165,6 +163,36 @@ public class PartialDerivativesEquations implements AdditionalEquations {
return selected;
}
/** Set the initial value of the Jacobian with respect to state and parameter.
* <p>
* This method is equivalent to call {@link #setInitialJacobians(SpacecraftState,
* double[][], double[][])} with dYdY0 set to the identity matrix and dYdP set
* to a zero matrix.
* </p>
* <p>
* The force models parameters for which partial derivatives are desired,
* <em>must</em> have been {@link ParameterDriver#setSelected(boolean) selected}
* before this method is called, so proper matrices dimensions are used.
* </p>
* @param s0 initial state
* @return state with initial Jacobians added
* @exception OrekitException if the partial equation has not been registered in
* the propagator or if matrices dimensions are incorrect
* @see #getSelectedParameters()
* @since 9.0
*/
public SpacecraftState setInitialJacobians(final SpacecraftState s0)
throws OrekitException {
freezeParametersSelection();
final int stateDimension = 6;
final double[][] dYdY0 = new double[stateDimension][stateDimension];
final double[][] dYdP = new double[stateDimension][selected.getNbParams()];
for (int i = 0; i < stateDimension; ++i) {
dYdY0[i][i] = 1.0;
}
return setInitialJacobians(s0, dYdY0, dYdP);
}
/** Set the initial value of the Jacobian with respect to state and parameter.
* <p>
* This method is equivalent to call {@link #setInitialJacobians(SpacecraftState,
......@@ -182,7 +210,9 @@ public class PartialDerivativesEquations implements AdditionalEquations {
* @exception OrekitException if the partial equation has not been registered in
* the propagator or if matrices dimensions are incorrect
* @see #getSelectedParameters()
* @deprecated as of 9.0, replaced by {@link #setInitialJacobians(SpacecraftState)}
*/
@Deprecated
public SpacecraftState setInitialJacobians(final SpacecraftState s0, final int stateDimension)
throws OrekitException {
freezeParametersSelection();
......@@ -207,8 +237,7 @@ public class PartialDerivativesEquations implements AdditionalEquations {
* </p>
* @param s1 current state
* @param dY1dY0 Jacobian of current state at time t₁ with respect
* to state at some previous time t₀ (may be either 6x6 for orbit
* only or 7x7 for orbit and mass)
* to state at some previous time t₀ (must be 6x6)
* @param dY1dP Jacobian of current state at time t₁ with respect
* to parameters (may be null if no parameters are selected)
* @return state with initial Jacobians added
......@@ -223,9 +252,9 @@ public class PartialDerivativesEquations implements AdditionalEquations {
freezeParametersSelection();
// Check dimensions
stateDim = dY1dY0.length;
if (stateDim < 6 || stateDim > 7 || stateDim != dY1dY0[0].length) {
throw new OrekitException(OrekitMessages.STATE_JACOBIAN_NEITHER_6X6_NOR_7X7,
final int stateDim = dY1dY0.length;
if (stateDim != 6 || stateDim != dY1dY0[0].length) {
throw new OrekitException(OrekitMessages.STATE_JACOBIAN_NOT_6X6,
stateDim, dY1dY0[0].length);
}
if (dY1dP != null && stateDim != dY1dP.length) {
......@@ -239,6 +268,7 @@ public class PartialDerivativesEquations implements AdditionalEquations {
}
// store the matrices as a single dimension array
initialized = true;
final JacobiansMapper mapper = getMapper();
final double[] p = new double[mapper.getAdditionalStateDimension()];
mapper.setInitialJacobians(s1, dY1dY0, dY1dP, p);
......@@ -256,10 +286,10 @@ public class PartialDerivativesEquations implements AdditionalEquations {
* @see #setInitialJacobians(SpacecraftState, double[][], double[][])
*/
public JacobiansMapper getMapper() throws OrekitException {
if (stateDim < 0) {
if (!initialized) {
throw new OrekitException(OrekitMessages.STATE_JACOBIAN_NOT_INITIALIZED);
}
return new JacobiansMapper(name, stateDim, selected,
return new JacobiansMapper(name, selected,
propagator.getOrbitType(),
propagator.getPositionAngleType());
}
......@@ -274,10 +304,9 @@ public class PartialDerivativesEquations implements AdditionalEquations {
final double[][] dAccdParam = new double[dim][paramDim];
final double[][] dAccdPos = new double[dim][dim];
final double[][] dAccdVel = new double[dim][dim];
final double[] dAccdM = (stateDim > 6) ? new double[dim] : null;
final DSConverter fullConverter = new DSConverter(s, stateDim, propagator.getAttitudeProvider());
final DSConverter posOnlyConverter = new DSConverter(s, 3, propagator.getAttitudeProvider());
final DSConverter fullConverter = new DSConverter(s, 6, propagator.getAttitudeProvider());
final DSConverter posOnlyConverter = new DSConverter(s, 3, propagator.getAttitudeProvider());
// compute acceleration Jacobians, finishing with the largest force: Newtonian attraction
for (final ForceModel forceModel : propagator.getAllForceModels()) {
......@@ -292,9 +321,9 @@ public class PartialDerivativesEquations implements AdditionalEquations {
final double[] derivativesZ = acceleration.getZ().getAllDerivatives();
// update Jacobians with respect to state
addToRow(derivativesX, 0, converter.getFreeStateParameters(), dAccdPos, dAccdVel, dAccdM);
addToRow(derivativesY, 1, converter.getFreeStateParameters(), dAccdPos, dAccdVel, dAccdM);
addToRow(derivativesZ, 2, converter.getFreeStateParameters(), dAccdPos, dAccdVel, dAccdM);
addToRow(derivativesX, 0, converter.getFreeStateParameters(), dAccdPos, dAccdVel);
addToRow(derivativesY, 1, converter.getFreeStateParameters(), dAccdPos, dAccdVel);
addToRow(derivativesZ, 2, converter.getFreeStateParameters(), dAccdPos, dAccdVel);
int index = converter.getFreeStateParameters();
for (ParameterDriver driver : forceModel.getParametersDrivers()) {
......@@ -309,111 +338,83 @@ public class PartialDerivativesEquations implements AdditionalEquations {
}
// the variational equations of the complete state Jacobian matrix have the
// following form for 7x7, i.e. when mass partial derivatives are also considered
// (when mass is not considered, only the A, B, D and E matrices are used along
// with their derivatives):
// [ | | ] [ | | ] [ | | ]
// [ Adot | Bdot | Cdot ] [ dVel/dPos = 0 | dVel/dVel = Id | dVel/dm = 0 ] [ A | B | C ]
// [ | | ] [ | | ] [ | | ]
// --------+--------+--- ---- ------------------+------------------+---------------- -----+-----+-----
// [ | | ] [ | | ] [ | | ]
// [ Ddot | Edot | Fdot ] = [ dAcc/dPos | dAcc/dVel | dAcc/dm ] * [ D | E | F ]
// [ | | ] [ | | ] [ | | ]
// --------+--------+--- ---- ------------------+------------------+---------------- -----+-----+-----
// [ Gdot | Hdot | Idot ] [ dmDot/dPos = 0 | dmDot/dVel = 0 | dmDot/dm = 0 ] [ G | H | I ]
// The A, B, D and E sub-matrices and their derivatives (Adot ...) are 3x3 matrices,
// the C and F sub-matrices and their derivatives (Cdot ...) are 3x1 matrices,
// the G and H sub-matrices and their derivatives (Gdot ...) are 1x3 matrices,
// the I sub-matrix and its derivative (Idot) is a 1x1 matrix.
// the variational equations of the complete state Jacobian matrix have the following form:
// [ | ] [ | ] [ | ]
// [ Adot | Bdot ] [ dVel/dPos = 0 | dVel/dVel = Id ] [ A | B ]
// [ | ] [ | ] [ | ]
// ---------+--------- ------------------+------------------- * ------+------
// [ | ] [ | ] [ | ]
// [ Cdot | Ddot ] = [ dAcc/dPos | dAcc/dVel ] [ C | D ]
// [ | ] [ | ] [ | ]
// The A, B, C and D sub-matrices and their derivatives (Adot ...) are 3x3 matrices
// The expanded multiplication above can be rewritten to take into account
// the fixed values found in the sub-matrices in the left factor. This leads to:
// [ Adot ] = [ D ]
// [ Bdot ] = [ E ]
// [ Cdot ] = [ F ]
// [ Ddot ] = [ dAcc/dPos ] * [ A ] + [ dAcc/dVel ] * [ D ] + [ dAcc/dm ] * [ G ]
// [ Edot ] = [ dAcc/dPos ] * [ B ] + [ dAcc/dVel ] * [ E ] + [ dAcc/dm ] * [ H ]
// [ Fdot ] = [ dAcc/dPos ] * [ C ] + [ dAcc/dVel ] * [ F ] + [ dAcc/dm ] * [ I ]
// [ Gdot ] = [ 0 ]
// [ Hdot ] = [ 0 ]
// [ Idot ] = [ 0 ]
// [ Adot ] = [ C ]
// [ Bdot ] = [ D ]
// [ Cdot ] = [ dAcc/dPos ] * [ A ] + [ dAcc/dVel ] * [ C ]
// [ Ddot ] = [ dAcc/dPos ] * [ B ] + [ dAcc/dVel ] * [ D ]
// The following loops compute these expressions taking care of the mapping of the
// (A, B, ... I) matrices into the single dimension array p and of the mapping of the
// (Adot, Bdot, ... Idot) matrices into the single dimension array pDot.
// (A, B, C, D) matrices into the single dimension array p and of the mapping of the
// (Adot, Bdot, Cdot, Ddot) matrices into the single dimension array pDot.
// copy D, E and F into Adot, Bdot and Cdot
// copy C and E into Adot and Bdot
final int stateDim = 6;
final double[] p = s.getAdditionalState(getName());
System.arraycopy(p, dim * stateDim, pDot, 0, dim * stateDim);
// compute Ddot, Edot and Fdot
// compute Cdot and Ddot
for (int i = 0; i < dim; ++i) {
final double[] dAdPi = dAccdPos[i];
final double[] dAdVi = dAccdVel[i];
for (int j = 0; j < stateDim; ++j) {
pDot[(dim + i) * stateDim + j] =
dAdPi[0] * p[j] + dAdPi[1] * p[j + stateDim] + dAdPi[2] * p[j + 2 * stateDim] +
dAdVi[0] * p[j + 3 * stateDim] + dAdVi[1] * p[j + 4 * stateDim] + dAdVi[2] * p[j + 5 * stateDim] +
((dAccdM == null) ? 0.0 : dAccdM[i] * p[j + 6 * stateDim]);
dAdVi[0] * p[j + 3 * stateDim] + dAdVi[1] * p[j + 4 * stateDim] + dAdVi[2] * p[j + 5 * stateDim];
}
}
if (dAccdM != null) {
// set Gdot, Hdot and Idot to 0
Arrays.fill(pDot, 6 * stateDim, 7 * stateDim, 0.0);
}
for (int k = 0; k < paramDim; ++k) {
// the variational equations of the parameters Jacobian matrix are computed
// one column at a time, they have the following form:
// [ ] [ | | ] [ ] [ ]
// [ Jdot ] [ dVel/dPos = 0 | dVel/dVel = Id | dVel/dm = 0 ] [ J ] [ dVel/dParam = 0 ]
// [ ] [ | | ] [ ] [ ]
// -------- ------------------+------------------+---------------- ----- --------------------
// [ ] [ | | ] [ ] [ ]
// [ Kdot ] = [ dAcc/dPos | dAcc/dVel | dAcc/dm ] * [ K ] + [ dAcc/dParam ]
// [ ] [ | | ] [ ] [ ]
// -------- ------------------+------------------+---------------- ----- --------------------
// [ Ldot ] [ dmDot/dPos = 0 | dmDot/dVel = 0 | dmDot/dm = 0 ] [ L ] [ dmDot/dParam = 0 ]
// The J and K sub-columns and their derivatives (Jdot ...) are 3 elements columns,
// the L sub-colums and its derivative (Ldot) are 1 elements columns.
// [ ] [ | ] [ ] [ ]
// [ Edot ] [ dVel/dPos = 0 | dVel/dVel = Id ] [ E ] [ dVel/dParam = 0 ]
// [ ] [ | ] [ ] [ ]
// -------- ------------------+------------------- * ----- + --------------------
// [ ] [ | ] [ ] [ ]
// [ Fdot ] = [ dAcc/dPos | dAcc/dVel ] [ F ] [ dAcc/dParam ]
// [ ] [ | ] [ ] [ ]
// The E and F sub-columns and their derivatives (Edot, Fdot) are 3 elements columns.
// The expanded multiplication and addition above can be rewritten to take into
// account the fixed values found in the sub-matrices in the left factor. This leads to:
// [ Jdot ] = [ K ]
// [ Kdot ] = [ dAcc/dPos ] * [ J ] + [ dAcc/dVel ] * [ K ] + [ dAcc/dm ] * [ L ] + [ dAcc/dParam ]
// [ Ldot ] = [ 0 ]
// [ Edot ] = [ F ]
// [ Fdot ] = [ dAcc/dPos ] * [ E ] + [ dAcc/dVel ] * [ F ] + [ dAcc/dParam ]
// The following loops compute these expressions taking care of the mapping of the
// (J, K, L) columns into the single dimension array p and of the mapping of the
// (Jdot, Kdot, Ldot) columns into the single dimension array pDot.
// (E, F) columns into the single dimension array p and of the mapping of the
// (Edot, Fdot) columns into the single dimension array pDot.
// copy K into Jdot
// copy F into Edot
final int columnTop = stateDim * stateDim + k;
pDot[columnTop] = p[columnTop + 3 * paramDim];
pDot[columnTop + paramDim] = p[columnTop + 4 * paramDim];
pDot[columnTop + 2 * paramDim] = p[columnTop + 5 * paramDim];
// compute Kdot
// compute Fdot
for (int i = 0; i < dim; ++i) {
final double[] dAdPi = dAccdPos[i];
final double[] dAdVi = dAccdVel[i];
pDot[columnTop + (dim + i) * paramDim] =
dAccdParam[i][k] +
dAdPi[0] * p[columnTop] + dAdPi[1] * p[columnTop + paramDim] + dAdPi[2] * p[columnTop + 2 * paramDim] +
dAdVi[0] * p[columnTop + 3 * paramDim] + dAdVi[1] * p[columnTop + 4 * paramDim] + dAdVi[2] * p[columnTop + 5 * paramDim] +
((dAccdM == null) ? 0.0 : dAccdM[i] * p[columnTop + 6 * paramDim]);
}
if (dAccdM != null) {
// set Ldot to 0
pDot[columnTop + 6 * paramDim] = 0;
dAdVi[0] * p[columnTop + 3 * paramDim] + dAdVi[1] * p[columnTop + 4 * paramDim] + dAdVi[2] * p[columnTop + 5 * paramDim];
}
}
......@@ -430,10 +431,9 @@ public class PartialDerivativesEquations implements AdditionalEquations {
* 6 (position-velocity) or 7 (position-velocity-mass)
* @param dAccdPos Jacobian of acceleration with respect to spacecraft position
* @param dAccdVel Jacobian of acceleration with respect to spacecraft velocity
* @param dAccdM Jacobian of acceleration with respect to spacecraft mass
*/
private void addToRow(final double[] derivatives, final int index, final int freeStateParameters,
final double[][] dAccdPos, final double[][] dAccdVel, final double[] dAccdM) {
final double[][] dAccdPos, final double[][] dAccdVel) {
for (int i = 0; i < 3; ++i) {
dAccdPos[index][i] += derivatives[i + 1];
......@@ -442,9 +442,6 @@ public class PartialDerivativesEquations implements AdditionalEquations {
for (int i = 0; i < 3; ++i) {
dAccdVel[index][i] += derivatives[i + 4];
}
if (freeStateParameters > 6) {
dAccdM[index] += derivatives[7];
}
}
}
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = Jacobian-matricen associeret med type {0} er
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = Jacobian-tilstanden er endnu ikke blevet initialiseret
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = Jacobian-tilstanden er en {0}x{1} matrice, den skal enten være en 6x6 eller en 7x7 matrice
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
STATE_JACOBIAN_NOT_6X6 = Jacobian-tilstanden er en {0}x{1} matrice, den skal enten være en 6x6 matrice
# state Jacobian has {0} rows but parameters Jacobian has {1} rows
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH = Jacobian-tilstanden har {0} rækker men Jacobian parametrene har {1} rækker
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = Jacobi Matrix des Typs {0} ist singulär für
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = Jacobi Zustandsmatrix wurde noch nicht initialisiert
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = Jacobi Zustandsmatrix ist eine {0}x{1} Matrix, sollte aber entweder eine 6x6 oder 7x7 Matrix sein
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
STATE_JACOBIAN_NOT_6X6 = Jacobi Zustandsmatrix ist eine {0}x{1} Matrix, sollte aber entweder eine 6x6 Matrix sein
# state Jacobian has {0} rows but parameters Jacobian has {1} rows
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH = Jacobi Zustandsmatrix hat {0} Zeilen, aber Jacobi Parametermatrix hat {1} Zeilen
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = Ο πίνακας Jacobian για τον τύ
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = Η Jacobian κατάσταση δεν έχει ακόμη αρχικοποιηθεί
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = Η κατάσταση είναι ένας {0}x{1} πίνακας, θα πρέπει να είναι είτε ένας 6x6 είτε ένας 7x7 πίνακας
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
STATE_JACOBIAN_NOT_6X6 = Η κατάσταση είναι ένας {0}x{1} πίνακας, θα πρέπει να είναι είτε ένας 6x6 πίνακας
# state Jacobian has {0} rows but parameters Jacobian has {1} rows
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH = Η Jacobian κατάσταση έχει {0} γραμμές, αλλά οι Jacobian παράμετροι έχουν {1} γραμμές
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = Jacobian matrix for type {0} is singular with
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = state Jacobian has not been initialized yet
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
STATE_JACOBIAN_NOT_6X6 = state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
# state Jacobian has {0} rows but parameters Jacobian has {1} rows
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH = state Jacobian has {0} rows but parameters Jacobian has {1} rows
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = la matriz jacobiana asociada al tipo {0} es s
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = la matriz jacobiana del estado no ha sido todavía inicializada
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = la matriz jacobiana del estado es una matriz {0}x{1}, y debería ser una matriz 6x6 o 7x7
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
STATE_JACOBIAN_NOT_6X6 = la matriz jacobiana del estado es una matriz {0}x{1}, y debería ser una matriz 6x6
# state Jacobian has {0} rows but parameters Jacobian has {1} rows
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH = la matriz jacobiana del estado tiene {0} líneas mientras que la matriz jacobiana de parámetros tiene {1}
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = la matrice jacobienne associée au type {0} e
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = la jacobienne de l''état n''a pas encore été initialisée
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = la jacobienne de l''état est une matrice {0}x{1}, alors qu''elle devrait être soit une matrice 6x6 soit une matrice 7x7
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix
STATE_JACOBIAN_NOT_6X6 = la jacobienne de l''état est une matrice {0}x{1}, alors qu''elle devrait être une matrice 6x6
# state Jacobian has {0} rows but parameters Jacobian has {1} rows
STATE_AND_PARAMETERS_JACOBIANS_ROWS_MISMATCH = la jacobienne de l''état a {0} lignes alors que la jacobienne des paramètres en a {1}
......
......@@ -268,8 +268,8 @@ SINGULAR_JACOBIAN_FOR_ORBIT_TYPE = matriz xacobiana asociada ao tipo {0} é sing
# state Jacobian has not been initialized yet
STATE_JACOBIAN_NOT_INITIALIZED = a xacobiana do estado non foi aínda inicializada
# state Jacobian is a {0}x{1} matrix, it should be either a 6x6 or a 7x7 matrix
STATE_JACOBIAN_NEITHER_6X6_NOR_7X7 = a xacobiana do estado es una matriz {0}x{1}, y debería ser una matriz 6x6 o 7x7
# state Jacobian is a {0}x{1} matrix, it should be a 6x6 matrix