Search in sources :

Example 6 with OrekitFixedStepHandler

use of org.orekit.propagation.sampling.OrekitFixedStepHandler in project Orekit by CS-SI.

the class TabulatedProviderTest method createSample.

private List<TimeStampedAngularCoordinates> createSample(double samplingRate, AttitudeProvider referenceProvider) throws OrekitException {
    // reference propagator, using a yaw compensation law
    final KeplerianPropagator referencePropagator = new KeplerianPropagator(circOrbit);
    referencePropagator.setAttitudeProvider(referenceProvider);
    // create sample
    final List<TimeStampedAngularCoordinates> sample = new ArrayList<TimeStampedAngularCoordinates>();
    referencePropagator.setMasterMode(samplingRate, new OrekitFixedStepHandler() {

        public void handleStep(SpacecraftState currentState, boolean isLast) {
            sample.add(currentState.getAttitude().getOrientation());
        }
    });
    referencePropagator.propagate(circOrbit.getDate().shiftedBy(2 * circOrbit.getKeplerianPeriod()));
    return sample;
}
Also used : KeplerianPropagator(org.orekit.propagation.analytical.KeplerianPropagator) FieldSpacecraftState(org.orekit.propagation.FieldSpacecraftState) SpacecraftState(org.orekit.propagation.SpacecraftState) ArrayList(java.util.ArrayList) OrekitFixedStepHandler(org.orekit.propagation.sampling.OrekitFixedStepHandler) TimeStampedAngularCoordinates(org.orekit.utils.TimeStampedAngularCoordinates)

Example 7 with OrekitFixedStepHandler

use of org.orekit.propagation.sampling.OrekitFixedStepHandler in project Orekit by CS-SI.

the class EventDetectorTest method testIssue108Analytical.

@Test
public void testIssue108Analytical() throws OrekitException {
    final TimeScale utc = TimeScalesFactory.getUTC();
    final Vector3D position = new Vector3D(-6142438.668, 3492467.56, -25767.257);
    final Vector3D velocity = new Vector3D(505.848, 942.781, 7435.922);
    final AbsoluteDate date = new AbsoluteDate(2003, 9, 16, utc);
    final Orbit orbit = new CircularOrbit(new PVCoordinates(position, velocity), FramesFactory.getEME2000(), date, mu);
    final double step = 60.0;
    final int n = 100;
    KeplerianPropagator propagator = new KeplerianPropagator(orbit);
    GCallsCounter counter = new GCallsCounter(100000.0, 1.0e-6, 20, new StopOnEvent<GCallsCounter>());
    propagator.addEventDetector(counter);
    propagator.setMasterMode(step, new OrekitFixedStepHandler() {

        public void handleStep(SpacecraftState currentState, boolean isLast) {
        }
    });
    propagator.propagate(date.shiftedBy(n * step));
    Assert.assertEquals(n + 1, counter.getCount());
}
Also used : Orbit(org.orekit.orbits.Orbit) EquinoctialOrbit(org.orekit.orbits.EquinoctialOrbit) CircularOrbit(org.orekit.orbits.CircularOrbit) KeplerianOrbit(org.orekit.orbits.KeplerianOrbit) PVCoordinates(org.orekit.utils.PVCoordinates) TimeScale(org.orekit.time.TimeScale) AbsoluteDate(org.orekit.time.AbsoluteDate) KeplerianPropagator(org.orekit.propagation.analytical.KeplerianPropagator) SpacecraftState(org.orekit.propagation.SpacecraftState) CircularOrbit(org.orekit.orbits.CircularOrbit) Vector3D(org.hipparchus.geometry.euclidean.threed.Vector3D) OrekitFixedStepHandler(org.orekit.propagation.sampling.OrekitFixedStepHandler) Test(org.junit.Test)

Example 8 with OrekitFixedStepHandler

use of org.orekit.propagation.sampling.OrekitFixedStepHandler in project Orekit by CS-SI.

the class EventSlopeFilterTest method testReplayBackward.

