diff --git a/src/main/java/org/orekit/errors/OrekitMessages.java b/src/main/java/org/orekit/errors/OrekitMessages.java index 8e31dc84c910c366b60a905bce2e994390e0ee44..943f252aef3222e0408d7f5d523eb93761f60145 100644 --- a/src/main/java/org/orekit/errors/OrekitMessages.java +++ b/src/main/java/org/orekit/errors/OrekitMessages.java @@ -333,7 +333,8 @@ public enum OrekitMessages implements Localizable { FIND_ROOT("{0} failed to find root between {1} (g={2,number,0.0##############E0}) and {3} (g={4,number,0.0##############E0})\nLast iteration at {5} (g={6,number,0.0##############E0})"), BACKWARD_PROPAGATION_NOT_ALLOWED("backward propagation not allowed here"), NO_STATION_ECCENTRICITY_FOR_EPOCH("no station eccentricity values for the given epoch {0}, validity interval is between {1} and {2}"), - INCONSISTENT_SELECTION("inconsistent parameters selection between pairs {0}/{1} and {2}/{3}"); + INCONSISTENT_SELECTION("inconsistent parameters selection between pairs {0}/{1} and {2}/{3}"), + NOT_STRICTLY_POSITIVE("value is not strictly positive: {0}"); // CHECKSTYLE: resume JavadocVariable check diff --git a/src/main/java/org/orekit/forces/maneuvers/trigger/DateBasedManeuverTriggers.java b/src/main/java/org/orekit/forces/maneuvers/trigger/DateBasedManeuverTriggers.java index f3956934ed96eb623b3e1b58e3540ee2ca46f89d..3aaa49d97c677689fea1ff4c99377f285680a7e4 100644 --- a/src/main/java/org/orekit/forces/maneuvers/trigger/DateBasedManeuverTriggers.java +++ b/src/main/java/org/orekit/forces/maneuvers/trigger/DateBasedManeuverTriggers.java @@ -21,6 +21,7 @@ import java.util.List; import org.hipparchus.CalculusFieldElement; import org.hipparchus.Field; +import org.hipparchus.util.FastMath; import org.orekit.propagation.events.FieldAbstractDetector; import org.orekit.propagation.events.FieldEventDetector; import org.orekit.propagation.events.FieldParameterDrivenDateIntervalDetector; @@ -28,7 +29,7 @@ import org.orekit.propagation.events.ParameterDrivenDateIntervalDetector; import org.orekit.time.AbsoluteDate; import org.orekit.utils.ParameterDriver; -/** Maneuver triggers based on a start and end date, with no parameter drivers. +/** Maneuver triggers based on a start and end date. * @author Maxime Journot * @since 10.2 */ @@ -37,6 +38,11 @@ public class DateBasedManeuverTriggers extends IntervalEventTrigger= 0) { - return new ParameterDrivenDateIntervalDetector(prefix, date, date.shiftedBy(duration)); + return new ParameterDrivenDateIntervalDetector(prefix, date, date.shiftedBy(duration)). + withMaxCheck(FastMath.max(MIN_MAX_CHECK, duration)); } else { - return new ParameterDrivenDateIntervalDetector(prefix, date.shiftedBy(duration), date); + return new ParameterDrivenDateIntervalDetector(prefix, date.shiftedBy(duration), date). + withMaxCheck(FastMath.max(MIN_MAX_CHECK, -duration)); } } diff --git a/src/main/java/org/orekit/propagation/events/AbstractDetector.java b/src/main/java/org/orekit/propagation/events/AbstractDetector.java index 3c9ef80544f2ff2180fb0acc178120fba16cf969..e93cd4c0bc6b8143a27391177634e5a163a674c5 100644 --- a/src/main/java/org/orekit/propagation/events/AbstractDetector.java +++ b/src/main/java/org/orekit/propagation/events/AbstractDetector.java @@ -17,6 +17,8 @@ package org.orekit.propagation.events; import org.hipparchus.ode.events.Action; +import org.orekit.errors.OrekitException; +import org.orekit.errors.OrekitMessages; import org.orekit.propagation.SpacecraftState; import org.orekit.propagation.events.handlers.EventHandler; import org.orekit.time.AbsoluteDate; @@ -52,13 +54,15 @@ public abstract class AbstractDetector> implements private boolean forward; /** Build a new instance. - * @param maxCheck maximum checking interval (s) + * @param maxCheck maximum checking interval, must be strictly positive (s) * @param threshold convergence threshold (s) * @param maxIter maximum number of iterations in the event time search * @param handler event handler to call at event occurrences */ protected AbstractDetector(final double maxCheck, final double threshold, final int maxIter, final EventHandler handler) { + checkStrictlyPositive(maxCheck); + checkStrictlyPositive(threshold); this.maxCheck = maxCheck; this.threshold = threshold; this.maxIter = maxIter; @@ -66,6 +70,17 @@ public abstract class AbstractDetector> implements this.forward = true; } + /** Check value is strictly positive. + * @param value value to check + * @exception OrekitException if value is not strictly positive + * @since 11.2 + */ + private void checkStrictlyPositive(final double value) throws OrekitException { + if (value <= 0.0) { + throw new OrekitException(OrekitMessages.NOT_STRICTLY_POSITIVE, value); + } + } + /** * {@inheritDoc} * diff --git a/src/main/java/org/orekit/propagation/events/FieldAbstractDetector.java b/src/main/java/org/orekit/propagation/events/FieldAbstractDetector.java index 6fad8126e20924696913aa220b4aa3207ce401cc..ce66f31b42d98af84dffdb9729db46e0e7bd9be7 100644 --- a/src/main/java/org/orekit/propagation/events/FieldAbstractDetector.java +++ b/src/main/java/org/orekit/propagation/events/FieldAbstractDetector.java @@ -18,6 +18,8 @@ package org.orekit.propagation.events; import org.hipparchus.CalculusFieldElement; import org.hipparchus.ode.events.Action; +import org.orekit.errors.OrekitException; +import org.orekit.errors.OrekitMessages; import org.orekit.propagation.FieldSpacecraftState; import org.orekit.propagation.events.handlers.FieldEventHandler; import org.orekit.time.FieldAbsoluteDate; @@ -61,6 +63,8 @@ public abstract class FieldAbstractDetector, */ protected FieldAbstractDetector(final T maxCheck, final T threshold, final int maxIter, final FieldEventHandler handler) { + checkStrictlyPositive(maxCheck.getReal()); + checkStrictlyPositive(threshold.getReal()); this.maxCheck = maxCheck; this.threshold = threshold; this.maxIter = maxIter; @@ -68,6 +72,17 @@ public abstract class FieldAbstractDetector, this.forward = true; } + /** Check value is strictly positive. + * @param value value to check + * @exception OrekitException if value is not strictly positive + * @since 11.2 + */ + private void checkStrictlyPositive(final double value) throws OrekitException { + if (value <= 0.0) { + throw new OrekitException(OrekitMessages.NOT_STRICTLY_POSITIVE, value); + } + } + /** {@inheritDoc} */ @SuppressWarnings("unchecked") public void init(final FieldSpacecraftState s0, diff --git a/src/main/java/org/orekit/propagation/events/ParameterDrivenDateIntervalDetector.java b/src/main/java/org/orekit/propagation/events/ParameterDrivenDateIntervalDetector.java index 4582d7ade4553d711e78d8ba1f838c46800e51eb..f168fac492f95129774b9202a2731f1e650938ff 100644 --- a/src/main/java/org/orekit/propagation/events/ParameterDrivenDateIntervalDetector.java +++ b/src/main/java/org/orekit/propagation/events/ParameterDrivenDateIntervalDetector.java @@ -58,6 +58,9 @@ public class ParameterDrivenDateIntervalDetector extends AbstractDetector(), new DateDriver(refStart, prefix + START_SUFFIX, true), new DateDriver(refStop, prefix + STOP_SUFFIX, false), diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_da.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_da.utf8 index 5e7090e42445c1adfef22b4dd89166285420fa0d..0a29a76cf4a175b3acc052c5b7909e8d4063e8a6 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_da.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_da.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_de.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_de.utf8 index 9852e80be1d995e16a68b75419ce0ffca94fcb05..319a268f1c1ff0460af4be88145bff4e82ca3730 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_de.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_de.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_el.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_el.utf8 index cda4a6f5a5ae24b074b1d18044aa9af007dc21ea..6781b77dfc226c087deaea9bf3787f392ba8cdba 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_el.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_el.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_en.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_en.utf8 index 9045ec49a8501ecfd30b01b799fa65015cca9b05..4cebfd8ac0a50d33fc86c1657ceb666bbb093f8a 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_en.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_en.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = no station eccentricity values for the given # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = inconsistent parameters selection between pairs {0}/{1} and {2}/{3} + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = value is not strictly positive: {0} diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_es.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_es.utf8 index 6db717206edf7ff13eac3133d6dce614aa53ef54..1933515ddc8eb536bfbd0e76f1ec87115058576f 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_es.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_es.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = ningún valor de excentricidad de la estaci # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = selección de parámetros inconsistente entre los pares {0}/{1} y {2}/{3} + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_fr.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_fr.utf8 index 82c2a175355d6cbd038adba90a703a0419b3b5d6..0cca996888ddc29db449abd43eada23d79bb9887 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_fr.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_fr.utf8 @@ -754,4 +754,7 @@ BACKWARD_PROPAGATION_NOT_ALLOWED = la propagation à rebours n''a pas été auto NO_STATION_ECCENTRICITY_FOR_EPOCH = pas d''excentricité station pour la date {0}, l''intervalle de validité est entre {1} et {2} # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} -INCONSISTENT_SELECTION = sélection de paramètres incohérents entre les paires {0}/{1} et {2}/{3} \ No newline at end of file +INCONSISTENT_SELECTION = sélection de paramètres incohérents entre les paires {0}/{1} et {2}/{3} + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = la valeur {0} n''est pas strictement positive diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_gl.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_gl.utf8 index e79f0b70ec0fa913b4dbb975fd43f65bbd6947a2..85a59898d1c3c74bf3a8138ba05ceff33d5e4b9a 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_gl.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_gl.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_it.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_it.utf8 index 1c7463340ad50622254c55e4de5e6f2dec080146..4ebae1d164a4856f50781b73f24433df83ffa858 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_it.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_it.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = nessun valore di eccentricità stazione per # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = scelta di parametri discordante per le coppie {0}/{1} e {2}/{3} + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_no.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_no.utf8 index 7ebbece1af5656bfd33eeeb64f2303dc10a3807f..a8ec9b3b442db45cc2a8b7b8373c27d2ed4267fa 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_no.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_no.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/main/resources/assets/org/orekit/localization/OrekitMessages_ro.utf8 b/src/main/resources/assets/org/orekit/localization/OrekitMessages_ro.utf8 index b258a6967ad1b28ad4fbf97cf1ae2bebc9c2f4ec..2cff1356ff8ad9c875edeab0ebcad810e83ccaf3 100644 --- a/src/main/resources/assets/org/orekit/localization/OrekitMessages_ro.utf8 +++ b/src/main/resources/assets/org/orekit/localization/OrekitMessages_ro.utf8 @@ -755,3 +755,6 @@ NO_STATION_ECCENTRICITY_FOR_EPOCH = # inconsistent parameters selection between pairs {0}/{1} and {2}/{3} INCONSISTENT_SELECTION = + +# value is not strictly positive: {0} +NOT_STRICTLY_POSITIVE = diff --git a/src/test/java/org/orekit/errors/OrekitMessagesTest.java b/src/test/java/org/orekit/errors/OrekitMessagesTest.java index f4c7ef0b96c079ec10d6b708c473174c5f3770f7..f7d74591143598f13778b4720ae08c02fb0ba769 100644 --- a/src/test/java/org/orekit/errors/OrekitMessagesTest.java +++ b/src/test/java/org/orekit/errors/OrekitMessagesTest.java @@ -30,7 +30,7 @@ public class OrekitMessagesTest { @Test public void testMessageNumber() { - Assert.assertEquals(252, OrekitMessages.values().length); + Assert.assertEquals(253, OrekitMessages.values().length); } @Test diff --git a/src/test/java/org/orekit/forces/maneuvers/ConstantThrustManeuverTest.java b/src/test/java/org/orekit/forces/maneuvers/ConstantThrustManeuverTest.java index 609283d66b6a8cb26c92cfac5d5414532401fbf8..8d609bb2fc6bd5203ec40440e79440d843877465 100644 --- a/src/test/java/org/orekit/forces/maneuvers/ConstantThrustManeuverTest.java +++ b/src/test/java/org/orekit/forces/maneuvers/ConstantThrustManeuverTest.java @@ -28,6 +28,7 @@ import org.hipparchus.geometry.euclidean.threed.FieldRotation; import org.hipparchus.geometry.euclidean.threed.FieldVector3D; import org.hipparchus.geometry.euclidean.threed.Rotation; import org.hipparchus.geometry.euclidean.threed.Vector3D; +import org.hipparchus.ode.ODEIntegrator; import org.hipparchus.ode.nonstiff.AdaptiveStepsizeFieldIntegrator; import org.hipparchus.ode.nonstiff.AdaptiveStepsizeIntegrator; import org.hipparchus.ode.nonstiff.DormandPrince853FieldIntegrator; @@ -68,6 +69,7 @@ import org.orekit.utils.Constants; import org.orekit.utils.FieldPVCoordinates; import org.orekit.utils.PVCoordinates; import org.orekit.utils.ParameterDriver; +import org.orekit.utils.TimeStampedPVCoordinates; public class ConstantThrustManeuverTest extends AbstractLegacyForceModelTest { @@ -794,6 +796,52 @@ public class ConstantThrustManeuverTest extends AbstractLegacyForceModelTest { } + @Test + public void testNullDuration() { + + // Defining initial state + final Frame eme2000 = FramesFactory.getEME2000(); + final AbsoluteDate initialDate = new AbsoluteDate(); + final TimeStampedPVCoordinates initialPV = new TimeStampedPVCoordinates(initialDate, + new Vector3D(6378e3 + 400e3, 0, 0), + new Vector3D(0, 7669, 0)); + final double initialMass = 1000; + final CartesianOrbit cartesianOrbit = new CartesianOrbit(initialPV, eme2000, Constants.EIGEN5C_EARTH_MU); + + // Defining ConstantThrustManeuver with null duration + final AbsoluteDate startManeuverDate = initialDate.shiftedBy(30); + final double duration = 0; // in s + final double thrust = 100; // default value + final double isp = 300; // default value + final Vector3D direction = new Vector3D(1, 0, 0); + final AttitudeProvider attitudeProvider = new LofOffset(eme2000, LOFType.TNW); + + final ConstantThrustManeuver nullDurationManeuver = new ConstantThrustManeuver(startManeuverDate, duration, + thrust, isp, attitudeProvider, direction); + + // Defining propagator + // Default Values + final double dP = 0.001; + final double minStep = 0.1; + final double maxStep = 3600; + + // Defining integrator + final double[][] tolerances = NumericalPropagator.tolerances(dP, cartesianOrbit, OrbitType.CARTESIAN); + final ODEIntegrator integrator = new DormandPrince853Integrator(minStep, maxStep, tolerances[0], + tolerances[1]); + final NumericalPropagator numProp = new NumericalPropagator(integrator); + + // Configuring propagator + numProp.setOrbitType(OrbitType.CARTESIAN); + numProp.setInitialState(new SpacecraftState(cartesianOrbit, initialMass)); + numProp.addForceModel(nullDurationManeuver); + + // Propagation + final SpacecraftState finalState = numProp.propagate(initialDate.shiftedBy(60)); + Assert.assertEquals(cartesianOrbit.getA(), finalState.getA(), 1.0e-15); + + } + @Before public void setUp() { Utils.setDataRoot("regular-data"); diff --git a/src/test/java/org/orekit/forces/maneuvers/triggers/IntervalEventTriggerTest.java b/src/test/java/org/orekit/forces/maneuvers/triggers/IntervalEventTriggerTest.java index b5e2ae9ace9dfed426c06f449f3d7fa32c92afb1..5897e3298d2da0fd3dfe1eac7af44a3ca54824b5 100644 --- a/src/test/java/org/orekit/forces/maneuvers/triggers/IntervalEventTriggerTest.java +++ b/src/test/java/org/orekit/forces/maneuvers/triggers/IntervalEventTriggerTest.java @@ -46,11 +46,12 @@ public class IntervalEventTriggerTest extends AbstractManeuverTriggersTest, S extends CalculusFieldElement> FieldAbstractDetector convertIntervalDetector(Field field, DateDetector detector) { - final S maxCheck = field.getZero().newInstance(detector.getMaxCheckInterval()); + final S maxCheck = field.getZero().newInstance(detector.getMaxCheckInterval()); + final S threshold = field.getZero().newInstance(detector.getThreshold()); final FieldAbsoluteDate d0 = new FieldAbsoluteDate<>(field, detector.getDates().get(0).getDate()); final FieldAbsoluteDate d1 = new FieldAbsoluteDate<>(field, detector.getDates().get(1).getDate()); @SuppressWarnings("unchecked") - final FieldAbstractDetector converted = (FieldAbstractDetector) new FieldDateDetector<>(maxCheck, null, d0, d1); + final FieldAbstractDetector converted = (FieldAbstractDetector) new FieldDateDetector<>(maxCheck, threshold, d0, d1); return converted; } diff --git a/src/test/java/org/orekit/propagation/events/AndDetectorTest.java b/src/test/java/org/orekit/propagation/events/AndDetectorTest.java index 843ee8d2473973dd1f30132292766c2b98dd8cb9..0ed492fc044f04a83bfc139f27cfee233d733a49 100644 --- a/src/test/java/org/orekit/propagation/events/AndDetectorTest.java +++ b/src/test/java/org/orekit/propagation/events/AndDetectorTest.java @@ -120,7 +120,11 @@ public class AndDetectorTest { public void testInit() { // setup EventDetector a = Mockito.mock(EventDetector.class); + Mockito.when(a.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(a.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); EventDetector b = Mockito.mock(EventDetector.class); + Mockito.when(b.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(b.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); @SuppressWarnings("unchecked") EventHandler c = Mockito.mock(EventHandler.class); BooleanDetector and = BooleanDetector.andCombine(a, b).withHandler(c); @@ -168,12 +172,12 @@ public class AndDetectorTest { @Override public double getThreshold() { - return 0; + return AbstractDetector.DEFAULT_THRESHOLD; } @Override public double getMaxCheckInterval() { - return 0; + return AbstractDetector.DEFAULT_MAXCHECK; } @Override diff --git a/src/test/java/org/orekit/propagation/events/EventDetectorTest.java b/src/test/java/org/orekit/propagation/events/EventDetectorTest.java index 27c42fc9ca0419284a1d6e2e0ddccfa87541660b..a1ad3fedebd740cbdbe66ee293520529fe04284a 100644 --- a/src/test/java/org/orekit/propagation/events/EventDetectorTest.java +++ b/src/test/java/org/orekit/propagation/events/EventDetectorTest.java @@ -33,6 +33,7 @@ import org.junit.Before; import org.junit.Test; import org.orekit.Utils; import org.orekit.errors.OrekitException; +import org.orekit.errors.OrekitMessages; import org.orekit.frames.Frame; import org.orekit.frames.FramesFactory; import org.orekit.orbits.CircularOrbit; @@ -375,6 +376,17 @@ public class EventDetectorTest { } + @Test + public void testWrongConfiguration() { + try { + new DateDetector(-1.0, 1.0e-6, AbsoluteDate.ARBITRARY_EPOCH); + Assert.fail("an exception should have been thrown"); + } catch (OrekitException oe) { + Assert.assertEquals(OrekitMessages.NOT_STRICTLY_POSITIVE, oe.getSpecifier()); + Assert.assertEquals(-1.0, ((Double) oe.getParts()[0]).doubleValue(), 1.0e-15); + } + } + @Test public void testForwardAnalytical() { doTestScheduling(0.0, 1.0, 21, this::buildAnalytical); diff --git a/src/test/java/org/orekit/propagation/events/FieldEventDetectorTest.java b/src/test/java/org/orekit/propagation/events/FieldEventDetectorTest.java index 7c4f5238aab38eae8fdb6dcb675b42711be1d177..25169f02db39cd2cb507f4cfb4a8b52dfaef35ba 100644 --- a/src/test/java/org/orekit/propagation/events/FieldEventDetectorTest.java +++ b/src/test/java/org/orekit/propagation/events/FieldEventDetectorTest.java @@ -37,6 +37,7 @@ import org.junit.Before; import org.junit.Test; import org.orekit.Utils; import org.orekit.errors.OrekitException; +import org.orekit.errors.OrekitMessages; import org.orekit.frames.Frame; import org.orekit.frames.FramesFactory; import org.orekit.orbits.FieldCircularOrbit; @@ -434,6 +435,23 @@ public class FieldEventDetectorTest { } + @Test + public void testWrongConfiguration() { + doTestWrongConfiguration(Decimal64Field.getInstance()); + } + + private > void doTestWrongConfiguration(final Field field) { + try { + new FieldDateDetector<>(field.getZero().newInstance(-1.0), + field.getZero().newInstance(1.0e-6), + FieldAbsoluteDate.getArbitraryEpoch(field)); + Assert.fail("an exception should have been thrown"); + } catch (OrekitException oe) { + Assert.assertEquals(OrekitMessages.NOT_STRICTLY_POSITIVE, oe.getSpecifier()); + Assert.assertEquals(-1.0, ((Double) oe.getParts()[0]).doubleValue(), 1.0e-15); + } + } + @Test public void testForwardAnalytical() { doTestScheduling(Decimal64Field.getInstance(), 0.0, 1.0, 21, this::buildAnalytical); diff --git a/src/test/java/org/orekit/propagation/events/NegateDetectorTest.java b/src/test/java/org/orekit/propagation/events/NegateDetectorTest.java index 4dcba3fe6a45884ea93e1bc0a9ca3ab9a19a9395..63537e8eb808e050e981c973c4f9bb2d801dfb04 100644 --- a/src/test/java/org/orekit/propagation/events/NegateDetectorTest.java +++ b/src/test/java/org/orekit/propagation/events/NegateDetectorTest.java @@ -39,6 +39,8 @@ public class NegateDetectorTest { public void testInit() { //setup EventDetector a = Mockito.mock(EventDetector.class); + Mockito.when(a.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(a.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); @SuppressWarnings("unchecked") EventHandler c = Mockito.mock(EventHandler.class); NegateDetector detector = new NegateDetector(a).withHandler(c); @@ -61,6 +63,8 @@ public class NegateDetectorTest { public void testG() { //setup EventDetector a = Mockito.mock(EventDetector.class); + Mockito.when(a.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(a.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); NegateDetector detector = new NegateDetector(a); SpacecraftState s = Mockito.mock(SpacecraftState.class); @@ -77,6 +81,8 @@ public class NegateDetectorTest { public void testCreate() { //setup EventDetector a = Mockito.mock(EventDetector.class); + Mockito.when(a.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(a.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); NegateDetector detector = new NegateDetector(a); // action diff --git a/src/test/java/org/orekit/propagation/events/OrDetectorTest.java b/src/test/java/org/orekit/propagation/events/OrDetectorTest.java index bc95cbf941334f2fd689b56eb2961216d8c41f72..ce54b305ef221d8b0594a14652c1006f7a1a9fb7 100644 --- a/src/test/java/org/orekit/propagation/events/OrDetectorTest.java +++ b/src/test/java/org/orekit/propagation/events/OrDetectorTest.java @@ -124,7 +124,11 @@ public class OrDetectorTest { public void testInit() { // setup EventDetector a = Mockito.mock(EventDetector.class); + Mockito.when(a.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(a.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); EventDetector b = Mockito.mock(EventDetector.class); + Mockito.when(b.getMaxCheckInterval()).thenReturn(AbstractDetector.DEFAULT_MAXCHECK); + Mockito.when(b.getThreshold()).thenReturn(AbstractDetector.DEFAULT_THRESHOLD); @SuppressWarnings("unchecked") EventHandler c = Mockito.mock(EventHandler.class); BooleanDetector or = BooleanDetector.orCombine(a, b).withHandler(c); @@ -172,12 +176,12 @@ public class OrDetectorTest { @Override public double getThreshold() { - return 0; + return AbstractDetector.DEFAULT_THRESHOLD; } @Override public double getMaxCheckInterval() { - return 0; + return AbstractDetector.DEFAULT_MAXCHECK; } @Override diff --git a/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java b/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java index 26c276d71ccd2ebc3227ff6559f91162558843c4..161929dcfe3ae26b8d30d7fdc7ae4612c5821835 100644 --- a/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java +++ b/src/test/java/org/orekit/propagation/numerical/StateTransitionMatrixGeneratorTest.java @@ -167,7 +167,7 @@ public class StateTransitionMatrixGeneratorTest { // after completing the two-stage propagation, we get the same matrices Assert.assertEquals(0.0, stm2.subtract(stm1).getNorm1(), 1.3e-13 * stm1.getNorm1()); - Assert.assertEquals(0.0, jacobian2.subtract(jacobian1).getNorm1(), 3.0e-14 * jacobian1.getNorm1()); + Assert.assertEquals(0.0, jacobian2.subtract(jacobian1).getNorm1(), 7.0e-11 * jacobian1.getNorm1()); }