OrbitType.java

  1. /* Copyright 2002-2025 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.orbits;

  19. import org.hipparchus.CalculusFieldElement;
  20. import org.hipparchus.Field;
  21. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  22. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  23. import org.hipparchus.util.FastMath;
  24. import org.hipparchus.util.MathUtils;
  25. import org.orekit.errors.OrekitException;
  26. import org.orekit.errors.OrekitMessages;
  27. import org.orekit.frames.Frame;
  28. import org.orekit.time.AbsoluteDate;
  29. import org.orekit.time.FieldAbsoluteDate;
  30. import org.orekit.utils.FieldPVCoordinates;
  31. import org.orekit.utils.PVCoordinates;
  32. import org.orekit.utils.ParameterDriver;
  33. import org.orekit.utils.ParameterDriversList;
  34. import org.orekit.utils.TimeStampedFieldPVCoordinates;

  36. /** Enumerate for {@link Orbit} and {@link FieldOrbit} parameters types.
  37.  */
  38. public enum OrbitType {

  40.     /** Type for orbital representation in {@link CartesianOrbit} and {@link FieldCartesianOrbit} parameters. */
  41.     CARTESIAN {

  43.         /** {@inheritDoc} */
  44.         @Override
  45.         public CartesianOrbit convertType(final Orbit orbit) {
  46.             return (orbit.getType() == this) ? (CartesianOrbit) orbit : new CartesianOrbit(orbit);
  47.         }

  49.         /** {@inheritDoc} */
  50.         @Override
  51.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  52.                                     final double[] stateVector, final double[] stateVectorDot) {

  54.             final PVCoordinates pv = orbit.getPVCoordinates();
  55.             final Vector3D      p  = pv.getPosition();
  56.             final Vector3D      v  = pv.getVelocity();

  58.             stateVector[0] = p.getX();
  59.             stateVector[1] = p.getY();
  60.             stateVector[2] = p.getZ();
  61.             stateVector[3] = v.getX();
  62.             stateVector[4] = v.getY();
  63.             stateVector[5] = v.getZ();

  65.             if (stateVectorDot != null) {
  66.                 final Vector3D a  = pv.getAcceleration();
  67.                 stateVectorDot[0] = v.getX();
  68.                 stateVectorDot[1] = v.getY();
  69.                 stateVectorDot[2] = v.getZ();
  70.                 stateVectorDot[3] = a.getX();
  71.                 stateVectorDot[4] = a.getY();
  72.                 stateVectorDot[5] = a.getZ();
  73.             }

  75.         }

  77.         /** {@inheritDoc} */
  78.         @Override
  79.         public CartesianOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  80.                                               final AbsoluteDate date, final double mu, final Frame frame) {

  82.             final Vector3D p = new Vector3D(stateVector[0], stateVector[1], stateVector[2]);
  83.             final Vector3D v = new Vector3D(stateVector[3], stateVector[4], stateVector[5]);
  84.             final Vector3D a;
  85.             if (stateVectorDot == null) {
  86.                 // we don't have data about acceleration
  87.                 return new CartesianOrbit(new PVCoordinates(p, v), frame, date, mu);
  88.             } else {
  89.                 // we do have an acceleration
  90.                 a = new Vector3D(stateVectorDot[3], stateVectorDot[4], stateVectorDot[5]);
  91.                 return new CartesianOrbit(new PVCoordinates(p, v, a), frame, date, mu);
  92.             }

  94.         }

  96.         /** {@inheritDoc} */
  97.         @Override
  98.         public <T extends CalculusFieldElement<T>> FieldCartesianOrbit<T> convertType(final FieldOrbit<T> orbit) {
  99.             return (orbit.getType() == this) ? (FieldCartesianOrbit<T>) orbit : new FieldCartesianOrbit<>(orbit);
  100.         }

  102.         /** {@inheritDoc} */
  103.         @Override
  104.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  105.                                                                         final PositionAngleType type,
  106.                                                                         final T[] stateVector,
  107.                                                                         final T[] stateVectorDot) {

  109.             final TimeStampedFieldPVCoordinates<T> pv = orbit.getPVCoordinates();
  110.             final FieldVector3D<T>                 p  = pv.getPosition();
  111.             final FieldVector3D<T>                 v  = pv.getVelocity();

  113.             stateVector[0] = p.getX();
  114.             stateVector[1] = p.getY();
  115.             stateVector[2] = p.getZ();
  116.             stateVector[3] = v.getX();
  117.             stateVector[4] = v.getY();
  118.             stateVector[5] = v.getZ();

  120.             if (stateVectorDot != null) {
  121.                 final FieldVector3D<T> a = pv.getAcceleration();
  122.                 stateVectorDot[0] = v.getX();
  123.                 stateVectorDot[1] = v.getY();
  124.                 stateVectorDot[2] = v.getZ();
  125.                 stateVectorDot[3] = a.getX();
  126.                 stateVectorDot[4] = a.getY();
  127.                 stateVectorDot[5] = a.getZ();
  128.             }

  130.         }

  132.         /** {@inheritDoc} */
  133.         @Override
  134.         public <T extends CalculusFieldElement<T>> FieldCartesianOrbit<T> mapArrayToOrbit(final T[] stateVector,
  135.                                                                                           final T[] stateVectorDot,
  136.                                                                                           final PositionAngleType type,
  137.                                                                                           final FieldAbsoluteDate<T> date,
  138.                                                                                           final T mu, final Frame frame) {
  139.             final FieldVector3D<T> p = new FieldVector3D<>(stateVector[0], stateVector[1], stateVector[2]);
  140.             final FieldVector3D<T> v = new FieldVector3D<>(stateVector[3], stateVector[4], stateVector[5]);
  141.             final FieldVector3D<T> a;
  142.             if (stateVectorDot == null) {
  143.                 // we don't have data about acceleration
  144.                 return new FieldCartesianOrbit<>(new FieldPVCoordinates<>(p, v), frame, date, mu);
  145.             } else {
  146.                 // we do have an acceleration
  147.                 a = new FieldVector3D<>(stateVectorDot[3], stateVectorDot[4], stateVectorDot[5]);
  148.                 return new FieldCartesianOrbit<>(new FieldPVCoordinates<>(p, v, a), frame, date, mu);
  149.             }

  151.         }

  153.         /** {@inheritDoc} */
  154.         @Override
  155.         public <T extends CalculusFieldElement<T>> FieldCartesianOrbit<T> convertToFieldOrbit(final Field<T> field,
  156.                                                                                               final Orbit orbit) {
  157.             return new FieldCartesianOrbit<>(field, CARTESIAN.convertType(orbit));
  158.         }

  160.         /** {@inheritDoc} */
  161.         @Override
  162.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  163.             final ParameterDriversList drivers = new ParameterDriversList();
  164.             final double[] array = new double[6];
  165.             mapOrbitToArray(orbit, type, array, null);
  166.             final double[] scale = scale(dP, orbit);
  167.             drivers.add(new ParameterDriver(POS_X, array[0], scale[0], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  168.             drivers.add(new ParameterDriver(POS_Y, array[1], scale[1], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  169.             drivers.add(new ParameterDriver(POS_Z, array[2], scale[2], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  170.             drivers.add(new ParameterDriver(VEL_X, array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  171.             drivers.add(new ParameterDriver(VEL_Y, array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  172.             drivers.add(new ParameterDriver(VEL_Z, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  173.             return drivers;
  174.         }

  176.         /** {@inheritDoc} */
  177.         @Override
  178.         public CartesianOrbit normalize(final Orbit orbit, final Orbit reference) {
  179.             // no angular parameters need normalization
  180.             return convertType(orbit);
  181.         }

  183.         /** {@inheritDoc} */
  184.         @Override
  185.         public <T extends CalculusFieldElement<T>> FieldCartesianOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {
  186.             // no angular parameters need normalization
  187.             return convertType(orbit);
  188.         }

  190.         /** {@inheritDoc} */
  191.         @Override
  192.         public boolean isPositionAngleBased() {
  193.             return false;
  194.         }

  196.     },

  198.     /** Type for orbital representation in {@link CircularOrbit} and {@link FieldCircularOrbit} parameters. */
  199.     CIRCULAR {

  201.         /** {@inheritDoc} */
  202.         @Override
  203.         public CircularOrbit convertType(final Orbit orbit) {
  204.             return (orbit.getType() == this) ? (CircularOrbit) orbit : new CircularOrbit(orbit);
  205.         }

  207.         /** {@inheritDoc} */
  208.         @Override
  209.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  210.                                     final double[] stateVector, final double[] stateVectorDot) {

  212.             final CircularOrbit circularOrbit = (CircularOrbit) OrbitType.CIRCULAR.convertType(orbit);

  214.             stateVector[0] = circularOrbit.getA();
  215.             stateVector[1] = circularOrbit.getCircularEx();
  216.             stateVector[2] = circularOrbit.getCircularEy();
  217.             stateVector[3] = circularOrbit.getI();
  218.             stateVector[4] = circularOrbit.getRightAscensionOfAscendingNode();
  219.             stateVector[5] = circularOrbit.getAlpha(type);

  221.             if (stateVectorDot != null) {
  222.                 stateVectorDot[0] = circularOrbit.getADot();
  223.                 stateVectorDot[1] = circularOrbit.getCircularExDot();
  224.                 stateVectorDot[2] = circularOrbit.getCircularEyDot();
  225.                 stateVectorDot[3] = circularOrbit.getIDot();
  226.                 stateVectorDot[4] = circularOrbit.getRightAscensionOfAscendingNodeDot();
  227.                 stateVectorDot[5] = circularOrbit.getAlphaDot(type);
  228.             }

  230.         }

  232.         /** {@inheritDoc} */
  233.         @Override
  234.         public CircularOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  235.                                              final AbsoluteDate date, final double mu, final Frame frame) {
  236.             if (stateVectorDot == null) {
  237.                 // we don't have orbit derivatives
  238.                 return new CircularOrbit(stateVector[0], stateVector[1], stateVector[2],
  239.                                          stateVector[3], stateVector[4], stateVector[5],
  240.                                          type, frame, date, mu);
  241.             } else {
  242.                 // we have orbit derivatives
  243.                 return new CircularOrbit(stateVector[0],    stateVector[1],    stateVector[2],
  244.                                          stateVector[3],    stateVector[4],    stateVector[5],
  245.                                          stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  246.                                          stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  247.                                          type, frame, date, mu);
  248.             }
  249.         }

  251.         /** {@inheritDoc} */
  252.         @Override
  253.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> convertType(final FieldOrbit<T> orbit) {
  254.             return (orbit.getType() == this) ? (FieldCircularOrbit<T>) orbit : new FieldCircularOrbit<>(orbit);
  255.         }

  257.         /** {@inheritDoc} */
  258.         @Override
  259.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  260.                                                                         final PositionAngleType type,
  261.                                                                         final T[] stateVector,
  262.                                                                         final T[] stateVectorDot) {

  264.             final FieldCircularOrbit<T> circularOrbit = (FieldCircularOrbit<T>) OrbitType.CIRCULAR.convertType(orbit);

  266.             stateVector[0] = circularOrbit.getA();
  267.             stateVector[1] = circularOrbit.getCircularEx();
  268.             stateVector[2] = circularOrbit.getCircularEy();
  269.             stateVector[3] = circularOrbit.getI();
  270.             stateVector[4] = circularOrbit.getRightAscensionOfAscendingNode();
  271.             stateVector[5] = circularOrbit.getAlpha(type);

  273.             if (stateVectorDot != null) {
  274.                 stateVectorDot[0] = circularOrbit.getADot();
  275.                 stateVectorDot[1] = circularOrbit.getCircularExDot();
  276.                 stateVectorDot[2] = circularOrbit.getCircularEyDot();
  277.                 stateVectorDot[3] = circularOrbit.getIDot();
  278.                 stateVectorDot[4] = circularOrbit.getRightAscensionOfAscendingNodeDot();
  279.                 stateVectorDot[5] = circularOrbit.getAlphaDot(type);
  280.             }

  282.         }

  284.         /** {@inheritDoc} */
  285.         @Override
  286.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> mapArrayToOrbit(final T[] stateVector,
  287.                                                                                          final T[] stateVectorDot, final PositionAngleType type,
  288.                                                                                          final FieldAbsoluteDate<T> date,
  289.                                                                                          final T mu, final Frame frame) {
  290.             if (stateVectorDot == null) {
  291.                 // we don't have orbit derivatives
  292.                 return new FieldCircularOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  293.                                                 stateVector[3], stateVector[4], stateVector[5],
  294.                                                 type, frame, date, mu);
  295.             } else {
  296.                 // we have orbit derivatives
  297.                 return new FieldCircularOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  298.                                                 stateVector[3],    stateVector[4],    stateVector[5],
  299.                                                 stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  300.                                                 stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  301.                                                 type, frame, date, mu);
  302.             }
  303.         }

  305.         /** {@inheritDoc} */
  306.         @Override
  307.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> convertToFieldOrbit(final Field<T> field,
  308.                                                                                              final Orbit orbit) {
  309.             return new FieldCircularOrbit<>(field, CIRCULAR.convertType(orbit));
  310.         }

  312.         /** {@inheritDoc} */
  313.         @Override
  314.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  315.             final ParameterDriversList drivers = new ParameterDriversList();
  316.             final double[] array = new double[6];
  317.             mapOrbitToArray(orbit, type, array, null);
  318.             final double[] scale = scale(dP, orbit);
  319.             final String name = type == PositionAngleType.MEAN ?
  320.                                     MEAN_LAT_ARG :
  321.                                     type == PositionAngleType.ECCENTRIC ? ECC_LAT_ARG : TRUE_LAT_ARG;
  322.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  323.             drivers.add(new ParameterDriver(E_X,  array[1], scale[1], -1.0, 1.0));
  324.             drivers.add(new ParameterDriver(E_Y,  array[2], scale[2], -1.0, 1.0));
  325.             drivers.add(new ParameterDriver(INC,  array[3], scale[3],  0.0, FastMath.PI));
  326.             drivers.add(new ParameterDriver(RAAN, array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  327.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  328.             return drivers;
  329.         }

  331.         /** {@inheritDoc} */
  332.         @Override
  333.         public CircularOrbit normalize(final Orbit orbit, final Orbit reference) {

  335.             // convert input to proper type
  336.             final CircularOrbit cO = convertType(orbit);
  337.             final CircularOrbit cR = convertType(reference);
  338.             final PositionAngleType cachedPositionAngleType = cO.getCachedPositionAngleType();

  340.             // perform normalization
  341.             return new CircularOrbit(cO.getA(),
  342.                                      cO.getCircularEx(),
  343.                                      cO.getCircularEy(),
  344.                                      cO.getI(),
  345.                                      MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  346.                                              cR.getRightAscensionOfAscendingNode()),
  347.                                      MathUtils.normalizeAngle(cO.getAlpha(cachedPositionAngleType),
  348.                                              cR.getAlpha(cachedPositionAngleType)),
  349.                                      cO.getADot(),
  350.                                      cO.getCircularExDot(),
  351.                                      cO.getCircularEyDot(),
  352.                                      cO.getIDot(),
  353.                                      cO.getRightAscensionOfAscendingNodeDot(),
  354.                                      cO.getAlphaDot(cachedPositionAngleType),
  355.                                      cachedPositionAngleType,
  356.                                      cO.getFrame(),
  357.                                      cO.getDate(),
  358.                                      cO.getMu());

  360.         }

  362.         /** {@inheritDoc} */
  363.         @Override
  364.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  366.             // convert input to proper type
  367.             final FieldCircularOrbit<T> cO = convertType(orbit);
  368.             final FieldCircularOrbit<T> cR = convertType(reference);
  369.             final PositionAngleType positionAngleType = cO.getCachedPositionAngleType();

  371.             // perform normalization
  372.             if (cO.hasNonKeplerianAcceleration()) {
  373.                 return new FieldCircularOrbit<>(cO.getA(),
  374.                                                 cO.getCircularEx(),
  375.                                                 cO.getCircularEy(),
  376.                                                 cO.getI(),
  377.                                                 MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  378.                                                         cR.getRightAscensionOfAscendingNode()),
  379.                                                 MathUtils.normalizeAngle(cO.getAlpha(positionAngleType),
  380.                                                         cR.getAlpha(positionAngleType)),
  381.                                                 cO.getADot(),
  382.                                                 cO.getCircularExDot(),
  383.                                                 cO.getCircularEyDot(),
  384.                                                 cO.getIDot(),
  385.                                                 cO.getRightAscensionOfAscendingNodeDot(),
  386.                                                 cO.getAlphaDot(positionAngleType),
  387.                                                 positionAngleType,
  388.                                                 cO.getFrame(),
  389.                                                 cO.getDate(),
  390.                                                 cO.getMu());
  391.             } else {
  392.                 return new FieldCircularOrbit<>(cO.getA(),
  393.                                                 cO.getCircularEx(),
  394.                                                 cO.getCircularEy(),
  395.                                                 cO.getI(),
  396.                                                 MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  397.                                                         cR.getRightAscensionOfAscendingNode()),
  398.                                                 MathUtils.normalizeAngle(cO.getAlpha(positionAngleType),
  399.                                                         cR.getAlpha(positionAngleType)),
  400.                                                 positionAngleType,
  401.                                                 cO.getFrame(),
  402.                                                 cO.getDate(),
  403.                                                 cO.getMu());
  404.             }

  406.         }

  408.         /** {@inheritDoc} */
  409.         @Override
  410.         public boolean isPositionAngleBased() {
  411.             return true;
  412.         }

  414.     },

  416.     /** Type for orbital representation in {@link EquinoctialOrbit} and {@link FieldEquinoctialOrbit} parameters. */
  417.     EQUINOCTIAL {

  419.         /** {@inheritDoc} */
  420.         @Override
  421.         public EquinoctialOrbit convertType(final Orbit orbit) {
  422.             return (orbit.getType() == this) ? (EquinoctialOrbit) orbit : new EquinoctialOrbit(orbit);
  423.         }

  425.         /** {@inheritDoc} */
  426.         @Override
  427.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  428.                                     final double[] stateVector, final double[] stateVectorDot) {

  430.             final EquinoctialOrbit equinoctialOrbit =
  431.                 (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(orbit);

  433.             stateVector[0] = equinoctialOrbit.getA();
  434.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  435.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  436.             stateVector[3] = equinoctialOrbit.getHx();
  437.             stateVector[4] = equinoctialOrbit.getHy();
  438.             stateVector[5] = equinoctialOrbit.getL(type);

  440.             if (stateVectorDot != null) {
  441.                 stateVectorDot[0] = equinoctialOrbit.getADot();
  442.                 stateVectorDot[1] = equinoctialOrbit.getEquinoctialExDot();
  443.                 stateVectorDot[2] = equinoctialOrbit.getEquinoctialEyDot();
  444.                 stateVectorDot[3] = equinoctialOrbit.getHxDot();
  445.                 stateVectorDot[4] = equinoctialOrbit.getHyDot();
  446.                 stateVectorDot[5] = equinoctialOrbit.getLDot(type);
  447.             }

  449.         }

  451.         /** {@inheritDoc} */
  452.         @Override
  453.         public EquinoctialOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  454.                                                 final AbsoluteDate date, final double mu, final Frame frame) {
  455.             if (stateVectorDot == null) {
  456.                 // we don't have orbit derivatives
  457.                 return new EquinoctialOrbit(stateVector[0], stateVector[1], stateVector[2],
  458.                                             stateVector[3], stateVector[4], stateVector[5],
  459.                                             type, frame, date, mu);
  460.             } else {
  461.                 // we have orbit derivatives
  462.                 return new EquinoctialOrbit(stateVector[0],    stateVector[1],    stateVector[2],
  463.                                             stateVector[3],    stateVector[4],    stateVector[5],
  464.                                             stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  465.                                             stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  466.                                             type, frame, date, mu);
  467.             }
  468.         }

  470.         /** {@inheritDoc} */
  471.         @Override
  472.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> convertType(final FieldOrbit<T> orbit) {
  473.             return (orbit.getType() == this) ? (FieldEquinoctialOrbit<T>) orbit : new FieldEquinoctialOrbit<>(orbit);
  474.         }

  476.         /** {@inheritDoc} */
  477.         @Override
  478.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  479.                                                                         final PositionAngleType type,
  480.                                                                         final T[] stateVector,
  481.                                                                         final T[] stateVectorDot) {

  483.             final FieldEquinoctialOrbit<T> equinoctialOrbit =
  484.                 (FieldEquinoctialOrbit<T>) OrbitType.EQUINOCTIAL.convertType(orbit);

  486.             stateVector[0] = equinoctialOrbit.getA();
  487.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  488.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  489.             stateVector[3] = equinoctialOrbit.getHx();
  490.             stateVector[4] = equinoctialOrbit.getHy();
  491.             stateVector[5] = equinoctialOrbit.getL(type);

  493.             if (stateVectorDot != null) {
  494.                 stateVectorDot[0] = equinoctialOrbit.getADot();
  495.                 stateVectorDot[1] = equinoctialOrbit.getEquinoctialExDot();
  496.                 stateVectorDot[2] = equinoctialOrbit.getEquinoctialEyDot();
  497.                 stateVectorDot[3] = equinoctialOrbit.getHxDot();
  498.                 stateVectorDot[4] = equinoctialOrbit.getHyDot();
  499.                 stateVectorDot[5] = equinoctialOrbit.getLDot(type);
  500.             }

  502.         }

  504.         /** {@inheritDoc} */
  505.         @Override
  506.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> mapArrayToOrbit(final T[] stateVector,
  507.                                                                                             final T[] stateVectorDot,
  508.                                                                                             final PositionAngleType type,
  509.                                                                                             final FieldAbsoluteDate<T> date,
  510.                                                                                             final T mu, final Frame frame) {
  511.             if (stateVectorDot == null) {
  512.                 // we don't have orbit derivatives
  513.                 return new FieldEquinoctialOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  514.                                                    stateVector[3], stateVector[4], stateVector[5],
  515.                                                    type, frame, date, mu);
  516.             } else {
  517.                 // we have orbit derivatives
  518.                 return new FieldEquinoctialOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  519.                                                    stateVector[3],    stateVector[4],    stateVector[5],
  520.                                                    stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  521.                                                    stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  522.                                                    type, frame, date, mu);
  523.             }
  524.         }

  526.         /** {@inheritDoc} */
  527.         @Override
  528.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> convertToFieldOrbit(final Field<T> field,
  529.                                                                                                 final Orbit orbit) {
  530.             return new FieldEquinoctialOrbit<>(field, EQUINOCTIAL.convertType(orbit));
  531.         }

  533.         /** {@inheritDoc} */
  534.         @Override
  535.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  536.             final ParameterDriversList drivers = new ParameterDriversList();
  537.             final double[] array = new double[6];
  538.             mapOrbitToArray(orbit, type, array, null);
  539.             final double[] scale = scale(dP, orbit);
  540.             final String name = type == PositionAngleType.MEAN ?
  541.                                     MEAN_LON_ARG :
  542.                                     type == PositionAngleType.ECCENTRIC ? ECC_LON_ARG : TRUE_LON_ARG;
  543.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  544.             drivers.add(new ParameterDriver(E_X,  array[1], scale[1], -1.0, 1.0));
  545.             drivers.add(new ParameterDriver(E_Y,  array[2], scale[2], -1.0, 1.0));
  546.             drivers.add(new ParameterDriver(H_X,  array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  547.             drivers.add(new ParameterDriver(H_Y,  array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  548.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  549.             return drivers;
  550.         }

  552.         /** {@inheritDoc} */
  553.         @Override
  554.         public EquinoctialOrbit normalize(final Orbit orbit, final Orbit reference) {

  556.             // convert input to proper type
  557.             final EquinoctialOrbit eO = convertType(orbit);
  558.             final EquinoctialOrbit eR = convertType(reference);
  559.             final PositionAngleType cachedPositionAngleType = eO.getCachedPositionAngleType();

  561.             // perform normalization
  562.             return new EquinoctialOrbit(eO.getA(),
  563.                                         eO.getEquinoctialEx(),
  564.                                         eO.getEquinoctialEy(),
  565.                                         eO.getHx(),
  566.                                         eO.getHy(),
  567.                                         MathUtils.normalizeAngle(eO.getL(cachedPositionAngleType),
  568.                                         eR.getL(cachedPositionAngleType)),
  569.                                         eO.getADot(),
  570.                                         eO.getEquinoctialExDot(),
  571.                                         eO.getEquinoctialEyDot(),
  572.                                         eO.getHxDot(),
  573.                                         eO.getHyDot(),
  574.                                         eO.getLDot(cachedPositionAngleType),
  575.                                         cachedPositionAngleType,
  576.                                         eO.getFrame(),
  577.                                         eO.getDate(),
  578.                                         eO.getMu());

  580.         }

  582.         /** {@inheritDoc} */
  583.         @Override
  584.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  586.             // convert input to proper type
  587.             final FieldEquinoctialOrbit<T> eO = convertType(orbit);
  588.             final FieldEquinoctialOrbit<T> eR = convertType(reference);
  589.             final PositionAngleType positionAngleType = eO.getCachedPositionAngleType();

  591.             // perform normalization
  592.             if (eO.hasNonKeplerianAcceleration()) {
  593.                 return new FieldEquinoctialOrbit<>(eO.getA(),
  594.                                                    eO.getEquinoctialEx(),
  595.                                                    eO.getEquinoctialEy(),
  596.                                                    eO.getHx(),
  597.                                                    eO.getHy(),
  598.                                                    MathUtils.normalizeAngle(eO.getL(positionAngleType),
  599.                                                            eR.getL(positionAngleType)),
  600.                                                    eO.getADot(),
  601.                                                    eO.getEquinoctialExDot(),
  602.                                                    eO.getEquinoctialEyDot(),
  603.                                                    eO.getHxDot(),
  604.                                                    eO.getHyDot(),
  605.                                                    eO.getLDot(positionAngleType),
  606.                                                    positionAngleType,
  607.                                                    eO.getFrame(),
  608.                                                    eO.getDate(),
  609.                                                    eO.getMu());
  610.             } else {
  611.                 return new FieldEquinoctialOrbit<>(eO.getA(),
  612.                                                    eO.getEquinoctialEx(),
  613.                                                    eO.getEquinoctialEy(),
  614.                                                    eO.getHx(),
  615.                                                    eO.getHy(),
  616.                                                    MathUtils.normalizeAngle(eO.getL(positionAngleType),
  617.                                                            eR.getL(positionAngleType)),
  618.                                                    positionAngleType,
  619.                                                    eO.getFrame(),
  620.                                                    eO.getDate(),
  621.                                                    eO.getMu());
  622.             }

  624.         }

  626.         /** {@inheritDoc} */
  627.         @Override
  628.         public boolean isPositionAngleBased() {
  629.             return true;
  630.         }

  632.     },

  634.     /** Type for orbital representation in {@link KeplerianOrbit} and {@link FieldKeplerianOrbit} parameters. */
  635.     KEPLERIAN {

  637.         /** {@inheritDoc} */
  638.         @Override
  639.         public KeplerianOrbit convertType(final Orbit orbit) {
  640.             return (orbit.getType() == this) ? (KeplerianOrbit) orbit : new KeplerianOrbit(orbit);
  641.         }

  643.         /** {@inheritDoc} */
  644.         @Override
  645.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  646.                                     final double[] stateVector, final double[] stateVectorDot) {

  648.             final KeplerianOrbit keplerianOrbit =
  649.                 (KeplerianOrbit) OrbitType.KEPLERIAN.convertType(orbit);

  651.             stateVector[0] = keplerianOrbit.getA();
  652.             stateVector[1] = keplerianOrbit.getE();
  653.             stateVector[2] = keplerianOrbit.getI();
  654.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  655.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  656.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  658.             if (stateVectorDot != null) {
  659.                 stateVectorDot[0] = keplerianOrbit.getADot();
  660.                 stateVectorDot[1] = keplerianOrbit.getEDot();
  661.                 stateVectorDot[2] = keplerianOrbit.getIDot();
  662.                 stateVectorDot[3] = keplerianOrbit.getPerigeeArgumentDot();
  663.                 stateVectorDot[4] = keplerianOrbit.getRightAscensionOfAscendingNodeDot();
  664.                 stateVectorDot[5] = keplerianOrbit.getAnomalyDot(type);
  665.             }

  667.         }

  669.         /** {@inheritDoc} */
  670.         @Override
  671.         public KeplerianOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  672.                                               final AbsoluteDate date, final double mu, final Frame frame) {
  673.             if (stateVectorDot == null) {
  674.                 // we don't have orbit derivatives
  675.                 return new KeplerianOrbit(stateVector[0], stateVector[1], stateVector[2],
  676.                                           stateVector[3], stateVector[4], stateVector[5],
  677.                                           type, frame, date, mu);
  678.             } else {
  679.                 // we have orbit derivatives
  680.                 return new KeplerianOrbit(stateVector[0],    stateVector[1],    stateVector[2],
  681.                                           stateVector[3],    stateVector[4],    stateVector[5],
  682.                                           stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  683.                                           stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  684.                                           type, frame, date, mu);
  685.             }
  686.         }

  688.         /** {@inheritDoc} */
  689.         @Override
  690.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> convertType(final FieldOrbit<T> orbit) {
  691.             return (orbit.getType() == this) ? (FieldKeplerianOrbit<T>) orbit : new FieldKeplerianOrbit<>(orbit);
  692.         }

  694.         /** {@inheritDoc} */
  695.         @Override
  696.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  697.                                                                         final PositionAngleType type,
  698.                                                                         final T[] stateVector,
  699.                                                                         final T[] stateVectorDot) {
  700.             final FieldKeplerianOrbit<T> keplerianOrbit =
  701.                             (FieldKeplerianOrbit<T>) OrbitType.KEPLERIAN.convertType(orbit);

  703.             stateVector[0] = keplerianOrbit.getA();
  704.             stateVector[1] = keplerianOrbit.getE();
  705.             stateVector[2] = keplerianOrbit.getI();
  706.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  707.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  708.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  710.             if (stateVectorDot != null) {
  711.                 stateVectorDot[0] = keplerianOrbit.getADot();
  712.                 stateVectorDot[1] = keplerianOrbit.getEDot();
  713.                 stateVectorDot[2] = keplerianOrbit.getIDot();
  714.                 stateVectorDot[3] = keplerianOrbit.getPerigeeArgumentDot();
  715.                 stateVectorDot[4] = keplerianOrbit.getRightAscensionOfAscendingNodeDot();
  716.                 stateVectorDot[5] = keplerianOrbit.getAnomalyDot(type);
  717.             }

  719.         }

  721.         /** {@inheritDoc} */
  722.         @Override
  723.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> mapArrayToOrbit(final T[] stateVector,
  724.                                                                                           final T[] stateVectorDot,
  725.                                                                                           final PositionAngleType type,
  726.                                                                                           final FieldAbsoluteDate<T> date,
  727.                                                                                           final T mu, final Frame frame) {
  728.             if (stateVectorDot == null) {
  729.                 // we don't have orbit derivatives
  730.                 return new FieldKeplerianOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  731.                                                  stateVector[3], stateVector[4], stateVector[5],
  732.                                                  type, frame, date, mu);
  733.             } else {
  734.                 // we have orbit derivatives
  735.                 return new FieldKeplerianOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  736.                                                  stateVector[3],    stateVector[4],    stateVector[5],
  737.                                                  stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  738.                                                  stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  739.                                                  type, frame, date, mu);
  740.             }
  741.         }

  743.         /** {@inheritDoc} */
  744.         @Override
  745.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> convertToFieldOrbit(final Field<T> field,
  746.                                                                                               final Orbit orbit) {
  747.             return new FieldKeplerianOrbit<>(field, KEPLERIAN.convertType(orbit));
  748.         }

  750.         /** {@inheritDoc} */
  751.         @Override
  752.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  753.             final ParameterDriversList drivers = new ParameterDriversList();
  754.             final double[] array = new double[6];
  755.             mapOrbitToArray(orbit, type, array, null);
  756.             final double[] scale = scale(dP, orbit);
  757.             final String name = type == PositionAngleType.MEAN ?
  758.                                     MEAN_ANOM :
  759.                                     type == PositionAngleType.ECCENTRIC ? ECC_ANOM : TRUE_ANOM;
  760.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  761.             drivers.add(new ParameterDriver(ECC,  array[1], scale[1],  0.0, 1.0));
  762.             drivers.add(new ParameterDriver(INC,  array[2], scale[2],  0.0, FastMath.PI));
  763.             drivers.add(new ParameterDriver(PA,   array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  764.             drivers.add(new ParameterDriver(RAAN, array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  765.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  766.             return drivers;
  767.         }

  769.         /** {@inheritDoc} */
  770.         @Override
  771.         public KeplerianOrbit normalize(final Orbit orbit, final Orbit reference) {

  773.             // convert input to proper type
  774.             final KeplerianOrbit kO = convertType(orbit);
  775.             final KeplerianOrbit kR = convertType(reference);
  776.             final PositionAngleType cachedPositionAngleType = kO.getCachedPositionAngleType();

  778.             // perform normalization
  779.             return new KeplerianOrbit(kO.getA(),
  780.                                       kO.getE(),
  781.                                       kO.getI(),
  782.                                       MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  783.                                       MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(),
  784.                                               kR.getRightAscensionOfAscendingNode()),
  785.                                       MathUtils.normalizeAngle(kO.getAnomaly(cachedPositionAngleType),
  786.                                               kR.getAnomaly(cachedPositionAngleType)),
  787.                                       kO.getADot(),
  788.                                       kO.getEDot(),
  789.                                       kO.getIDot(),
  790.                                       kO.getPerigeeArgumentDot(),
  791.                                       kO.getRightAscensionOfAscendingNodeDot(),
  792.                                       kO.getAnomalyDot(cachedPositionAngleType),
  793.                                       cachedPositionAngleType,
  794.                                       kO.getFrame(),
  795.                                       kO.getDate(),
  796.                                       kO.getMu());

  798.         }

  800.         /** {@inheritDoc} */
  801.         @Override
  802.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  804.             // convert input to proper type
  805.             final FieldKeplerianOrbit<T> kO = convertType(orbit);
  806.             final FieldKeplerianOrbit<T> kR = convertType(reference);
  807.             final PositionAngleType positionAngleType = kO.getCachedPositionAngleType();

  809.             // perform normalization
  810.             if (kO.hasNonKeplerianAcceleration()) {
  811.                 return new FieldKeplerianOrbit<>(kO.getA(),
  812.                                                  kO.getE(),
  813.                                                  kO.getI(),
  814.                                                  MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  815.                                                  MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(),
  816.                                                          kR.getRightAscensionOfAscendingNode()),
  817.                                                  MathUtils.normalizeAngle(kO.getAnomaly(positionAngleType),
  818.                                                          kR.getAnomaly(positionAngleType)),
  819.                                                  kO.getADot(),
  820.                                                  kO.getEDot(),
  821.                                                  kO.getIDot(),
  822.                                                  kO.getPerigeeArgumentDot(),
  823.                                                  kO.getRightAscensionOfAscendingNodeDot(),
  824.                                                  kO.getAnomalyDot(positionAngleType),
  825.                                                  positionAngleType,
  826.                                                  kO.getFrame(),
  827.                                                  kO.getDate(),
  828.                                                  kO.getMu());
  829.             } else {
  830.                 return new FieldKeplerianOrbit<>(kO.getA(),
  831.                                                  kO.getE(),
  832.                                                  kO.getI(),
  833.                                                  MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  834.                                                  MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(),
  835.                                                          kR.getRightAscensionOfAscendingNode()),
  836.                                                  MathUtils.normalizeAngle(kO.getAnomaly(positionAngleType),
  837.                                                          kR.getAnomaly(positionAngleType)),
  838.                                                  positionAngleType,
  839.                                                  kO.getFrame(),
  840.                                                  kO.getDate(),
  841.                                                  kO.getMu());
  842.             }

  844.         }

  846.         /** {@inheritDoc} */
  847.         @Override
  848.         public boolean isPositionAngleBased() {
  849.             return true;
  850.         }

  852.     };

  854.     /** Name for position along X. */
  855.     public static final String POS_X = "Px";

  857.     /** Name for position along Y. */
  858.     public static final String POS_Y = "Py";

  860.     /** Name for position along Z. */
  861.     public static final String POS_Z = "Pz";

  863.     /** Name for velocity along X. */
  864.     public static final String VEL_X = "Vx";

  866.     /** Name for velocity along Y. */
  867.     public static final String VEL_Y = "Vy";

  869.     /** Name for velocity along Z. */
  870.     public static final String VEL_Z = "Vz";

  872.     /** Name for semi major axis. */
  873.     public static final String A     = "a";

  875.     /** Name for eccentricity. */
  876.     public static final String ECC   = "e";

  878.     /** Name for eccentricity vector first component. */
  879.     public static final String E_X   = "ex";

  881.     /** Name for eccentricity vector second component. */
  882.     public static final String E_Y   = "ey";

  884.     /** Name for inclination. */
  885.     public static final String INC   = "i";

  887.     /** Name for inclination vector first component. */
  888.     public static final String H_X   = "hx";

  890.     /** Name for inclination vector second component . */
  891.     public static final String H_Y   = "hy";

  893.     /** Name for perigee argument. */
  894.     public static final String PA    = "ω";

  896.     /** Name for right ascension of ascending node. */
  897.     public static final String RAAN    = "Ω";

  899.     /** Name for mean anomaly. */
  900.     public static final String MEAN_ANOM = "M";

  902.     /** Name for eccentric anomaly. */
  903.     public static final String ECC_ANOM  = "E";

  905.     /** Name for mean anomaly. */
  906.     public static final String TRUE_ANOM = "v";

  908.     /** Name for mean argument of latitude. */
  909.     public static final String MEAN_LAT_ARG = "αM";

  911.     /** Name for eccentric argument of latitude. */
  912.     public static final String ECC_LAT_ARG  = "αE";

  914.     /** Name for mean argument of latitude. */
  915.     public static final String TRUE_LAT_ARG = "αv";

  917.     /** Name for mean argument of longitude. */
  918.     public static final String MEAN_LON_ARG = "λM";

  920.     /** Name for eccentric argument of longitude. */
  921.     public static final String ECC_LON_ARG  = "λE";

  923.     /** Name for mean argument of longitude. */
  924.     public static final String TRUE_LON_ARG = "λv";

  926.     /** Convert an orbit to the instance type.
  927.      * <p>
  928.      * The returned orbit is the specified instance itself if its type already matches,
  929.      * otherwise, a new orbit of the proper type created
  930.      * </p>
  931.      * @param orbit orbit to convert
  932.      * @return converted orbit with type guaranteed to match (so it can be cast safely)
  933.      */
  934.     public abstract Orbit convertType(Orbit orbit);

  936.     /** Convert orbit to state array.
  937.      * <p>
  938.      * Note that all implementations of this method <em>must</em> be consistent with the
  939.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  940.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  941.      * method for the corresponding orbit type in terms of parameters order and meaning.
  942.      * </p>
  943.      * @param orbit orbit to map
  944.      * @param type type of the angle
  945.      * @param stateVector flat array into which the state vector should be mapped
  946.      * (it can have more than 6 elements, extra elements are untouched)
  947.      * @param stateVectorDot flat array into which the state vector derivative should be mapped
  948.      * (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)
  949.      */
  950.     public abstract void mapOrbitToArray(Orbit orbit, PositionAngleType type, double[] stateVector, double[] stateVectorDot);

  952.      /** Convert state array to orbital parameters.
  953.      * <p>
  954.      * Note that all implementations of this method <em>must</em> be consistent with the
  955.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  956.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  957.      * method for the corresponding orbit type in terms of parameters order and meaning.
  958.      * </p>
  959.      * @param array state as a flat array
  960.      * (it can have more than 6 elements, extra elements are ignored)
  961.      * @param arrayDot state derivative as a flat array
  962.      * (it can be null, in which case Keplerian motion is assumed,
  963.      * and it can have more than 6 elements, extra elements are ignored)
  964.      * @param type type of the angle
  965.      * @param date integration date
  966.      * @param mu central attraction coefficient used for propagation (m³/s²)
  967.      * @param frame frame in which integration is performed
  968.      * @return orbit corresponding to the flat array as a space dynamics object
  969.      */
  970.     public abstract Orbit mapArrayToOrbit(double[] array, double[] arrayDot, PositionAngleType type,
  971.                                           AbsoluteDate date, double mu, Frame frame);

  973.     /** Convert an orbit to the instance type.
  974.      * <p>
  975.      * The returned orbit is the specified instance itself if its type already matches,
  976.      * otherwise, a new orbit of the proper type created
  977.      * </p>
  978.      * @param <T> CalculusFieldElement used
  979.      * @param orbit orbit to convert
  980.      * @return converted orbit with type guaranteed to match (so it can be cast safely)
  981.      */
  982.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertType(FieldOrbit<T> orbit);

  984.     /** Convert orbit to state array.
  985.      * <p>
  986.      * Note that all implementations of this method <em>must</em> be consistent with the
  987.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  988.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  989.      * method for the corresponding orbit type in terms of parameters order and meaning.
  990.      * </p>
  991.      * @param <T> CalculusFieldElement used
  992.      * @param orbit orbit to map
  993.      * @param type type of the angle
  994.      * @param stateVector flat array into which the state vector should be mapped
  995.      * (it can have more than 6 elements, extra elements are untouched)
  996.      * @param stateVectorDot flat array into which the state vector derivative should be mapped
  997.      * (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)
  998.      */
  999.     public abstract <T extends CalculusFieldElement<T>>void mapOrbitToArray(FieldOrbit<T> orbit, PositionAngleType type,
  1000.                                                                             T[] stateVector, T[] stateVectorDot);


  1003.     /** Convert state array to orbital parameters.
  1004.      * <p>
  1005.      * Note that all implementations of this method <em>must</em> be consistent with the
  1006.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1007.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1008.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1009.      * </p>
  1010.      * @param <T> CalculusFieldElement used
  1011.      * @param array state as a flat array
  1012.      * (it can have more than 6 elements, extra elements are ignored)
  1013.      * @param arrayDot state derivative as a flat array
  1014.      * (it can be null, in which case Keplerian motion is assumed,
  1015.      * @param type type of the angle
  1016.      * @param date integration date
  1017.      * @param mu central attraction coefficient used for propagation (m³/s²)
  1018.      * @param frame frame in which integration is performed
  1019.      * @return orbit corresponding to the flat array as a space dynamics object
  1020.      */
  1021.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> mapArrayToOrbit(T[] array,
  1022.                                                                                       T[] arrayDot,
  1023.                                                                                       PositionAngleType type,
  1024.                                                                                       FieldAbsoluteDate<T> date,
  1025.                                                                                       T mu, Frame frame);

  1027.     /** Convert an orbit to the "Fielded" instance type.
  1028.      * @param <T> CalculusFieldElement used
  1029.      * @param field CalculusField
  1030.      * @param orbit base orbit
  1031.      * @return converted FieldOrbit with type guaranteed to match (so it can be cast safely)
  1032.      * @since 12.0
  1033.      */
  1034.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertToFieldOrbit(Field<T> field,
  1035.                                                                                            Orbit orbit);

  1037.     /** Get parameters drivers initialized from a reference orbit.
  1038.      * @param dP user specified position error
  1039.      * @param orbit reference orbit
  1040.      * @param type type of the angle
  1041.      * @return parameters drivers initialized from reference orbit
  1042.      */
  1043.     public abstract ParameterDriversList getDrivers(double dP, Orbit orbit,
  1044.                                                     PositionAngleType type);

  1046.     /** Normalize one orbit with respect to a reference one.
  1047.      * <p>
  1048.      * Given a, angular component ζ of an orbit and the corresponding
  1049.      * angular component ζᵣ in the reference orbit, the angular component
  1050.      * ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ
  1051.      * where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended
  1052.      * to avoid too large discontinuities and is particularly useful
  1053.      * for normalizing the orbit after an impulsive maneuver with respect
  1054.      * to the reference picked up before the maneuver.
  1055.      * </p>
  1056.      * @param <T> CalculusFieldElement used
  1057.      * @param orbit orbit to normalize
  1058.      * @param reference reference orbit
  1059.      * @return normalized orbit (the type is guaranteed to match {@link OrbitType})
  1060.      * @since 11.1
  1061.      */
  1062.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> normalize(FieldOrbit<T> orbit,
  1063.                                                                                 FieldOrbit<T> reference);

  1065.     /** Normalize one orbit with respect to a reference one.
  1066.      * <p>
  1067.      * Given a, angular component ζ of an orbit and the corresponding
  1068.      * angular component ζᵣ in the reference orbit, the angular component
  1069.      * ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ
  1070.      * where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended
  1071.      * to avoid too large discontinuities and is particularly useful
  1072.      * for normalizing the orbit after an impulsive maneuver with respect
  1073.      * to the reference picked up before the maneuver.
  1074.      * </p>
  1075.      * @param orbit orbit to normalize
  1076.      * @param reference reference orbit
  1077.      * @return normalized orbit (the type is guaranteed to match {@link OrbitType})
  1078.      * @since 11.1
  1079.      */
  1080.     public abstract Orbit normalize(Orbit orbit, Orbit reference);

  1082.     /** Tells if the orbit type is based on position angles or not.
  1083.      * @return true if based on {@link PositionAngleType}
  1084.      * @since 12.0
  1085.      */
  1086.     public abstract boolean isPositionAngleBased();

  1088.     /** Compute scaling factor for parameters drivers.
  1089.      * <p>
  1090.      * The scales are estimated from partial derivatives properties of orbits,
  1091.      * starting from a scalar position error specified by the user.
  1092.      * Considering the energy conservation equation V = sqrt(mu (2/r - 1/a)),
  1093.      * we get at constant energy (i.e. on a Keplerian trajectory):
  1094.      * <pre>
  1095.      * V r² |dV| = mu |dr|
  1096.      * </pre>
  1097.      * <p> So we deduce a scalar velocity error consistent with the position error.
  1098.      * From here, we apply orbits Jacobians matrices to get consistent scales
  1099.      * on orbital parameters.
  1100.      *
  1101.      * @param dP user specified position error
  1102.      * @param orbit reference orbit
  1103.      * @return scaling factor array
  1104.      */
  1105.     protected double[] scale(final double dP, final Orbit orbit) {

  1107.         // estimate the scalar velocity error
  1108.         final PVCoordinates pv = orbit.getPVCoordinates();
  1109.         final double r2 = pv.getPosition().getNormSq();
  1110.         final double v  = pv.getVelocity().getNorm();
  1111.         final double dV = orbit.getMu() * dP / (v * r2);

  1113.         final double[] scale = new double[6];

  1115.         // convert the orbit to the desired type
  1116.         final double[][] jacobian = new double[6][6];
  1117.         final Orbit converted = convertType(orbit);
  1118.         converted.getJacobianWrtCartesian(PositionAngleType.TRUE, jacobian);

  1120.         for (int i = 0; i < 6; ++i) {
  1121.             final double[] row = jacobian[i];
  1122.             scale[i] = FastMath.abs(row[0]) * dP +
  1123.                        FastMath.abs(row[1]) * dP +
  1124.                        FastMath.abs(row[2]) * dP +
  1125.                        FastMath.abs(row[3]) * dV +
  1126.                        FastMath.abs(row[4]) * dV +
  1127.                        FastMath.abs(row[5]) * dV;
  1128.             if (Double.isNaN(scale[i])) {
  1129.                 throw new OrekitException(OrekitMessages.SINGULAR_JACOBIAN_FOR_ORBIT_TYPE, this);
  1130.             }
  1131.         }

  1133.         return scale;

  1135.     }

  1137. }
Created with JaCoCo 0.8.12.202403310830