@Test
public void testReplayBackward() throws OrekitException {
    EclipseDetector detector = new EclipseDetector(60., 1.e-3, CelestialBodyFactory.getSun(), sunRadius, CelestialBodyFactory.getEarth(), earthRadius).withPenumbra().withHandler(new Counter());
    final EventSlopeFilter<EclipseDetector> filter = new EventSlopeFilter<EclipseDetector>(detector, FilterType.TRIGGER_ONLY_DECREASING_EVENTS).withMaxIter(200);
    Assert.assertEquals(200, filter.getMaxIterationCount());
    propagator.clearEventsDetectors();
    propagator.addEventDetector(filter);
    propagator.propagate(iniDate.shiftedBy(7 * Constants.JULIAN_DAY), iniDate);
    Assert.assertEquals(0, ((Counter) detector.getHandler()).getIncreasingCounter());
    Assert.assertEquals(102, ((Counter) detector.getHandler()).getDecreasingCounter());
    ((Counter) detector.getHandler()).reset();
    propagator.clearEventsDetectors();
    propagator.setMasterMode(10.0, new OrekitFixedStepHandler() {

        @Override
        public void handleStep(SpacecraftState currentState, boolean isLast) throws OrekitException {
            // we exceed the events history in the past,
            // and in this example get stuck with Transformer.MIN
            // transformer, hence the g function is always negative
            // in the test range
            Assert.assertTrue(filter.g(currentState) < 0);
        }
    });
    propagator.propagate(iniDate.shiftedBy(7 * Constants.JULIAN_DAY + 3600), iniDate.shiftedBy(6 * Constants.JULIAN_DAY + 3600));
}
Also used : SpacecraftState(org.orekit.propagation.SpacecraftState) OrekitException(org.orekit.errors.OrekitException) OrekitFixedStepHandler(org.orekit.propagation.sampling.OrekitFixedStepHandler) Test(org.junit.Test)

Example 9 with OrekitFixedStepHandler

use of org.orekit.propagation.sampling.OrekitFixedStepHandler in project Orekit by CS-SI.

the class JacobianPropagatorConverterTest method doTestDerivatives.

