diff --git a/src/main/java/org/orekit/forces/maneuvers/jacobians/MassDepletionDelay.java b/src/main/java/org/orekit/forces/maneuvers/jacobians/MassDepletionDelay.java index b9f351438119ed3cbe3a87f3f5285388893aa2e9..d587c05e876c26e2c03ccd0649f2d5fff10b3d6b 100644 --- a/src/main/java/org/orekit/forces/maneuvers/jacobians/MassDepletionDelay.java +++ b/src/main/java/org/orekit/forces/maneuvers/jacobians/MassDepletionDelay.java @@ -20,6 +20,7 @@ import org.hipparchus.geometry.euclidean.threed.Vector3D; import org.orekit.forces.maneuvers.Maneuver; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.time.AbsoluteDate; /** Generator for effect of delaying mass depletion when delaying a maneuver. @@ -79,7 +80,14 @@ public class MassDepletionDelay implements AdditionalDerivativesProvider { /** {@inheritDoc} */ @Override + @Deprecated public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + @Override + public CombinedDerivatives combinedDerivatives(final SpacecraftState state) { // retrieve current Jacobian column final double[] p = state.getAdditionalState(getName()); @@ -108,7 +116,7 @@ public class MassDepletionDelay implements AdditionalDerivativesProvider { } - return pDot; + return new CombinedDerivatives(pDot, null); } diff --git a/src/main/java/org/orekit/propagation/integration/AbstractIntegratedPropagator.java b/src/main/java/org/orekit/propagation/integration/AbstractIntegratedPropagator.java index 4ec638af697a44cf1d028d4fd399b04f5b16786b..e892725e9caec74f2c531d7f8274acc55677a3a2 100644 --- a/src/main/java/org/orekit/propagation/integration/AbstractIntegratedPropagator.java +++ b/src/main/java/org/orekit/propagation/integration/AbstractIntegratedPropagator.java @@ -823,12 +823,20 @@ public abstract class AbstractIntegratedPropagator extends AbstractPropagator { } } else { // we can use these equations right now - final String name = provider.getName(); - final int offset = secondaryOffsets.get(name); - final int dimension = provider.getDimension(); - final double[] derivatives = provider.derivatives(updated); - System.arraycopy(derivatives, 0, secondaryDot, offset, dimension); - updated = updated.addAdditionalStateDerivative(name, derivatives); + final String name = provider.getName(); + final int offset = secondaryOffsets.get(name); + final int dimension = provider.getDimension(); + final CombinedDerivatives derivatives = provider.combinedDerivatives(updated); + final double[] additionalPart = derivatives.getAdditionalDerivatives(); + final double[] mainPart = derivatives.getMainStateDerivativesIncrements(); + System.arraycopy(additionalPart, 0, secondaryDot, offset, dimension); + updated = updated.addAdditionalStateDerivative(name, additionalPart); + if (mainPart != null) { + // this equation does change the main state derivatives + for (int i = 0; i < mainPart.length; ++i) { + primaryDot[i] += mainPart[i]; + } + } yieldCount = 0; } } diff --git a/src/main/java/org/orekit/propagation/integration/AdditionalDerivativesProvider.java b/src/main/java/org/orekit/propagation/integration/AdditionalDerivativesProvider.java index 682de053b470720d4464a17478940581c387570f..4933e46499a039e6a0015180bab8b31f37f94589 100644 --- a/src/main/java/org/orekit/propagation/integration/AdditionalDerivativesProvider.java +++ b/src/main/java/org/orekit/propagation/integration/AdditionalDerivativesProvider.java @@ -85,7 +85,7 @@ public interface AdditionalDerivativesProvider { * } *

* The default implementation returns {@code false}, meaning that derivative data can be - * {@link #derivatives(SpacecraftState) computed} immediately. + * {@link #combinedDerivatives(SpacecraftState) computed} immediately. *

* @param state state to handle * @return true if this provider should yield so another provider has an opportunity to add missing parts @@ -100,7 +100,28 @@ public interface AdditionalDerivativesProvider { * additional states this equations depend on (according to the * {@link #yield(SpacecraftState) yield} method) * @return computed derivatives + * @deprecated as of 11.2, replaced by {@link #combinedDerivatives(SpacecraftState)} */ + @Deprecated double[] derivatives(SpacecraftState s); + /** Compute the derivatives related to the additional state (and optionally main state increments). + *

+ * As of 11.2, there is a default implementation that calls the deprecated + * {@link #derivatives(SpacecraftState)} method. This has been done for + * backward compatibility only and will be removed in 12.0. + *

+ * @param s current state information: date, kinematics, attitude, and + * additional states this equations depend on (according to the + * {@link #yield(SpacecraftState) yield} method) + * @return computed combined derivatives, which may include some incremental + * coupling effect to add to main state derivatives + * @since 11.2 + */ + default CombinedDerivatives combinedDerivatives(SpacecraftState s) { + // this default implementation will be removed + // when the deprecated derivatives method above is removed + return new CombinedDerivatives(derivatives(s), null); + } + } diff --git a/src/main/java/org/orekit/propagation/integration/AdditionalEquationsAdapter.java b/src/main/java/org/orekit/propagation/integration/AdditionalEquationsAdapter.java index 465ea5c9c4bd2d8368e59ff666bcaf069e686299..8e8641532ce881f1248b523779ae1be003491d08 100644 --- a/src/main/java/org/orekit/propagation/integration/AdditionalEquationsAdapter.java +++ b/src/main/java/org/orekit/propagation/integration/AdditionalEquationsAdapter.java @@ -78,10 +78,17 @@ public class AdditionalEquationsAdapter implements AdditionalDerivativesProvider /** {@inheritDoc} */ @Override + @Deprecated public double[] derivatives(final SpacecraftState state) { - final double[] pDot = new double[getDimension()]; - equations.computeDerivatives(state, pDot); - return pDot; + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + @Override + public CombinedDerivatives combinedDerivatives(final SpacecraftState state) { + final double[] pDot = new double[getDimension()]; + final double[] mainDot = equations.computeDerivatives(state, pDot); + return new CombinedDerivatives(pDot, mainDot); } } diff --git a/src/main/java/org/orekit/propagation/integration/CombinedDerivatives.java b/src/main/java/org/orekit/propagation/integration/CombinedDerivatives.java new file mode 100644 index 0000000000000000000000000000000000000000..cd833be6c338fbc0c3c95f2330933f8596b67d33 --- /dev/null +++ b/src/main/java/org/orekit/propagation/integration/CombinedDerivatives.java @@ -0,0 +1,60 @@ +/* Copyright 2002-2022 CS GROUP + * Licensed to CS GROUP (CS) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * CS licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.orekit.propagation.integration; + +/** Container for additional derivatives. + * @see AdditionalDerivativesProvider + * @author Luc Maisonobe + * @since 11.2 + */ +public class CombinedDerivatives { + + /** Additional state derivatives. */ + private double[] additionalDerivatives; + + /** Primary state derivatives increments (may be null). */ + private final double[] mainStateDerivativesIncrements; + + /** Simple constructor. + * @param additionalDerivatives additional state derivatives + * @param mainStateDerivativesIncrements increments related to the main state parameters + * (may be null if main state should not be incremented) + */ + public CombinedDerivatives(final double[] additionalDerivatives, + final double[] mainStateDerivativesIncrements) { + this.mainStateDerivativesIncrements = mainStateDerivativesIncrements == null ? + null : mainStateDerivativesIncrements.clone(); + this.additionalDerivatives = additionalDerivatives.clone(); + } + + /** Get the derivatives increments related to the main state. + * @return primary state derivatives increments, or null if + * main state should not be incremented + */ + public double[] getMainStateDerivativesIncrements() { + return mainStateDerivativesIncrements == null ? + null : mainStateDerivativesIncrements.clone(); + } + + /** Get the derivatives related to the additional state. + * @return additional state derivatives + */ + public double[] getAdditionalDerivatives() { + return additionalDerivatives.clone(); + } + +} diff --git a/src/main/java/org/orekit/propagation/integration/FieldAbstractIntegratedPropagator.java b/src/main/java/org/orekit/propagation/integration/FieldAbstractIntegratedPropagator.java index daff0b6612e29416e4344305c3d6c91476ae32a9..712b8d0b47b93aa8ac7c9027a6ee6f5cec1d9e02 100644 --- a/src/main/java/org/orekit/propagation/integration/FieldAbstractIntegratedPropagator.java +++ b/src/main/java/org/orekit/propagation/integration/FieldAbstractIntegratedPropagator.java @@ -806,12 +806,20 @@ public abstract class FieldAbstractIntegratedPropagator derivatives = equations.combinedDerivatives(updated); + final T[] additionalPart = derivatives.getAdditionalDerivatives(); + final T[] mainPart = derivatives.getMainStateDerivativesIncrements(); + System.arraycopy(additionalPart, 0, secondaryDot, offset, dimension); + updated = updated.addAdditionalStateDerivative(name, additionalPart); + if (mainPart != null) { + // this equation does change the main state derivatives + for (int i = 0; i < mainPart.length; ++i) { + primaryDot[i] = primaryDot[i].add(mainPart[i]); + } + } yieldCount = 0; } } diff --git a/src/main/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvider.java b/src/main/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvider.java index dfd3754cc860b0e4cc38b2fef04116087a1254f0..4170fd995b1eb3a4a730d1bd58ca7afc7e605096 100644 --- a/src/main/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvider.java +++ b/src/main/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvider.java @@ -101,7 +101,28 @@ public interface FieldAdditionalDerivativesProvider s); + /** Compute the derivatives related to the additional state (and optionally main state increments). + *

+ * As of 11.2, there is a default implementation that calls the deprecated + * {@link #derivatives(FieldSpacecraftState) method. This has been done for + * backward compatibility only and will be removed in 12.0. + *

+ * @param s current state information: date, kinematics, attitude, and + * additional states this equations depend on (according to the + * {@link #yield(FieldSpacecraftState) yield} method) + * @return computed combined derivatives, which may include some incremental + * coupling effect to add to main state derivatives + * @since 11.2 + */ + default FieldCombinedDerivatives combinedDerivatives(FieldSpacecraftState s) { + // this default implementation will be removed + // when the deprecated derivatives method above is removed + return new FieldCombinedDerivatives<>(derivatives(s), null); + } + } diff --git a/src/main/java/org/orekit/propagation/integration/FieldAdditionalEquationsAdapter.java b/src/main/java/org/orekit/propagation/integration/FieldAdditionalEquationsAdapter.java index 589cf9f6552f50b20b1b8ed7f58f3b088272fcb4..9ae5c6fed927b2fc445a341f3c9767add50bfc37 100644 --- a/src/main/java/org/orekit/propagation/integration/FieldAdditionalEquationsAdapter.java +++ b/src/main/java/org/orekit/propagation/integration/FieldAdditionalEquationsAdapter.java @@ -80,9 +80,15 @@ public class FieldAdditionalEquationsAdapter> /** {@inheritDoc} */ @Override public T[] derivatives(final FieldSpacecraftState state) { - final T[] pDot = MathArrays.buildArray(state.getDate().getField(), getDimension()); - equations.computeDerivatives(state, pDot); - return pDot; + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + @Override + public FieldCombinedDerivatives combinedDerivatives(final FieldSpacecraftState state) { + final T[] pDot = MathArrays.buildArray(state.getDate().getField(), getDimension()); + final T[] mainDot = equations.computeDerivatives(state, pDot); + return new FieldCombinedDerivatives<>(pDot, mainDot); } } diff --git a/src/main/java/org/orekit/propagation/integration/FieldCombinedDerivatives.java b/src/main/java/org/orekit/propagation/integration/FieldCombinedDerivatives.java new file mode 100644 index 0000000000000000000000000000000000000000..a474ad6982ad4e7d9e6df96398fca73d43b77839 --- /dev/null +++ b/src/main/java/org/orekit/propagation/integration/FieldCombinedDerivatives.java @@ -0,0 +1,63 @@ +/* Copyright 2002-2022 CS GROUP + * Licensed to CS GROUP (CS) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * CS licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.orekit.propagation.integration; + +import org.hipparchus.CalculusFieldElement; + +/** Container for additional derivatives. + * @see FieldAdditionalDerivativesProvider + * @author Luc Maisonobe + * @since 11.2 + * @param type of the field elements + */ +public class FieldCombinedDerivatives> { + + /** Additional state derivatives. */ + private T[] additionalDerivatives; + + /** Primary state derivatives increments (may be null). */ + private final T[] mainStateDerivativesIncrements; + + /** Simple constructor. + * @param additionalDerivatives additional state derivatives + * @param mainStateDerivativesIncrements increments related to the main state parameters + * (may be null if main state should not be incremented) + */ + public FieldCombinedDerivatives(final T[] additionalDerivatives, + final T[] mainStateDerivativesIncrements) { + this.mainStateDerivativesIncrements = mainStateDerivativesIncrements == null ? + null : mainStateDerivativesIncrements.clone(); + this.additionalDerivatives = additionalDerivatives.clone(); + } + + /** Get the derivatives increments related to the main state. + * @return primary state derivatives increments, or null if + * main state should not be incremented + */ + public T[] getMainStateDerivativesIncrements() { + return mainStateDerivativesIncrements == null ? + null : mainStateDerivativesIncrements.clone(); + } + + /** Get the derivatives related to the additional state. + * @return additional state derivatives + */ + public T[] getAdditionalDerivatives() { + return additionalDerivatives.clone(); + } + +} diff --git a/src/main/java/org/orekit/propagation/numerical/EpochDerivativesEquations.java b/src/main/java/org/orekit/propagation/numerical/EpochDerivativesEquations.java index 14b25f2e78a1d35ed19e62aa95cdc66bfcf64e49..bade437a762eaa08c5003b40b4ed10825b8e9e65 100644 --- a/src/main/java/org/orekit/propagation/numerical/EpochDerivativesEquations.java +++ b/src/main/java/org/orekit/propagation/numerical/EpochDerivativesEquations.java @@ -28,6 +28,8 @@ import org.orekit.forces.gravity.ThirdBodyAttractionEpoch; import org.orekit.propagation.FieldSpacecraftState; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.AdditionalEquations; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.time.AbsoluteDate; import org.orekit.utils.ParameterDriver; import org.orekit.utils.ParameterDriversList; @@ -270,7 +272,14 @@ public class EpochDerivativesEquations } /** {@inheritDoc} */ - public double[] derivatives(final SpacecraftState s) { + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + public CombinedDerivatives combinedDerivatives(final SpacecraftState s) { // initialize acceleration Jacobians to zero final int paramDimEpoch = selected.getNbParams() + 1; // added epoch @@ -402,7 +411,7 @@ public class EpochDerivativesEquations } - return pDot; + return new CombinedDerivatives(pDot, null); } diff --git a/src/main/java/org/orekit/propagation/numerical/IntegrableJacobianColumnGenerator.java b/src/main/java/org/orekit/propagation/numerical/IntegrableJacobianColumnGenerator.java index b543635dae98851e4b51af45c6f41268bc27d888..c7bf643762cce961ad56ad779201657c49030400 100644 --- a/src/main/java/org/orekit/propagation/numerical/IntegrableJacobianColumnGenerator.java +++ b/src/main/java/org/orekit/propagation/numerical/IntegrableJacobianColumnGenerator.java @@ -18,6 +18,7 @@ package org.orekit.propagation.numerical; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; /** Generator for one column of a Jacobian matrix. *

@@ -96,8 +97,15 @@ class IntegrableJacobianColumnGenerator /** {@inheritDoc} */ @Override - public double[] derivatives(final SpacecraftState s) { - return pDot; + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + @Override + public CombinedDerivatives combinedDerivatives(final SpacecraftState s) { + return new CombinedDerivatives(pDot, null); } } diff --git a/src/main/java/org/orekit/propagation/numerical/PartialDerivativesEquations.java b/src/main/java/org/orekit/propagation/numerical/PartialDerivativesEquations.java index 2e88064088e06280d5d25088f27a1680426873f7..af27487ac1cd5742bf2f79c17117efcc83c44d39 100644 --- a/src/main/java/org/orekit/propagation/numerical/PartialDerivativesEquations.java +++ b/src/main/java/org/orekit/propagation/numerical/PartialDerivativesEquations.java @@ -27,6 +27,7 @@ import org.orekit.forces.ForceModel; import org.orekit.propagation.FieldSpacecraftState; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.time.AbsoluteDate; import org.orekit.utils.ParameterDriver; import org.orekit.utils.ParameterDriversList; @@ -274,7 +275,14 @@ public class PartialDerivativesEquations } /** {@inheritDoc} */ - public double[] derivatives(final SpacecraftState s) { + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + public CombinedDerivatives combinedDerivatives(final SpacecraftState s) { // initialize acceleration Jacobians to zero final int paramDim = selected.getNbParams(); @@ -398,7 +406,7 @@ public class PartialDerivativesEquations } - return pDot; + return new CombinedDerivatives(pDot, null); } diff --git a/src/main/java/org/orekit/propagation/numerical/StateTransitionMatrixGenerator.java b/src/main/java/org/orekit/propagation/numerical/StateTransitionMatrixGenerator.java index 69796dc850d6722b29ef9c9494fea990b8313ad3..7966954c8559eee4b29ec0d01cc243441b9daaee 100644 --- a/src/main/java/org/orekit/propagation/numerical/StateTransitionMatrixGenerator.java +++ b/src/main/java/org/orekit/propagation/numerical/StateTransitionMatrixGenerator.java @@ -35,6 +35,7 @@ import org.orekit.orbits.PositionAngle; import org.orekit.propagation.FieldSpacecraftState; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.utils.DoubleArrayDictionary; import org.orekit.utils.ParameterDriver; @@ -163,7 +164,14 @@ class StateTransitionMatrixGenerator implements AdditionalDerivativesProvider { } /** {@inheritDoc} */ + @Override + @Deprecated public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + public CombinedDerivatives combinedDerivatives(final SpacecraftState state) { // Assuming position is (px, py, pz), velocity is (vx, vy, vz) and the acceleration // due to the force models is (Σ ax, Σ ay, Σ az), the differential equation for @@ -186,7 +194,7 @@ class StateTransitionMatrixGenerator implements AdditionalDerivativesProvider { // perform multiplication multiplyMatrix(factor, p, pDot, STATE_DIMENSION); - return pDot; + return new CombinedDerivatives(pDot, null); } diff --git a/src/main/java/org/orekit/propagation/numerical/cr3bp/STMEquations.java b/src/main/java/org/orekit/propagation/numerical/cr3bp/STMEquations.java index de0f8dbdafede90342afb01a267c0527ee3c2873..4c68bc902c9bbe177d476ecf6fd22d369fc7b70d 100644 --- a/src/main/java/org/orekit/propagation/numerical/cr3bp/STMEquations.java +++ b/src/main/java/org/orekit/propagation/numerical/cr3bp/STMEquations.java @@ -24,6 +24,7 @@ import org.hipparchus.linear.RealMatrix; import org.orekit.bodies.CR3BPSystem; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.time.AbsoluteDate; /** Class calculating the state transition matrix coefficient for CR3BP Computation. @@ -94,7 +95,14 @@ public class STMEquations } /** {@inheritDoc} */ - public double[] derivatives(final SpacecraftState s) { + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + public CombinedDerivatives combinedDerivatives(final SpacecraftState s) { // State Transition Matrix final double[] phi = s.getAdditionalState(getName()); @@ -135,7 +143,7 @@ public class STMEquations } } - return dPhi; + return new CombinedDerivatives(dPhi, null); } diff --git a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTIntegrableJacobianColumnGenerator.java b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTIntegrableJacobianColumnGenerator.java index 206716a5bbf13473aadd3bf15aed2f823a7d639a..cc2af9fce51a45218e2d11e5aa13da8b4bf892de 100644 --- a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTIntegrableJacobianColumnGenerator.java +++ b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTIntegrableJacobianColumnGenerator.java @@ -19,6 +19,7 @@ package org.orekit.propagation.semianalytical.dsst; import org.hipparchus.linear.RealMatrix; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; /** Generator for one column of a Jacobian matrix. *

@@ -98,8 +99,15 @@ class DSSTIntegrableJacobianColumnGenerator /** {@inheritDoc} */ @Override - public double[] derivatives(final SpacecraftState s) { - return pDot; + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + @Override + public CombinedDerivatives combinedDerivatives(final SpacecraftState s) { + return new CombinedDerivatives(pDot, null); } } diff --git a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPartialDerivativesEquations.java b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPartialDerivativesEquations.java index f8018f0d1e239e164cba167dda39c34797b3f6d1..4a6b7702396dd82ac9b2d623ade3fe8af5a79ea9 100644 --- a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPartialDerivativesEquations.java +++ b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPartialDerivativesEquations.java @@ -26,6 +26,7 @@ import org.orekit.propagation.FieldSpacecraftState; import org.orekit.propagation.PropagationType; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.semianalytical.dsst.forces.DSSTForceModel; import org.orekit.propagation.semianalytical.dsst.utilities.FieldAuxiliaryElements; import org.orekit.time.AbsoluteDate; @@ -267,7 +268,14 @@ public class DSSTPartialDerivativesEquations } /** {@inheritDoc} */ - public double[] derivatives(final SpacecraftState s) { + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + public CombinedDerivatives combinedDerivatives(final SpacecraftState s) { // initialize Jacobians to zero final int paramDim = selected.getNbParams(); @@ -361,7 +369,7 @@ public class DSSTPartialDerivativesEquations } } - return pDot; + return new CombinedDerivatives(pDot, null); } diff --git a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGenerator.java b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGenerator.java index c8ca596bf79ef8f81cdaf053ff266e75441f204e..f10790fc0469bca3e6a5dc0d881dc972aba51d08 100644 --- a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGenerator.java +++ b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGenerator.java @@ -29,6 +29,7 @@ import org.orekit.errors.OrekitException; import org.orekit.propagation.FieldSpacecraftState; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.semianalytical.dsst.forces.DSSTForceModel; import org.orekit.propagation.semianalytical.dsst.utilities.FieldAuxiliaryElements; import org.orekit.utils.DoubleArrayDictionary; @@ -152,7 +153,14 @@ class DSSTStateTransitionMatrixGenerator implements AdditionalDerivativesProvide } /** {@inheritDoc} */ + @Override + @Deprecated public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + /** {@inheritDoc} */ + public CombinedDerivatives combinedDerivatives(final SpacecraftState state) { final double[] p = state.getAdditionalState(getName()); final double[] res = new double[p.length]; @@ -170,7 +178,7 @@ class DSSTStateTransitionMatrixGenerator implements AdditionalDerivativesProvide } } - return res; + return new CombinedDerivatives(res, null); } diff --git a/src/test/java/org/orekit/gnss/metric/ntrip/CountingObserver.java b/src/test/java/org/orekit/gnss/metric/ntrip/CountingObserver.java index bbe3a2aeea8677e9857908a5341db428652da02b..22b61da60527495a820bbcf602409a3d2d26e0b4 100644 --- a/src/test/java/org/orekit/gnss/metric/ntrip/CountingObserver.java +++ b/src/test/java/org/orekit/gnss/metric/ntrip/CountingObserver.java @@ -38,7 +38,7 @@ public class CountingObserver implements MessageObserver { public void messageAvailable(String mountPoint, ParsedMessage message) { if (filter.apply(message)) { - final int i = received.incrementAndGet(); + received.incrementAndGet(); phaser.arrive(); } } diff --git a/src/test/java/org/orekit/orbits/KeplerianOrbitTest.java b/src/test/java/org/orekit/orbits/KeplerianOrbitTest.java index 77fda19b5870a103c82706f9b18a01d110cd5348..2b8c0955ad6ce5227fe8fc59841ce92fafd0ae1b 100644 --- a/src/test/java/org/orekit/orbits/KeplerianOrbitTest.java +++ b/src/test/java/org/orekit/orbits/KeplerianOrbitTest.java @@ -27,7 +27,6 @@ import java.util.ArrayList; import java.util.List; import java.util.function.Function; -import org.hamcrest.CoreMatchers; import org.hamcrest.MatcherAssert; import org.hipparchus.analysis.UnivariateFunction; import org.hipparchus.analysis.differentiation.DSFactory; diff --git a/src/test/java/org/orekit/propagation/PropagatorsParallelizerTest.java b/src/test/java/org/orekit/propagation/PropagatorsParallelizerTest.java index 8ec2c777c37dd753c502d06422cc65a2e26aad37..45be44716c603669c134caa90e28a2ce57f578f4 100644 --- a/src/test/java/org/orekit/propagation/PropagatorsParallelizerTest.java +++ b/src/test/java/org/orekit/propagation/PropagatorsParallelizerTest.java @@ -51,6 +51,7 @@ import org.orekit.propagation.analytical.EcksteinHechlerPropagator; import org.orekit.propagation.events.DateDetector; import org.orekit.propagation.events.handlers.StopOnEvent; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.numerical.NumericalPropagator; import org.orekit.propagation.semianalytical.dsst.DSSTPropagator; import org.orekit.propagation.semianalytical.dsst.forces.DSSTForceModel; @@ -341,8 +342,12 @@ public class PropagatorsParallelizerTest { public boolean yield(final SpacecraftState state) { return !state.hasAdditionalState(name); } - public double[] derivatives(final SpacecraftState state) { - return new double[] { base * state.getAdditionalState(name)[0] }; + public double[] derivatives(SpacecraftState s) { + return null; + } + public CombinedDerivatives combinedDerivatives(SpacecraftState state) { + return new CombinedDerivatives(new double[] { base * state.getAdditionalState(name)[0] }, + null); } public int getDimension() { return 1; diff --git a/src/test/java/org/orekit/propagation/conversion/DSSTPropagatorBuilderTest.java b/src/test/java/org/orekit/propagation/conversion/DSSTPropagatorBuilderTest.java index 44fde3ba8344a425f5cec7d509526bbb3a0a5874..875433154893d24b67de4584716a4c55a3cb650a 100644 --- a/src/test/java/org/orekit/propagation/conversion/DSSTPropagatorBuilderTest.java +++ b/src/test/java/org/orekit/propagation/conversion/DSSTPropagatorBuilderTest.java @@ -40,6 +40,7 @@ import org.orekit.orbits.PositionAngle; import org.orekit.propagation.PropagationType; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.numerical.NumericalPropagator; import org.orekit.propagation.semianalytical.dsst.DSSTPropagator; import org.orekit.propagation.semianalytical.dsst.forces.DSSTForceModel; @@ -229,9 +230,17 @@ public class DSSTPropagatorBuilderTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + /** {@inheritDoc} */ + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); + } + }); builder.addAdditionalDerivativesProvider(new AdditionalDerivativesProvider() { @@ -244,9 +253,17 @@ public class DSSTPropagatorBuilderTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + /** {@inheritDoc} */ + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); } + }); try { diff --git a/src/test/java/org/orekit/propagation/conversion/NumericalConverterTest.java b/src/test/java/org/orekit/propagation/conversion/NumericalConverterTest.java index 0f31deb316b6d5984393c2790088d79d1061644d..1b47b640db6ec87feb1819ad321aa10dbfbd5f3c 100644 --- a/src/test/java/org/orekit/propagation/conversion/NumericalConverterTest.java +++ b/src/test/java/org/orekit/propagation/conversion/NumericalConverterTest.java @@ -49,6 +49,7 @@ import org.orekit.orbits.OrbitType; import org.orekit.orbits.PositionAngle; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.numerical.NumericalPropagator; import org.orekit.time.AbsoluteDate; import org.orekit.time.TimeScalesFactory; @@ -233,8 +234,12 @@ public class NumericalConverterTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + public double[] derivatives(final SpacecraftState state) { + return null; + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); } }); @@ -249,8 +254,12 @@ public class NumericalConverterTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + public double[] derivatives(final SpacecraftState state) { + return null; + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); } }); diff --git a/src/test/java/org/orekit/propagation/events/DateDetectorTest.java b/src/test/java/org/orekit/propagation/events/DateDetectorTest.java index 283c6de53d2a6184018463d35426fa6bf2ef625b..89b7a2f5ad77da46b34e05eaf0358e62730e9cc5 100644 --- a/src/test/java/org/orekit/propagation/events/DateDetectorTest.java +++ b/src/test/java/org/orekit/propagation/events/DateDetectorTest.java @@ -34,6 +34,7 @@ import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.events.handlers.ContinueOnEvent; import org.orekit.propagation.events.handlers.EventHandler; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.numerical.NumericalPropagator; import org.orekit.propagation.sampling.OrekitStepInterpolator; import org.orekit.time.AbsoluteDate; @@ -59,7 +60,10 @@ public class DateDetectorTest { propagator.addAdditionalDerivativesProvider(new AdditionalDerivativesProvider() { public String getName() { return "dummy"; } public int getDimension() { return 1; } - public double[] derivatives(SpacecraftState s) { return new double[1]; } + public double[] derivatives(final SpacecraftState state) { return null; } + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[1], null); + } }); propagator.setInitialState(propagator.getInitialState().addAdditionalState("dummy", new double[1])); propagator.getMultiplexer().add(interpolator -> { diff --git a/src/test/java/org/orekit/propagation/integration/AdditionalDerivativesProvidersTest.java b/src/test/java/org/orekit/propagation/integration/AdditionalDerivativesProvidersTest.java index 2605d1567e65587280aadaddb34ff7303506d60d..4c2294d8e9b1dc52c1aa872d0f18cb8884310162 100644 --- a/src/test/java/org/orekit/propagation/integration/AdditionalDerivativesProvidersTest.java +++ b/src/test/java/org/orekit/propagation/integration/AdditionalDerivativesProvidersTest.java @@ -162,6 +162,33 @@ public class AdditionalDerivativesProvidersTest { } + @Test + public void testCoupling() { + + // setup + final double dt = 600.0; + final Coupling coupling = new Coupling("coupling", 3.5, -2.0, 1.0); + + // action + AdaptiveStepsizeIntegrator integrator = new DormandPrince853Integrator(0.001, 200, tolerance[0], tolerance[1]); + integrator.setInitialStepSize(60); + NumericalPropagator propagatorNumerical = new NumericalPropagator(integrator); + propagatorNumerical.setInitialState(initialState. + addAdditionalState(coupling.getName(), + coupling.secondaryInit)); + propagatorNumerical.addAdditionalDerivativesProvider(coupling); + SpacecraftState finalState = propagatorNumerical.propagate(initDate.shiftedBy(dt)); + + // verify + Assert.assertEquals(coupling.secondaryInit + dt * coupling.secondaryRate, + finalState.getAdditionalState(coupling.getName())[0], + 1.0e-10); + Assert.assertEquals(initialState.getA() + dt * coupling.smaRate, + finalState.getA(), + 1.0e-10); + + } + @Before public void setUp() { Utils.setDataRoot("regular-data:potential/shm-format"); @@ -204,8 +231,14 @@ public class AdditionalDerivativesProvidersTest { } @Override - public double[] derivatives(SpacecraftState s) { - return new double[] { rate }; + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + @Override + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { rate }, null); } @Override @@ -237,8 +270,17 @@ public class AdditionalDerivativesProvidersTest { } @Override - public double[] derivatives(final SpacecraftState s) { - return dependency == null ? new double[] { rate } : s.getAdditionalStateDerivative(dependency); + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + @Override + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(dependency == null ? + new double[] { rate } : + s.getAdditionalStateDerivative(dependency), + null); } @Override @@ -258,4 +300,44 @@ public class AdditionalDerivativesProvidersTest { } + private static class Coupling implements AdditionalDerivativesProvider { + + private final String name; + private final double secondaryInit; + private final double secondaryRate; + private final double smaRate; + + public Coupling(final String name, + final double secondaryInit, final double secondaryRate, + final double smaRate) { + this.name = name; + this.secondaryInit = secondaryInit; + this.secondaryRate = secondaryRate; + this.smaRate = smaRate; + } + + @Override + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + @Override + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { secondaryRate }, + new double[] { smaRate, 0.0, 0.0, 0.0, 0.0, 0.0 }); + } + + @Override + public int getDimension() { + return 1; + } + + @Override + public String getName() { + return name; + } + + } + } diff --git a/src/test/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvidersTest.java b/src/test/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvidersTest.java index 6121beb7835c0f798b1042828ffc3fd771735014..7eb58b254fbeb0bc6cfb7a949aa5deba52a627fa 100644 --- a/src/test/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvidersTest.java +++ b/src/test/java/org/orekit/propagation/integration/FieldAdditionalDerivativesProvidersTest.java @@ -74,6 +74,11 @@ public class FieldAdditionalDerivativesProvidersTest { doTestYield(Decimal64Field.getInstance()); } + @Test + public void testCoupling() { + doTestCoupling(Decimal64Field.getInstance()); + } + private > void doTestInitNumerical(Field field) { // setup final double reference = 1.25; @@ -184,6 +189,34 @@ public class FieldAdditionalDerivativesProvidersTest { } + private > void doTestCoupling(Field field) { + + // setup + final T dt = field.getZero().newInstance(600.0); + final Coupling coupling = new Coupling<>("coupling", 3.5, -2.0, 1.0); + + // action + AdaptiveStepsizeFieldIntegrator integrator = + new DormandPrince853FieldIntegrator<>(field, 0.001, 200, + tolerance[0], tolerance[1]); + integrator.setInitialStepSize(60); + FieldNumericalPropagator propagatorNumerical = new FieldNumericalPropagator<>(field, integrator); + propagatorNumerical.setInitialState(new FieldSpacecraftState<>(field, initialState). + addAdditionalState(coupling.getName(), + field.getZero().newInstance(coupling.secondaryInit))); + propagatorNumerical.addAdditionalDerivativesProvider(coupling); + FieldSpacecraftState finalState = propagatorNumerical.propagate(new FieldAbsoluteDate<>(field, initDate).shiftedBy(dt)); + + // verify + Assert.assertEquals(coupling.secondaryInit + dt.getReal() * coupling.secondaryRate, + finalState.getAdditionalState(coupling.getName())[0].getReal(), + 1.0e-10); + Assert.assertEquals(initialState.getA() + dt.getReal() * coupling.smaRate, + finalState.getA().getReal(), + 1.0e-10); + + } + @Before public void setUp() { Utils.setDataRoot("regular-data:potential/shm-format"); @@ -226,10 +259,16 @@ public class FieldAdditionalDerivativesProvidersTest { } @Override - public T[] derivatives(FieldSpacecraftState s) { + @Deprecated + public T[] derivatives(final FieldSpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + @Override + public FieldCombinedDerivatives combinedDerivatives(FieldSpacecraftState s) { final T[] pDot = MathArrays.buildArray(s.getDate().getField(), 1); pDot[0] = s.getDate().getField().getZero().newInstance(rate); - return pDot; + return new FieldCombinedDerivatives<>(pDot, null); } @Override @@ -261,7 +300,13 @@ public class FieldAdditionalDerivativesProvidersTest { } @Override - public T[] derivatives(final FieldSpacecraftState s) { + @Deprecated + public T[] derivatives(final FieldSpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + @Override + public FieldCombinedDerivatives combinedDerivatives(FieldSpacecraftState s) { final T[] pDot; if (dependency == null) { pDot = MathArrays.buildArray(s.getDate().getField(), 1); @@ -269,7 +314,7 @@ public class FieldAdditionalDerivativesProvidersTest { } else { pDot = s.getAdditionalStateDerivative(dependency); } - return pDot; + return new FieldCombinedDerivatives<>(pDot, null); } @Override @@ -289,4 +334,53 @@ public class FieldAdditionalDerivativesProvidersTest { } + private static class Coupling> implements FieldAdditionalDerivativesProvider { + + private final String name; + private final double secondaryInit; + private final double secondaryRate; + private final double smaRate; + + public Coupling(final String name, + final double secondaryInit, final double secondaryRate, + final double smaRate) { + this.name = name; + this.secondaryInit = secondaryInit; + this.secondaryRate = secondaryRate; + this.smaRate = smaRate; + } + + @Override + @Deprecated + public T[] derivatives(final FieldSpacecraftState state) { + return combinedDerivatives(state).getAdditionalDerivatives(); + } + + @Override + public FieldCombinedDerivatives combinedDerivatives(FieldSpacecraftState s) { + final Field field = s.getDate().getField(); + T[] pDot = MathArrays.buildArray(field, 1); + T[] mainIncrement = MathArrays.buildArray(field, 6); + mainIncrement[0] = field.getZero().newInstance(smaRate); + mainIncrement[1] = field.getZero(); + mainIncrement[2] = field.getZero(); + mainIncrement[3] = field.getZero(); + mainIncrement[4] = field.getZero(); + mainIncrement[5] = field.getZero(); + pDot[0] = field.getZero().newInstance(secondaryRate); + return new FieldCombinedDerivatives<>(pDot, mainIncrement); + } + + @Override + public int getDimension() { + return 1; + } + + @Override + public String getName() { + return name; + } + + } + } diff --git a/src/test/java/org/orekit/propagation/numerical/NumericalPropagatorTest.java b/src/test/java/org/orekit/propagation/numerical/NumericalPropagatorTest.java index 6634fa6e20dd3e4f9877646a6a159ac08cc8cccb..5783a15ddc53974624f3f826179073ff5781261a 100644 --- a/src/test/java/org/orekit/propagation/numerical/NumericalPropagatorTest.java +++ b/src/test/java/org/orekit/propagation/numerical/NumericalPropagatorTest.java @@ -95,6 +95,7 @@ import org.orekit.propagation.events.handlers.RecordAndContinue; import org.orekit.propagation.events.handlers.StopOnEvent; import org.orekit.propagation.integration.AbstractIntegratedPropagator; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.sampling.OrekitFixedStepHandler; import org.orekit.propagation.sampling.OrekitStepHandler; import org.orekit.propagation.sampling.OrekitStepInterpolator; @@ -692,8 +693,12 @@ public class NumericalPropagatorTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + public double[] derivatives(final SpacecraftState state) { + return null; + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); } }); @@ -708,8 +713,12 @@ public class NumericalPropagatorTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + public double[] derivatives(final SpacecraftState state) { + return null; + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); } }); @@ -727,8 +736,12 @@ public class NumericalPropagatorTest { return 1; } - public double[] derivatives(SpacecraftState state) { - return null; + public double[] derivatives(final SpacecraftState state) { + return null; + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[1], null); } }); Assert.fail("an exception should have been thrown"); @@ -799,8 +812,12 @@ public class NumericalPropagatorTest { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { 1.0 }; + public double[] derivatives(final SpacecraftState state) { + return null; + } + + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { 1.0 }, null); } }); propagator.setInitialState(propagator.getInitialState().addAdditionalState("linear", 1.5)); @@ -937,8 +954,11 @@ public class NumericalPropagatorTest { public int getDimension() { return 1; } - public double[] derivatives(SpacecraftState s) { - return new double[] { rate }; + public double[] derivatives(final SpacecraftState state) { + return null; + } + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[] { rate }, null); } }); propagator.setInitialState(propagator.getInitialState().addAdditionalState("extra", 1.5)); @@ -1572,8 +1592,14 @@ public class NumericalPropagatorTest { } @Override - public double[] derivatives(SpacecraftState s) { - return new double[getDimension()]; + @Deprecated + public double[] derivatives(final SpacecraftState state) { + return null; + } + + @Override + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[getDimension()], null); } @Override diff --git a/src/test/java/org/orekit/propagation/numerical/PickupHandler.java b/src/test/java/org/orekit/propagation/numerical/PickupHandler.java index e135839e3c3b6622c4b78a49e117ac64b53b067a..5ea43d5d45210d3115786f3510791ad2950029b7 100644 --- a/src/test/java/org/orekit/propagation/numerical/PickupHandler.java +++ b/src/test/java/org/orekit/propagation/numerical/PickupHandler.java @@ -111,7 +111,7 @@ class PickUpHandler implements OrekitStepHandler, StateTransitionMatrixGenerator } private void checkState(final SpacecraftState state) { - stmGenerator.derivatives(state); // just for the side effect of calling partialsComputed + stmGenerator.combinedDerivatives(state); // just for the side effect of calling partialsComputed Assert.assertEquals(columnName == null ? 1 : 2, state.getAdditionalStatesValues().size()); dYdY0 = harvester.getStateTransitionMatrix(state); dYdP = harvester.getParametersJacobian(state); // may be null diff --git a/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java b/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java index 26c276d71ccd2ebc3227ff6559f91162558843c4..5148c7714988d48963d180b7ea90337805444758 100644 --- a/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java +++ b/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java @@ -74,6 +74,7 @@ import org.orekit.propagation.events.EventDetector; import org.orekit.propagation.events.FieldEventDetector; import org.orekit.propagation.integration.AbstractIntegratedPropagator; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.time.AbsoluteDate; import org.orekit.time.DateComponents; import org.orekit.time.TimeComponents; @@ -141,7 +142,10 @@ public class StateTransitionMatrixGeneratorTest { propagator2.addAdditionalDerivativesProvider(new AdditionalDerivativesProvider() { public String getName() { return "dummy-3"; } public int getDimension() { return 1; } - public double[] derivatives(SpacecraftState s) { return new double[1]; } + public double[] derivatives(SpacecraftState s) { return null; } + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[1], null); + } }); propagator2.setInitialState(propagator2.getInitialState().addAdditionalState("dummy-3", new double[1])); propagator2.addAdditionalStateProvider(new TriggerDate(dummyStmGenerator.getName(), "dummy-4", true, @@ -200,7 +204,7 @@ public class StateTransitionMatrixGeneratorTest { propagator.getPositionAngleType()); //action - stmGenerator.derivatives(state); + stmGenerator.combinedDerivatives(state); //verify MatcherAssert.assertThat(forceModel.accelerationDerivativesPosition.toVector3D(), is(pv.getPosition())); diff --git a/src/test/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGeneratorTest.java b/src/test/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGeneratorTest.java index d38f25a49f4481d1493418ec30282c06ba39b3a6..e4a9bc29843bce21389d14d306e6aa7fa0a22c9f 100644 --- a/src/test/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGeneratorTest.java +++ b/src/test/java/org/orekit/propagation/semianalytical/dsst/DSSTStateTransitionMatrixGeneratorTest.java @@ -45,6 +45,7 @@ import org.orekit.propagation.MatricesHarvester; import org.orekit.propagation.PropagationType; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.integration.AdditionalDerivativesProvider; +import org.orekit.propagation.integration.CombinedDerivatives; import org.orekit.propagation.numerical.NumericalPropagator; import org.orekit.propagation.semianalytical.dsst.forces.DSSTForceModel; import org.orekit.propagation.semianalytical.dsst.forces.DSSTSolarRadiationPressure; @@ -103,7 +104,10 @@ public class DSSTStateTransitionMatrixGeneratorTest { propagator2.addAdditionalDerivativesProvider(new AdditionalDerivativesProvider() { public String getName() { return "dummy-3"; } public int getDimension() { return 1; } - public double[] derivatives(SpacecraftState s) { return new double[1]; } + public double[] derivatives(final SpacecraftState state) { return null; } + public CombinedDerivatives combinedDerivatives(SpacecraftState s) { + return new CombinedDerivatives(new double[1], null); + } }); propagator2.setInitialState(propagator2.getInitialState().addAdditionalState("dummy-3", new double[1]), propagator2.getPropagationType()); diff --git a/src/test/java/org/orekit/propagation/semianalytical/dsst/PickupHandler.java b/src/test/java/org/orekit/propagation/semianalytical/dsst/PickupHandler.java index 98c12a6c19ca15125ace1abde46dab0f710c4722..52e4402a18dbcd6ba40824268402aca0250c2542 100644 --- a/src/test/java/org/orekit/propagation/semianalytical/dsst/PickupHandler.java +++ b/src/test/java/org/orekit/propagation/semianalytical/dsst/PickupHandler.java @@ -106,7 +106,7 @@ class PickUpHandler implements OrekitStepHandler, DSSTStateTransitionMatrixGener } private void checkState(final SpacecraftState state) { - stmGenerator.derivatives(state); // just for the side effect of calling partialsComputed + stmGenerator.combinedDerivatives(state); // just for the side effect of calling partialsComputed Assert.assertEquals(columnName == null ? 1 : 2, state.getAdditionalStatesValues().size()); dYdY0 = harvester.getStateTransitionMatrix(state); dYdP = harvester.getParametersJacobian(state); // may be null