Examples with DerivativeStructure org.hipparchus.analysis.differentiation.DerivativeStructure used on opensource projects

Example 31 with DerivativeStructure

use of org.hipparchus.analysis.differentiation.DerivativeStructure in project Orekit by CS-SI.

the class TimeStampedFieldPVCoordinatesTest method testLinearConstructors.

@Test
public void testLinearConstructors() {
    DSFactory factory = new DSFactory(6, 1);
    TimeStampedFieldPVCoordinates<DerivativeStructure> pv1 = new TimeStampedFieldPVCoordinates<>(AbsoluteDate.CCSDS_EPOCH, createVector(1, 0.1, 10, 6), createVector(-1, -0.1, -10, 6), createVector(10, 1.0, 100, 6));
    TimeStampedFieldPVCoordinates<DerivativeStructure> pv2 = new TimeStampedFieldPVCoordinates<>(AbsoluteDate.FIFTIES_EPOCH, createVector(2, 0.2, 20, 6), createVector(-2, -0.2, -20, 6), createVector(20, 2.0, 200, 6));
    TimeStampedFieldPVCoordinates<DerivativeStructure> pv3 = new TimeStampedFieldPVCoordinates<>(AbsoluteDate.GALILEO_EPOCH, createVector(3, 0.3, 30, 6), createVector(-3, -0.3, -30, 6), createVector(30, 3.0, 300, 6));
    TimeStampedFieldPVCoordinates<DerivativeStructure> pv4 = new TimeStampedFieldPVCoordinates<>(AbsoluteDate.JULIAN_EPOCH, createVector(4, 0.4, 40, 6), createVector(-4, -0.4, -40, 6), createVector(40, 4.0, 400, 6));
    checkPV(pv4, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.JULIAN_EPOCH, 4, pv1), 1.0e-15);
    checkPV(pv4, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.JULIAN_EPOCH, factory.constant(4), pv1), 1.0e-15);
    checkPV(pv4, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.JULIAN_EPOCH, factory.constant(4), pv1.toPVCoordinates()), 1.0e-15);
    checkPV(pv2, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.FIFTIES_EPOCH, pv1, pv3), 1.0e-15);
    checkPV(pv3, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.GALILEO_EPOCH, 1, pv1, 1, pv2), 1.0e-15);
    checkPV(pv3, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.GALILEO_EPOCH, factory.constant(1), pv1, factory.constant(1), pv2), 1.0e-15);
    checkPV(pv3, new TimeStampedFieldPVCoordinates<>(AbsoluteDate.GALILEO_EPOCH, factory.constant(1), pv1.toPVCoordinates(), factory.constant(1), pv2.toPVCoordinates()), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 2, pv4), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 3, pv1, 1, pv2, 1, pv3), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 3, pv3), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 3, pv1, 1, pv2, 1, pv4), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 3, pv3), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, factory.constant(3), pv1, factory.constant(1), pv2, factory.constant(1), pv4), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 3, pv3), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, factory.constant(3), pv1.toPVCoordinates(), factory.constant(1), pv2.toPVCoordinates(), factory.constant(1), pv4.toPVCoordinates()), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 5, pv4), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 4, pv1, 3, pv2, 2, pv3, 1, pv4), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 5, pv4), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, factory.constant(4), pv1, factory.constant(3), pv2, factory.constant(2), pv3, factory.constant(1), pv4), 1.0e-15);
    checkPV(new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, 5, pv4), new TimeStampedFieldPVCoordinates<>(AbsoluteDate.J2000_EPOCH, factory.constant(4), pv1.toPVCoordinates(), factory.constant(3), pv2.toPVCoordinates(), factory.constant(2), pv3.toPVCoordinates(), factory.constant(1), pv4.toPVCoordinates()), 1.0e-15);
}

Example 32 with DerivativeStructure

use of org.hipparchus.analysis.differentiation.DerivativeStructure in project Orekit by CS-SI.

the class FieldPVCoordinatesTest method testGetMomentum.