private void doTestDerivatives(double tolP, double tolV, String... names) throws OrekitException {
    // we use a fixed step integrator on purpose
    // as the test is based on external differentiation using finite differences,
    // an adaptive step size integrator would introduce *lots* of numerical noise
    NumericalPropagatorBuilder builder = new NumericalPropagatorBuilder(OrbitType.CARTESIAN.convertType(orbit), new LutherIntegratorBuilder(10.0), PositionAngle.TRUE, dP);
    builder.setMass(200.0);
    builder.addForceModel(drag);
    builder.addForceModel(gravity);
    // retrieve a state slightly different from the initial state,
    // using normalized values different from 0.0 for the sake of generality
    RandomGenerator random = new Well19937a(0xe67f19c1a678d037l);
    List<ParameterDriver> all = new ArrayList<ParameterDriver>();
    for (final ParameterDriver driver : builder.getOrbitalParametersDrivers().getDrivers()) {
        all.add(driver);
    }
    for (final ParameterDriver driver : builder.getPropagationParametersDrivers().getDrivers()) {
        all.add(driver);
    }
    double[] normalized = new double[names.length];
    List<ParameterDriver> selected = new ArrayList<ParameterDriver>(names.length);
    int index = 0;
    for (final ParameterDriver driver : all) {
        boolean found = false;
        for (final String name : names) {
            if (name.equals(driver.getName())) {
                found = true;
                normalized[index++] = driver.getNormalizedValue() + (2 * random.nextDouble() - 1);
                selected.add(driver);
            }
        }
        driver.setSelected(found);
    }
    // create a one hour sample that starts 10 minutes after initial state
    // the 10 minutes offset implies even the first point is influenced by model parameters
    final List<SpacecraftState> sample = new ArrayList<SpacecraftState>();
    Propagator propagator = builder.buildPropagator(normalized);
    propagator.setMasterMode(60.0, new OrekitFixedStepHandler() {

        @Override
        public void handleStep(SpacecraftState currentState, boolean isLast) {
            sample.add(currentState);
        }
    });
    propagator.propagate(orbit.getDate().shiftedBy(600.0), orbit.getDate().shiftedBy(4200.0));
    JacobianPropagatorConverter fitter = new JacobianPropagatorConverter(builder, 1.0e-3, 5000);
    try {
        Method setSample = AbstractPropagatorConverter.class.getDeclaredMethod("setSample", List.class);
        setSample.setAccessible(true);
        setSample.invoke(fitter, sample);
    } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
        Assert.fail(e.getLocalizedMessage());
    }
    MultivariateVectorFunction f = fitter.getObjectiveFunction();
    Pair<RealVector, RealMatrix> p = fitter.getModel().value(new ArrayRealVector(normalized));
    // check derivatives
    // a h offset on normalized parameter represents a physical offset of h * scale
    RealMatrix m = p.getSecond();
    double h = 10.0;
    double[] shifted = normalized.clone();
    double maxErrorP = 0;
    double maxErrorV = 0;
    for (int j = 0; j < selected.size(); ++j) {
        shifted[j] = normalized[j] + 2.0 * h;
        double[] valueP2 = f.value(shifted);
        shifted[j] = normalized[j] + 1.0 * h;
        double[] valueP1 = f.value(shifted);
        shifted[j] = normalized[j] - 1.0 * h;
        double[] valueM1 = f.value(shifted);
        shifted[j] = normalized[j] - 2.0 * h;
        double[] valueM2 = f.value(shifted);
        shifted[j] = normalized[j];
        for (int i = 0; i < valueP2.length; ++i) {
            double d = (8 * (valueP1[i] - valueM1[i]) - (valueP2[i] - valueM2[i])) / (12 * h);
            if (i % 6 < 3) {
                // position
                maxErrorP = FastMath.max(maxErrorP, FastMath.abs(m.getEntry(i, j) - d));
            } else {
                // velocity
                maxErrorV = FastMath.max(maxErrorV, FastMath.abs(m.getEntry(i, j) - d));
            }
        }
    }
    Assert.assertEquals(0.0, maxErrorP, tolP);
    Assert.assertEquals(0.0, maxErrorV, tolV);
}
Also used : ArrayList(java.util.ArrayList) Well19937a(org.hipparchus.random.Well19937a) RandomGenerator(org.hipparchus.random.RandomGenerator) SpacecraftState(org.orekit.propagation.SpacecraftState) ArrayRealVector(org.hipparchus.linear.ArrayRealVector) RealVector(org.hipparchus.linear.RealVector) Propagator(org.orekit.propagation.Propagator) OrekitFixedStepHandler(org.orekit.propagation.sampling.OrekitFixedStepHandler) MathIllegalArgumentException(org.hipparchus.exception.MathIllegalArgumentException) ArrayRealVector(org.hipparchus.linear.ArrayRealVector) Method(java.lang.reflect.Method) ParameterDriver(org.orekit.utils.ParameterDriver) MultivariateVectorFunction(org.hipparchus.analysis.MultivariateVectorFunction) InvocationTargetException(java.lang.reflect.InvocationTargetException) RealMatrix(org.hipparchus.linear.RealMatrix)

Example 10 with OrekitFixedStepHandler

use of org.orekit.propagation.sampling.OrekitFixedStepHandler in project Orekit by CS-SI.

the class AttitudesSequenceTest method testDayNightSwitch.

@Test
public void testDayNightSwitch() throws OrekitException {
    // Initial state definition : date, orbit
    final AbsoluteDate initialDate = new AbsoluteDate(2004, 01, 01, 23, 30, 00.000, TimeScalesFactory.getUTC());
    final Vector3D position = new Vector3D(-6142438.668, 3492467.560, -25767.25680);
    final Vector3D velocity = new Vector3D(505.8479685, 942.7809215, 7435.922231);
    final Orbit initialOrbit = new KeplerianOrbit(new PVCoordinates(position, velocity), FramesFactory.getEME2000(), initialDate, Constants.EIGEN5C_EARTH_MU);
    final EventsLogger // Attitudes sequence definition
    logger = new EventsLogger();
    final AttitudesSequence attitudesSequence = new AttitudesSequence();
    final AttitudeProvider dayObservationLaw = new LofOffset(initialOrbit.getFrame(), LOFType.VVLH, RotationOrder.XYZ, FastMath.toRadians(20), FastMath.toRadians(40), 0);
    final AttitudeProvider nightRestingLaw = new LofOffset(initialOrbit.getFrame(), LOFType.VVLH);
    final PVCoordinatesProvider sun = CelestialBodyFactory.getSun();
    final PVCoordinatesProvider earth = CelestialBodyFactory.getEarth();
    final EclipseDetector ed = new EclipseDetector(sun, 696000000., earth, Constants.WGS84_EARTH_EQUATORIAL_RADIUS).withHandler(new ContinueOnEvent<EclipseDetector>() {

        private static final long serialVersionUID = 1L;

        public EventHandler.Action eventOccurred(final SpacecraftState s, final EclipseDetector d, final boolean increasing) {
            setInEclipse(s.getDate(), !increasing);
            return EventHandler.Action.RESET_STATE;
        }
    });
    final EventDetector monitored = logger.monitorDetector(ed);
    final Handler dayToNightHandler = new Handler(dayObservationLaw, nightRestingLaw);
    final Handler nightToDayHandler = new Handler(nightRestingLaw, dayObservationLaw);
    attitudesSequence.addSwitchingCondition(dayObservationLaw, nightRestingLaw, monitored, false, true, 300.0, AngularDerivativesFilter.USE_RRA, dayToNightHandler);
    attitudesSequence.addSwitchingCondition(nightRestingLaw, dayObservationLaw, monitored, true, false, 300.0, AngularDerivativesFilter.USE_RRA, nightToDayHandler);
    SpacecraftState initialState = new SpacecraftState(initialOrbit);
    initialState = initialState.addAdditionalState("fortyTwo", 42.0);
    if (ed.g(initialState) >= 0) {
        // initial position is in daytime
        setInEclipse(initialDate, false);
        attitudesSequence.resetActiveProvider(dayObservationLaw);
    } else {
        // initial position is in nighttime
        setInEclipse(initialDate, true);
        attitudesSequence.resetActiveProvider(nightRestingLaw);
    }
    // Propagator : consider the analytical Eckstein-Hechler model
    final Propagator propagator = new EcksteinHechlerPropagator(initialOrbit, attitudesSequence, Constants.EIGEN5C_EARTH_EQUATORIAL_RADIUS, Constants.EIGEN5C_EARTH_MU, Constants.EIGEN5C_EARTH_C20, Constants.EIGEN5C_EARTH_C30, Constants.EIGEN5C_EARTH_C40, Constants.EIGEN5C_EARTH_C50, Constants.EIGEN5C_EARTH_C60);
    // Register the switching events to the propagator
    attitudesSequence.registerSwitchEvents(propagator);
    propagator.setMasterMode(60.0, new OrekitFixedStepHandler() {

        public void handleStep(SpacecraftState currentState, boolean isLast) throws OrekitException {
            // the Earth position in spacecraft frame should be along spacecraft Z axis
            // during night time and away from it during day time due to roll and pitch offsets
            final Vector3D earth = currentState.toTransform().transformPosition(Vector3D.ZERO);
            final double pointingOffset = Vector3D.angle(earth, Vector3D.PLUS_K);
            // the g function is the eclipse indicator, its an angle between Sun and Earth limb,
            // positive when Sun is outside of Earth limb, negative when Sun is hidden by Earth limb
            final double eclipseAngle = ed.g(currentState);
            if (currentState.getDate().durationFrom(lastChange) > 300) {
                if (inEclipse) {
                    Assert.assertTrue(eclipseAngle <= 0);
                    Assert.assertEquals(0.0, pointingOffset, 1.0e-6);
                } else {
                    Assert.assertTrue(eclipseAngle >= 0);
                    Assert.assertEquals(0.767215, pointingOffset, 1.0e-6);
                }
            } else {
                // we are in transition
                Assert.assertTrue(pointingOffset + " " + (0.767215 - pointingOffset), pointingOffset <= 0.7672155);
            }
        }
    });
    // Propagate from the initial date for the fixed duration
    propagator.propagate(initialDate.shiftedBy(12600.));
    // as we have 2 switch events (even if they share the same underlying event detector),
    // and these events are triggered at both eclipse entry and exit, we get 8
    // raw events on 2 orbits
    Assert.assertEquals(8, logger.getLoggedEvents().size());
    // we have 4 attitudes switch on 2 orbits, 2 of each type
    Assert.assertEquals(2, dayToNightHandler.dates.size());
    Assert.assertEquals(2, nightToDayHandler.dates.size());
}
Also used : EclipseDetector(org.orekit.propagation.events.EclipseDetector) FieldOrbit(org.orekit.orbits.FieldOrbit) FieldKeplerianOrbit(org.orekit.orbits.FieldKeplerianOrbit) KeplerianOrbit(org.orekit.orbits.KeplerianOrbit) Orbit(org.orekit.orbits.Orbit) PVCoordinates(org.orekit.utils.PVCoordinates) FieldPVCoordinates(org.orekit.utils.FieldPVCoordinates) FieldOrekitFixedStepHandler(org.orekit.propagation.sampling.FieldOrekitFixedStepHandler) OrekitFixedStepHandler(org.orekit.propagation.sampling.OrekitFixedStepHandler) EventHandler(org.orekit.propagation.events.handlers.EventHandler) FieldAbsoluteDate(org.orekit.time.FieldAbsoluteDate) AbsoluteDate(org.orekit.time.AbsoluteDate) SpacecraftState(org.orekit.propagation.SpacecraftState) FieldSpacecraftState(org.orekit.propagation.FieldSpacecraftState) FieldEcksteinHechlerPropagator(org.orekit.propagation.analytical.FieldEcksteinHechlerPropagator) EcksteinHechlerPropagator(org.orekit.propagation.analytical.EcksteinHechlerPropagator) EventDetector(org.orekit.propagation.events.EventDetector) FieldVector3D(org.hipparchus.geometry.euclidean.threed.FieldVector3D) Vector3D(org.hipparchus.geometry.euclidean.threed.Vector3D) EventsLogger(org.orekit.propagation.events.EventsLogger) Propagator(org.orekit.propagation.Propagator) NumericalPropagator(org.orekit.propagation.numerical.NumericalPropagator) FieldEcksteinHechlerPropagator(org.orekit.propagation.analytical.FieldEcksteinHechlerPropagator) EcksteinHechlerPropagator(org.orekit.propagation.analytical.EcksteinHechlerPropagator) FieldPropagator(org.orekit.propagation.FieldPropagator) PVCoordinatesProvider(org.orekit.utils.PVCoordinatesProvider) FieldKeplerianOrbit(org.orekit.orbits.FieldKeplerianOrbit) KeplerianOrbit(org.orekit.orbits.KeplerianOrbit) OrekitException(org.orekit.errors.OrekitException) FieldOrekitFixedStepHandler(org.orekit.propagation.sampling.FieldOrekitFixedStepHandler) OrekitFixedStepHandler(org.orekit.propagation.sampling.OrekitFixedStepHandler) Test(org.junit.Test)