@Test
public void testGetMomentum() {
    // setup
    DSFactory factory = new DSFactory(1, 1);
    DerivativeStructure oneDS = factory.getDerivativeField().getOne();
    DerivativeStructure zeroDS = factory.getDerivativeField().getZero();
    FieldVector3D<DerivativeStructure> zero = new FieldVector3D<>(zeroDS, zeroDS, zeroDS);
    FieldVector3D<DerivativeStructure> i = new FieldVector3D<>(oneDS, zeroDS, zeroDS);
    FieldVector3D<DerivativeStructure> j = new FieldVector3D<>(zeroDS, oneDS, zeroDS);
    FieldVector3D<DerivativeStructure> k = new FieldVector3D<>(zeroDS, zeroDS, oneDS);
    FieldVector3D<DerivativeStructure> p = new FieldVector3D<>(oneDS, factory.constant(-2), factory.constant(3));
    FieldVector3D<DerivativeStructure> v = new FieldVector3D<>(factory.constant(-9), factory.constant(8), factory.constant(-7));
    // action + verify
    Assert.assertEquals(new FieldPVCoordinates<>(p, v).getMomentum(), p.crossProduct(v));
    // check simple cases
    Assert.assertEquals(new FieldPVCoordinates<>(i, i.scalarMultiply(-1)).getMomentum(), zero);
    Assert.assertEquals(new FieldPVCoordinates<>(i, j).getMomentum(), k);
}

Example 33 with DerivativeStructure

use of org.hipparchus.analysis.differentiation.DerivativeStructure in project Orekit by CS-SI.

the class FieldPVCoordinatesTest method testLinearConstructors.

@Test
public void testLinearConstructors() {
    DSFactory factory = new DSFactory(6, 1);
    FieldPVCoordinates<DerivativeStructure> pv1 = new FieldPVCoordinates<>(createVector(1, 0.1, 10, 6), createVector(-1, -0.1, -10, 6));
    FieldPVCoordinates<DerivativeStructure> pv2 = new FieldPVCoordinates<>(createVector(2, 0.2, 20, 6), createVector(-2, -0.2, -20, 6));
    FieldPVCoordinates<DerivativeStructure> pv3 = new FieldPVCoordinates<>(createVector(3, 0.3, 30, 6), createVector(-3, -0.3, -30, 6));
    FieldPVCoordinates<DerivativeStructure> pv4 = new FieldPVCoordinates<>(createVector(4, 0.4, 40, 6), createVector(-4, -0.4, -40, 6));
    checkPV(pv4, new FieldPVCoordinates<>(4, pv1), 1.0e-15);
    checkPV(pv4, new FieldPVCoordinates<>(factory.constant(4), pv1), 1.0e-15);
    checkPV(pv4, new FieldPVCoordinates<>(factory.constant(4), pv1.toPVCoordinates()), 1.0e-15);
    checkPV(pv2, new FieldPVCoordinates<>(pv1, pv3), 1.0e-15);
    checkPV(pv3, new FieldPVCoordinates<>(1, pv1, 1, pv2), 1.0e-15);
    checkPV(pv3, new FieldPVCoordinates<>(factory.constant(1), pv1, factory.constant(1), pv2), 1.0e-15);
    checkPV(pv3, new FieldPVCoordinates<>(factory.constant(1), pv1.toPVCoordinates(), factory.constant(1), pv2.toPVCoordinates()), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(2, pv4), new FieldPVCoordinates<>(3, pv1, 1, pv2, 1, pv3), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(3, pv3), new FieldPVCoordinates<>(3, pv1, 1, pv2, 1, pv4), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(3, pv3), new FieldPVCoordinates<>(factory.constant(3), pv1, factory.constant(1), pv2, factory.constant(1), pv4), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(3, pv3), new FieldPVCoordinates<>(factory.constant(3), pv1.toPVCoordinates(), factory.constant(1), pv2.toPVCoordinates(), factory.constant(1), pv4.toPVCoordinates()), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(5, pv4), new FieldPVCoordinates<>(4, pv1, 3, pv2, 2, pv3, 1, pv4), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(5, pv4), new FieldPVCoordinates<>(factory.constant(4), pv1, factory.constant(3), pv2, factory.constant(2), pv3, factory.constant(1), pv4), 1.0e-15);
    checkPV(new FieldPVCoordinates<>(5, pv4), new FieldPVCoordinates<>(factory.constant(4), pv1.toPVCoordinates(), factory.constant(3), pv2.toPVCoordinates(), factory.constant(2), pv3.toPVCoordinates(), factory.constant(1), pv4.toPVCoordinates()), 1.0e-15);
}

Example 34 with DerivativeStructure

use of org.hipparchus.analysis.differentiation.DerivativeStructure in project Orekit by CS-SI.