Aggregations

SpacecraftState (org.orekit.propagation.SpacecraftState)16 OrekitFixedStepHandler (org.orekit.propagation.sampling.OrekitFixedStepHandler)16 Test (org.junit.Test)11 AbsoluteDate (org.orekit.time.AbsoluteDate)11 OrekitException (org.orekit.errors.OrekitException)10 Vector3D (org.hipparchus.geometry.euclidean.threed.Vector3D)8 Propagator (org.orekit.propagation.Propagator)7 FieldAbsoluteDate (org.orekit.time.FieldAbsoluteDate)7 KeplerianOrbit (org.orekit.orbits.KeplerianOrbit)6 FieldSpacecraftState (org.orekit.propagation.FieldSpacecraftState)6 Frame (org.orekit.frames.Frame)5 CircularOrbit (org.orekit.orbits.CircularOrbit)5 Orbit (org.orekit.orbits.Orbit)5 BoundedPropagator (org.orekit.propagation.BoundedPropagator)5 KeplerianPropagator (org.orekit.propagation.analytical.KeplerianPropagator)5 ByteArrayInputStream (java.io.ByteArrayInputStream)4 ByteArrayOutputStream (java.io.ByteArrayOutputStream)4 ObjectInputStream (java.io.ObjectInputStream)4 ObjectOutputStream (java.io.ObjectOutputStream)4 ArrayList (java.util.ArrayList)4