the class FieldPVCoordinatesTest method testGetAngularVelocity.

@Test
public void testGetAngularVelocity() {
    // setup
    DSFactory factory = new DSFactory(1, 1);
    DerivativeStructure oneDS = factory.getDerivativeField().getOne();
    DerivativeStructure zeroDS = factory.getDerivativeField().getZero();
    FieldVector3D<DerivativeStructure> zero = new FieldVector3D<>(zeroDS, zeroDS, zeroDS);
    FieldVector3D<DerivativeStructure> i = new FieldVector3D<>(oneDS, zeroDS, zeroDS);
    FieldVector3D<DerivativeStructure> j = new FieldVector3D<>(zeroDS, oneDS, zeroDS);
    FieldVector3D<DerivativeStructure> k = new FieldVector3D<>(zeroDS, zeroDS, oneDS);
    FieldVector3D<DerivativeStructure> p = new FieldVector3D<>(oneDS, factory.constant(-2), factory.constant(3));
    FieldVector3D<DerivativeStructure> v = new FieldVector3D<>(factory.constant(-9), factory.constant(8), factory.constant(-7));
    // action + verify
    Assert.assertEquals(new FieldPVCoordinates<>(p, v).getAngularVelocity(), p.crossProduct(v).scalarMultiply(p.getNormSq().reciprocal()));
    // check extra simple cases
    Assert.assertEquals(new FieldPVCoordinates<>(i, i.scalarMultiply(-1)).getAngularVelocity(), zero);
    Assert.assertEquals(new FieldPVCoordinates<>(i.scalarMultiply(2), j).getAngularVelocity(), k.scalarMultiply(0.5));
}

Example 35 with DerivativeStructure

use of org.hipparchus.analysis.differentiation.DerivativeStructure in project Orekit by CS-SI.

the class FieldPropagation method main.

/**
 * Program entry point.
 * @param args program arguments (unused here)
 * @throws IOException
 * @throws OrekitException
 */
public static void main(String[] args) throws IOException, OrekitException {
    // the goal of this example is to make a Montecarlo simulation giving an error on the semiaxis,
    // the inclination and the RAAN. The interest of doing it with Orekit based on the
    // DerivativeStructure is that instead of doing a large number of propagation around the initial
    // point we will do a single propagation of the initial state, and thanks to the Taylor expansion
    // we will see the evolution of the std deviation of the position, which is divided in the
    // CrossTrack, the LongTrack and the Radial error.
    // configure Orekit
    File home = new File(System.getProperty("user.home"));
    File orekitData = new File(home, "orekit-data");
    if (!orekitData.exists()) {
        System.err.format(Locale.US, "Failed to find %s folder%n", orekitData.getAbsolutePath());
        System.err.format(Locale.US, "You need to download %s from the %s page and unzip it in %s for this tutorial to work%n", "orekit-data.zip", "https://www.orekit.org/forge/projects/orekit/files", home.getAbsolutePath());
        System.exit(1);
    }
    DataProvidersManager manager = DataProvidersManager.getInstance();
    manager.addProvider(new DirectoryCrawler(orekitData));
    // output file in user's home directory
    File workingDir = new File(System.getProperty("user.home"));
    File errorFile = new File(workingDir, "error.txt");
    System.out.println("Output file is in : " + errorFile.getAbsolutePath());
    PrintWriter PW = new PrintWriter(errorFile, "UTF-8");
    PW.printf("time \t\tCrossTrackErr \tLongTrackErr  \tRadialErr \tTotalErr%n");
    // setting the parameters of the simulation
    // Order of derivation of the DerivativeStructures
    int params = 3;
    int order = 3;
    DSFactory factory = new DSFactory(params, order);
    // number of samples of the montecarlo simulation
    int montecarlo_size = 100;
    // nominal values of the Orbital parameters
    double a_nominal = 7.278E6;
    double e_nominal = 1e-3;
    double i_nominal = FastMath.toRadians(98.3);
    double pa_nominal = FastMath.PI / 2;
    double raan_nominal = 0.0;
    double ni_nominal = 0.0;
    // mean of the gaussian curve for each of the errors around the nominal values
    // {a, i, RAAN}
    double[] mean = { 0, 0, 0 };
    // standard deviation of the gaussian curve for each of the errors around the nominal values
    // {dA, dI, dRaan}
    double[] dAdIdRaan = { 5, FastMath.toRadians(1e-3), FastMath.toRadians(1e-3) };
    // time of integration
    double final_Dt = 1 * 60 * 60;
    // number of steps per orbit
    double num_step_orbit = 10;
    DerivativeStructure a_0 = factory.variable(0, a_nominal);
    DerivativeStructure e_0 = factory.constant(e_nominal);
    DerivativeStructure i_0 = factory.variable(1, i_nominal);
    DerivativeStructure pa_0 = factory.constant(pa_nominal);
    DerivativeStructure raan_0 = factory.variable(2, raan_nominal);
    DerivativeStructure ni_0 = factory.constant(ni_nominal);
    // sometimes we will need the field of the DerivativeStructure to build new instances
    Field<DerivativeStructure> field = a_0.getField();
    // sometimes we will need the zero of the DerivativeStructure to build new instances
    DerivativeStructure zero = field.getZero();
    // initializing the FieldAbsoluteDate with only the field it will generate the day J2000
    FieldAbsoluteDate<DerivativeStructure> date_0 = new FieldAbsoluteDate<>(field);
    // initialize a basic frame
    Frame frame = FramesFactory.getEME2000();
    // initialize the orbit
    double mu = 3.9860047e14;
    FieldKeplerianOrbit<DerivativeStructure> KO = new FieldKeplerianOrbit<>(a_0, e_0, i_0, pa_0, raan_0, ni_0, PositionAngle.ECCENTRIC, frame, date_0, mu);
    // step of integration (how many times per orbit we take the mesures)
    double int_step = KO.getKeplerianPeriod().getReal() / num_step_orbit;
    // random generator to conduct an
    long number = 23091991;
    RandomGenerator RG = new Well19937a(number);
    GaussianRandomGenerator NGG = new GaussianRandomGenerator(RG);
    UncorrelatedRandomVectorGenerator URVG = new UncorrelatedRandomVectorGenerator(mean, dAdIdRaan, NGG);
    double[][] rand_gen = new double[montecarlo_size][3];
    for (int jj = 0; jj < montecarlo_size; jj++) {
        rand_gen[jj] = URVG.nextVector();
    }
    // 
    FieldSpacecraftState<DerivativeStructure> SS_0 = new FieldSpacecraftState<>(KO);
    // adding force models
    ForceModel fModel_Sun = new ThirdBodyAttraction(CelestialBodyFactory.getSun());
    ForceModel fModel_Moon = new ThirdBodyAttraction(CelestialBodyFactory.getMoon());
    ForceModel fModel_HFAM = new HolmesFeatherstoneAttractionModel(FramesFactory.getITRF(IERSConventions.IERS_2010, true), GravityFieldFactory.getNormalizedProvider(18, 18));
    // setting an hipparchus field integrator
    OrbitType type = OrbitType.CARTESIAN;
    double[][] tolerance = NumericalPropagator.tolerances(0.001, KO.toOrbit(), type);
    AdaptiveStepsizeFieldIntegrator<DerivativeStructure> integrator = new DormandPrince853FieldIntegrator<>(field, 0.001, 200, tolerance[0], tolerance[1]);
    integrator.setInitialStepSize(zero.add(60));
    // setting of the field propagator, we used the numerical one in order to add the third body attraction
    // and the holmes featherstone force models
    FieldNumericalPropagator<DerivativeStructure> numProp = new FieldNumericalPropagator<>(field, integrator);
    numProp.setOrbitType(type);
    numProp.setInitialState(SS_0);
    numProp.addForceModel(fModel_Sun);
    numProp.addForceModel(fModel_Moon);
    numProp.addForceModel(fModel_HFAM);
    // with the master mode we will calulcate and print the error on every fixed step on the file error.txt
    // we defined the StepHandler to do that giving him the random number generator,
    // the size of the montecarlo simulation and the initial date
    numProp.setMasterMode(zero.add(int_step), new MyStepHandler<DerivativeStructure>(rand_gen, montecarlo_size, date_0, PW));
    // 
    long START = System.nanoTime();
    FieldSpacecraftState<DerivativeStructure> finalState = numProp.propagate(date_0.shiftedBy(final_Dt));
    long STOP = System.nanoTime();
    System.out.println((STOP - START) / 1E6 + " ms");
    System.out.println(finalState.getDate());
    PW.close();
}