OrbitType.java

  1. /* Copyright 2002-2024 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 java.util.Arrays;

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

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

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

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

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

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

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

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

  77.         }

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

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

  96.         }

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

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

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

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

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

  132.         }

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

  153.         }

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

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

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

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

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

  198.     },

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

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

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

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

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

  223.             if (stateVectorDot != null) {
  224.                 if (orbit.hasDerivatives()) {
  225.                     stateVectorDot[0] = circularOrbit.getADot();
  226.                     stateVectorDot[1] = circularOrbit.getCircularExDot();
  227.                     stateVectorDot[2] = circularOrbit.getCircularEyDot();
  228.                     stateVectorDot[3] = circularOrbit.getIDot();
  229.                     stateVectorDot[4] = circularOrbit.getRightAscensionOfAscendingNodeDot();
  230.                     stateVectorDot[5] = circularOrbit.getAlphaDot(type);
  231.                 } else {
  232.                     Arrays.fill(stateVectorDot, 0, 6, Double.NaN);
  233.                 }
  234.             }

  236.         }

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

  257.         /** {@inheritDoc} */
  258.         @Override
  259.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> convertType(final FieldOrbit<T> orbit) {
  260.             return (orbit.getType() == this) ? (FieldCircularOrbit<T>) orbit : new FieldCircularOrbit<>(orbit);
  261.         }

  263.         /** {@inheritDoc} */
  264.         @Override
  265.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  266.                                                                         final PositionAngleType type,
  267.                                                                         final T[] stateVector,
  268.                                                                         final T[] stateVectorDot) {

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

  272.             stateVector[0] = circularOrbit.getA();
  273.             stateVector[1] = circularOrbit.getCircularEx();
  274.             stateVector[2] = circularOrbit.getCircularEy();
  275.             stateVector[3] = circularOrbit.getI();
  276.             stateVector[4] = circularOrbit.getRightAscensionOfAscendingNode();
  277.             stateVector[5] = circularOrbit.getAlpha(type);

  279.             if (stateVectorDot != null) {
  280.                 if (orbit.hasDerivatives()) {
  281.                     stateVectorDot[0] = circularOrbit.getADot();
  282.                     stateVectorDot[1] = circularOrbit.getCircularExDot();
  283.                     stateVectorDot[2] = circularOrbit.getCircularEyDot();
  284.                     stateVectorDot[3] = circularOrbit.getIDot();
  285.                     stateVectorDot[4] = circularOrbit.getRightAscensionOfAscendingNodeDot();
  286.                     stateVectorDot[5] = circularOrbit.getAlphaDot(type);
  287.                 } else {
  288.                     Arrays.fill(stateVectorDot, 0, 6, orbit.getZero().add(Double.NaN));
  289.                 }
  290.             }

  292.         }

  294.         /** {@inheritDoc} */
  295.         @Override
  296.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> mapArrayToOrbit(final T[] stateVector,
  297.                                                                                          final T[] stateVectorDot, final PositionAngleType type,
  298.                                                                                          final FieldAbsoluteDate<T> date,
  299.                                                                                          final T mu, final Frame frame) {
  300.             if (stateVectorDot == null) {
  301.                 // we don't have orbit derivatives
  302.                 return new FieldCircularOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  303.                                                 stateVector[3], stateVector[4], stateVector[5],
  304.                                                 type, frame, date, mu);
  305.             } else {
  306.                 // we have orbit derivatives
  307.                 return new FieldCircularOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  308.                                                 stateVector[3],    stateVector[4],    stateVector[5],
  309.                                                 stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  310.                                                 stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  311.                                                 type, frame, date, mu);
  312.             }
  313.         }

  315.         /** {@inheritDoc} */
  316.         @Override
  317.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> convertToFieldOrbit(final Field<T> field,
  318.                                                                                              final Orbit orbit) {
  319.             return new FieldCircularOrbit<>(field, CIRCULAR.convertType(orbit));
  320.         }

  322.         /** {@inheritDoc} */
  323.         @Override
  324.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  325.             final ParameterDriversList drivers = new ParameterDriversList();
  326.             final double[] array = new double[6];
  327.             mapOrbitToArray(orbit, type, array, null);
  328.             final double[] scale = scale(dP, orbit);
  329.             final String name = type == PositionAngleType.MEAN ?
  330.                                     MEAN_LAT_ARG :
  331.                                     type == PositionAngleType.ECCENTRIC ? ECC_LAT_ARG : TRUE_LAT_ARG;
  332.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  333.             drivers.add(new ParameterDriver(E_X,  array[1], scale[1], -1.0, 1.0));
  334.             drivers.add(new ParameterDriver(E_Y,  array[2], scale[2], -1.0, 1.0));
  335.             drivers.add(new ParameterDriver(INC,  array[3], scale[3],  0.0, FastMath.PI));
  336.             drivers.add(new ParameterDriver(RAAN, array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  337.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  338.             return drivers;
  339.         }

  341.         /** {@inheritDoc} */
  342.         @Override
  343.         public CircularOrbit normalize(final Orbit orbit, final Orbit reference) {

  345.             // convert input to proper type
  346.             final CircularOrbit cO = convertType(orbit);
  347.             final CircularOrbit cR = convertType(reference);
  348.             final PositionAngleType cachedPositionAngleType = cO.getCachedPositionAngleType();

  350.             // perform normalization
  351.             if (cO.hasDerivatives()) {
  352.                 return new CircularOrbit(cO.getA(),
  353.                                          cO.getCircularEx(),
  354.                                          cO.getCircularEy(),
  355.                                          cO.getI(),
  356.                                          MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  357.                                                  cR.getRightAscensionOfAscendingNode()),
  358.                                          MathUtils.normalizeAngle(cO.getAlpha(cachedPositionAngleType),
  359.                                                  cR.getAlpha(cachedPositionAngleType)),
  360.                                          cO.getADot(),
  361.                                          cO.getCircularExDot(),
  362.                                          cO.getCircularEyDot(),
  363.                                          cO.getIDot(),
  364.                                          cO.getRightAscensionOfAscendingNodeDot(),
  365.                                          cO.getAlphaDot(cachedPositionAngleType),
  366.                                          cachedPositionAngleType,
  367.                                          cO.getFrame(),
  368.                                          cO.getDate(),
  369.                                          cO.getMu());
  370.             } else {
  371.                 return new CircularOrbit(cO.getA(),
  372.                                          cO.getCircularEx(),
  373.                                          cO.getCircularEy(),
  374.                                          cO.getI(),
  375.                                          MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  376.                                                  cR.getRightAscensionOfAscendingNode()),
  377.                                          MathUtils.normalizeAngle(cO.getAlpha(cachedPositionAngleType),
  378.                                                  cR.getAlpha(cachedPositionAngleType)),
  379.                                          cachedPositionAngleType,
  380.                                          cO.getFrame(),
  381.                                          cO.getDate(),
  382.                                          cO.getMu());
  383.             }

  385.         }

  387.         /** {@inheritDoc} */
  388.         @Override
  389.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  391.             // convert input to proper type
  392.             final FieldCircularOrbit<T> cO = convertType(orbit);
  393.             final FieldCircularOrbit<T> cR = convertType(reference);
  394.             final PositionAngleType positionAngleType = cO.getCachedPositionAngleType();

  396.             // perform normalization
  397.             if (cO.hasDerivatives()) {
  398.                 return new FieldCircularOrbit<>(cO.getA(),
  399.                                                 cO.getCircularEx(),
  400.                                                 cO.getCircularEy(),
  401.                                                 cO.getI(),
  402.                                                 MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  403.                                                         cR.getRightAscensionOfAscendingNode()),
  404.                                                 MathUtils.normalizeAngle(cO.getAlpha(positionAngleType),
  405.                                                         cR.getAlpha(positionAngleType)),
  406.                                                 cO.getADot(),
  407.                                                 cO.getCircularExDot(),
  408.                                                 cO.getCircularEyDot(),
  409.                                                 cO.getIDot(),
  410.                                                 cO.getRightAscensionOfAscendingNodeDot(),
  411.                                                 cO.getAlphaDot(positionAngleType),
  412.                                                 positionAngleType,
  413.                                                 cO.getFrame(),
  414.                                                 cO.getDate(),
  415.                                                 cO.getMu());
  416.             } else {
  417.                 return new FieldCircularOrbit<>(cO.getA(),
  418.                                                 cO.getCircularEx(),
  419.                                                 cO.getCircularEy(),
  420.                                                 cO.getI(),
  421.                                                 MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(),
  422.                                                         cR.getRightAscensionOfAscendingNode()),
  423.                                                 MathUtils.normalizeAngle(cO.getAlpha(positionAngleType),
  424.                                                         cR.getAlpha(positionAngleType)),
  425.                                                 positionAngleType,
  426.                                                 cO.getFrame(),
  427.                                                 cO.getDate(),
  428.                                                 cO.getMu());
  429.             }

  431.         }

  433.         /** {@inheritDoc} */
  434.         @Override
  435.         public boolean isPositionAngleBased() {
  436.             return true;
  437.         }

  439.     },

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

  444.         /** {@inheritDoc} */
  445.         @Override
  446.         public EquinoctialOrbit convertType(final Orbit orbit) {
  447.             return (orbit.getType() == this) ? (EquinoctialOrbit) orbit : new EquinoctialOrbit(orbit);
  448.         }

  450.         /** {@inheritDoc} */
  451.         @Override
  452.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  453.                                     final double[] stateVector, final double[] stateVectorDot) {

  455.             final EquinoctialOrbit equinoctialOrbit =
  456.                 (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(orbit);

  458.             stateVector[0] = equinoctialOrbit.getA();
  459.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  460.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  461.             stateVector[3] = equinoctialOrbit.getHx();
  462.             stateVector[4] = equinoctialOrbit.getHy();
  463.             stateVector[5] = equinoctialOrbit.getL(type);

  465.             if (stateVectorDot != null) {
  466.                 if (orbit.hasDerivatives()) {
  467.                     stateVectorDot[0] = equinoctialOrbit.getADot();
  468.                     stateVectorDot[1] = equinoctialOrbit.getEquinoctialExDot();
  469.                     stateVectorDot[2] = equinoctialOrbit.getEquinoctialEyDot();
  470.                     stateVectorDot[3] = equinoctialOrbit.getHxDot();
  471.                     stateVectorDot[4] = equinoctialOrbit.getHyDot();
  472.                     stateVectorDot[5] = equinoctialOrbit.getLDot(type);
  473.                 } else {
  474.                     Arrays.fill(stateVectorDot, 0, 6, Double.NaN);
  475.                 }
  476.             }

  478.         }

  480.         /** {@inheritDoc} */
  481.         @Override
  482.         public EquinoctialOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  483.                                                 final AbsoluteDate date, final double mu, final Frame frame) {
  484.             if (stateVectorDot == null) {
  485.                 // we don't have orbit derivatives
  486.                 return new EquinoctialOrbit(stateVector[0], stateVector[1], stateVector[2],
  487.                                             stateVector[3], stateVector[4], stateVector[5],
  488.                                             type, frame, date, mu);
  489.             } else {
  490.                 // we have orbit derivatives
  491.                 return new EquinoctialOrbit(stateVector[0],    stateVector[1],    stateVector[2],
  492.                                             stateVector[3],    stateVector[4],    stateVector[5],
  493.                                             stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  494.                                             stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  495.                                             type, frame, date, mu);
  496.             }
  497.         }

  499.         /** {@inheritDoc} */
  500.         @Override
  501.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> convertType(final FieldOrbit<T> orbit) {
  502.             return (orbit.getType() == this) ? (FieldEquinoctialOrbit<T>) orbit : new FieldEquinoctialOrbit<>(orbit);
  503.         }

  505.         /** {@inheritDoc} */
  506.         @Override
  507.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  508.                                                                         final PositionAngleType type,
  509.                                                                         final T[] stateVector,
  510.                                                                         final T[] stateVectorDot) {

  512.             final FieldEquinoctialOrbit<T> equinoctialOrbit =
  513.                 (FieldEquinoctialOrbit<T>) OrbitType.EQUINOCTIAL.convertType(orbit);

  515.             stateVector[0] = equinoctialOrbit.getA();
  516.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  517.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  518.             stateVector[3] = equinoctialOrbit.getHx();
  519.             stateVector[4] = equinoctialOrbit.getHy();
  520.             stateVector[5] = equinoctialOrbit.getL(type);

  522.             if (stateVectorDot != null) {
  523.                 if (orbit.hasDerivatives()) {
  524.                     stateVectorDot[0] = equinoctialOrbit.getADot();
  525.                     stateVectorDot[1] = equinoctialOrbit.getEquinoctialExDot();
  526.                     stateVectorDot[2] = equinoctialOrbit.getEquinoctialEyDot();
  527.                     stateVectorDot[3] = equinoctialOrbit.getHxDot();
  528.                     stateVectorDot[4] = equinoctialOrbit.getHyDot();
  529.                     stateVectorDot[5] = equinoctialOrbit.getLDot(type);
  530.                 } else {
  531.                     Arrays.fill(stateVectorDot, 0, 6, orbit.getZero().add(Double.NaN));
  532.                 }
  533.             }

  535.         }

  537.         /** {@inheritDoc} */
  538.         @Override
  539.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> mapArrayToOrbit(final T[] stateVector,
  540.                                                                                             final T[] stateVectorDot,
  541.                                                                                             final PositionAngleType type,
  542.                                                                                             final FieldAbsoluteDate<T> date,
  543.                                                                                             final T mu, final Frame frame) {
  544.             if (stateVectorDot == null) {
  545.                 // we don't have orbit derivatives
  546.                 return new FieldEquinoctialOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  547.                                                    stateVector[3], stateVector[4], stateVector[5],
  548.                                                    type, frame, date, mu);
  549.             } else {
  550.                 // we have orbit derivatives
  551.                 return new FieldEquinoctialOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  552.                                                    stateVector[3],    stateVector[4],    stateVector[5],
  553.                                                    stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  554.                                                    stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  555.                                                    type, frame, date, mu);
  556.             }
  557.         }

  559.         /** {@inheritDoc} */
  560.         @Override
  561.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> convertToFieldOrbit(final Field<T> field,
  562.                                                                                                 final Orbit orbit) {
  563.             return new FieldEquinoctialOrbit<>(field, EQUINOCTIAL.convertType(orbit));
  564.         }

  566.         /** {@inheritDoc} */
  567.         @Override
  568.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  569.             final ParameterDriversList drivers = new ParameterDriversList();
  570.             final double[] array = new double[6];
  571.             mapOrbitToArray(orbit, type, array, null);
  572.             final double[] scale = scale(dP, orbit);
  573.             final String name = type == PositionAngleType.MEAN ?
  574.                                     MEAN_LON_ARG :
  575.                                     type == PositionAngleType.ECCENTRIC ? ECC_LON_ARG : TRUE_LON_ARG;
  576.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  577.             drivers.add(new ParameterDriver(E_X,  array[1], scale[1], -1.0, 1.0));
  578.             drivers.add(new ParameterDriver(E_Y,  array[2], scale[2], -1.0, 1.0));
  579.             drivers.add(new ParameterDriver(H_X,  array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  580.             drivers.add(new ParameterDriver(H_Y,  array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  581.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  582.             return drivers;
  583.         }

  585.         /** {@inheritDoc} */
  586.         @Override
  587.         public EquinoctialOrbit normalize(final Orbit orbit, final Orbit reference) {

  589.             // convert input to proper type
  590.             final EquinoctialOrbit eO = convertType(orbit);
  591.             final EquinoctialOrbit eR = convertType(reference);
  592.             final PositionAngleType cachedPositionAngleType = eO.getCachedPositionAngleType();

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

  627.         }

  629.         /** {@inheritDoc} */
  630.         @Override
  631.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  633.             // convert input to proper type
  634.             final FieldEquinoctialOrbit<T> eO = convertType(orbit);
  635.             final FieldEquinoctialOrbit<T> eR = convertType(reference);
  636.             final PositionAngleType positionAngleType = eO.getCachedPositionAngleType();

  638.             // perform normalization
  639.             if (eO.hasDerivatives()) {
  640.                 return new FieldEquinoctialOrbit<>(eO.getA(),
  641.                                                    eO.getEquinoctialEx(),
  642.                                                    eO.getEquinoctialEy(),
  643.                                                    eO.getHx(),
  644.                                                    eO.getHy(),
  645.                                                    MathUtils.normalizeAngle(eO.getL(positionAngleType),
  646.                                                            eR.getL(positionAngleType)),
  647.                                                    eO.getADot(),
  648.                                                    eO.getEquinoctialExDot(),
  649.                                                    eO.getEquinoctialEyDot(),
  650.                                                    eO.getHxDot(),
  651.                                                    eO.getHyDot(),
  652.                                                    eO.getLDot(positionAngleType),
  653.                                                    positionAngleType,
  654.                                                    eO.getFrame(),
  655.                                                    eO.getDate(),
  656.                                                    eO.getMu());
  657.             } else {
  658.                 return new FieldEquinoctialOrbit<>(eO.getA(),
  659.                                                    eO.getEquinoctialEx(),
  660.                                                    eO.getEquinoctialEy(),
  661.                                                    eO.getHx(),
  662.                                                    eO.getHy(),
  663.                                                    MathUtils.normalizeAngle(eO.getL(positionAngleType),
  664.                                                            eR.getL(positionAngleType)),
  665.                                                    positionAngleType,
  666.                                                    eO.getFrame(),
  667.                                                    eO.getDate(),
  668.                                                    eO.getMu());
  669.             }

  671.         }

  673.         /** {@inheritDoc} */
  674.         @Override
  675.         public boolean isPositionAngleBased() {
  676.             return true;
  677.         }

  679.     },

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

  684.         /** {@inheritDoc} */
  685.         @Override
  686.         public KeplerianOrbit convertType(final Orbit orbit) {
  687.             return (orbit.getType() == this) ? (KeplerianOrbit) orbit : new KeplerianOrbit(orbit);
  688.         }

  690.         /** {@inheritDoc} */
  691.         @Override
  692.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  693.                                     final double[] stateVector, final double[] stateVectorDot) {

  695.             final KeplerianOrbit keplerianOrbit =
  696.                 (KeplerianOrbit) OrbitType.KEPLERIAN.convertType(orbit);

  698.             stateVector[0] = keplerianOrbit.getA();
  699.             stateVector[1] = keplerianOrbit.getE();
  700.             stateVector[2] = keplerianOrbit.getI();
  701.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  702.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  703.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  705.             if (stateVectorDot != null) {
  706.                 if (orbit.hasDerivatives()) {
  707.                     stateVectorDot[0] = keplerianOrbit.getADot();
  708.                     stateVectorDot[1] = keplerianOrbit.getEDot();
  709.                     stateVectorDot[2] = keplerianOrbit.getIDot();
  710.                     stateVectorDot[3] = keplerianOrbit.getPerigeeArgumentDot();
  711.                     stateVectorDot[4] = keplerianOrbit.getRightAscensionOfAscendingNodeDot();
  712.                     stateVectorDot[5] = keplerianOrbit.getAnomalyDot(type);
  713.                 } else {
  714.                     Arrays.fill(stateVectorDot, 0, 6, Double.NaN);
  715.                 }
  716.             }

  718.         }

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

  739.         /** {@inheritDoc} */
  740.         @Override
  741.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> convertType(final FieldOrbit<T> orbit) {
  742.             return (orbit.getType() == this) ? (FieldKeplerianOrbit<T>) orbit : new FieldKeplerianOrbit<>(orbit);
  743.         }

  745.         /** {@inheritDoc} */
  746.         @Override
  747.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  748.                                                                         final PositionAngleType type,
  749.                                                                         final T[] stateVector,
  750.                                                                         final T[] stateVectorDot) {
  751.             final FieldKeplerianOrbit<T> keplerianOrbit =
  752.                             (FieldKeplerianOrbit<T>) OrbitType.KEPLERIAN.convertType(orbit);

  754.             stateVector[0] = keplerianOrbit.getA();
  755.             stateVector[1] = keplerianOrbit.getE();
  756.             stateVector[2] = keplerianOrbit.getI();
  757.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  758.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  759.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  761.             if (stateVectorDot != null) {
  762.                 if (orbit.hasDerivatives()) {
  763.                     stateVectorDot[0] = keplerianOrbit.getADot();
  764.                     stateVectorDot[1] = keplerianOrbit.getEDot();
  765.                     stateVectorDot[2] = keplerianOrbit.getIDot();
  766.                     stateVectorDot[3] = keplerianOrbit.getPerigeeArgumentDot();
  767.                     stateVectorDot[4] = keplerianOrbit.getRightAscensionOfAscendingNodeDot();
  768.                     stateVectorDot[5] = keplerianOrbit.getAnomalyDot(type);
  769.                 } else {
  770.                     Arrays.fill(stateVectorDot, 0, 6, orbit.getZero().add(Double.NaN));
  771.                 }
  772.             }

  774.         }

  776.         /** {@inheritDoc} */
  777.         @Override
  778.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> mapArrayToOrbit(final T[] stateVector,
  779.                                                                                           final T[] stateVectorDot,
  780.                                                                                           final PositionAngleType type,
  781.                                                                                           final FieldAbsoluteDate<T> date,
  782.                                                                                           final T mu, final Frame frame) {
  783.             if (stateVectorDot == null) {
  784.                 // we don't have orbit derivatives
  785.                 return new FieldKeplerianOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  786.                                                  stateVector[3], stateVector[4], stateVector[5],
  787.                                                  type, frame, date, mu);
  788.             } else {
  789.                 // we have orbit derivatives
  790.                 return new FieldKeplerianOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  791.                                                  stateVector[3],    stateVector[4],    stateVector[5],
  792.                                                  stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  793.                                                  stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  794.                                                  type, frame, date, mu);
  795.             }
  796.         }

  798.         /** {@inheritDoc} */
  799.         @Override
  800.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> convertToFieldOrbit(final Field<T> field,
  801.                                                                                               final Orbit orbit) {
  802.             return new FieldKeplerianOrbit<>(field, KEPLERIAN.convertType(orbit));
  803.         }

  805.         /** {@inheritDoc} */
  806.         @Override
  807.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  808.             final ParameterDriversList drivers = new ParameterDriversList();
  809.             final double[] array = new double[6];
  810.             mapOrbitToArray(orbit, type, array, null);
  811.             final double[] scale = scale(dP, orbit);
  812.             final String name = type == PositionAngleType.MEAN ?
  813.                                     MEAN_ANOM :
  814.                                     type == PositionAngleType.ECCENTRIC ? ECC_ANOM : TRUE_ANOM;
  815.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  816.             drivers.add(new ParameterDriver(ECC,  array[1], scale[1],  0.0, 1.0));
  817.             drivers.add(new ParameterDriver(INC,  array[2], scale[2],  0.0, FastMath.PI));
  818.             drivers.add(new ParameterDriver(PA,   array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  819.             drivers.add(new ParameterDriver(RAAN, array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  820.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  821.             return drivers;
  822.         }

  824.         /** {@inheritDoc} */
  825.         @Override
  826.         public KeplerianOrbit normalize(final Orbit orbit, final Orbit reference) {

  828.             // convert input to proper type
  829.             final KeplerianOrbit kO = convertType(orbit);
  830.             final KeplerianOrbit kR = convertType(reference);
  831.             final PositionAngleType cachedPositionAngleType = kO.getCachedPositionAngleType();

  833.             // perform normalization
  834.             if (kO.hasDerivatives()) {
  835.                 return new KeplerianOrbit(kO.getA(),
  836.                                           kO.getE(),
  837.                                           kO.getI(),
  838.                                           MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  839.                                           MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(),
  840.                                                   kR.getRightAscensionOfAscendingNode()),
  841.                                           MathUtils.normalizeAngle(kO.getAnomaly(cachedPositionAngleType),
  842.                                                   kR.getAnomaly(cachedPositionAngleType)),
  843.                                           kO.getADot(),
  844.                                           kO.getEDot(),
  845.                                           kO.getIDot(),
  846.                                           kO.getPerigeeArgumentDot(),
  847.                                           kO.getRightAscensionOfAscendingNodeDot(),
  848.                                           kO.getAnomalyDot(cachedPositionAngleType),
  849.                                           cachedPositionAngleType,
  850.                                           kO.getFrame(),
  851.                                           kO.getDate(),
  852.                                           kO.getMu());
  853.             } else {
  854.                 return new KeplerianOrbit(kO.getA(),
  855.                                           kO.getE(),
  856.                                           kO.getI(),
  857.                                           MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  858.                                           MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(), kR.getRightAscensionOfAscendingNode()),
  859.                                           MathUtils.normalizeAngle(kO.getAnomaly(cachedPositionAngleType),
  860.                                                   kR.getAnomaly(cachedPositionAngleType)),
  861.                                           cachedPositionAngleType,
  862.                                           kO.getFrame(),
  863.                                           kO.getDate(),
  864.                                           kO.getMu());
  865.             }

  867.         }

  869.         /** {@inheritDoc} */
  870.         @Override
  871.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  873.             // convert input to proper type
  874.             final FieldKeplerianOrbit<T> kO = convertType(orbit);
  875.             final FieldKeplerianOrbit<T> kR = convertType(reference);
  876.             final PositionAngleType positionAngleType = kO.getCachedPositionAngleType();

  878.             // perform normalization
  879.             if (kO.hasDerivatives()) {
  880.                 return new FieldKeplerianOrbit<>(kO.getA(),
  881.                                                  kO.getE(),
  882.                                                  kO.getI(),
  883.                                                  MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  884.                                                  MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(),
  885.                                                          kR.getRightAscensionOfAscendingNode()),
  886.                                                  MathUtils.normalizeAngle(kO.getAnomaly(positionAngleType),
  887.                                                          kR.getAnomaly(positionAngleType)),
  888.                                                  kO.getADot(),
  889.                                                  kO.getEDot(),
  890.                                                  kO.getIDot(),
  891.                                                  kO.getPerigeeArgumentDot(),
  892.                                                  kO.getRightAscensionOfAscendingNodeDot(),
  893.                                                  kO.getAnomalyDot(positionAngleType),
  894.                                                  positionAngleType,
  895.                                                  kO.getFrame(),
  896.                                                  kO.getDate(),
  897.                                                  kO.getMu());
  898.             } else {
  899.                 return new FieldKeplerianOrbit<>(kO.getA(),
  900.                                                  kO.getE(),
  901.                                                  kO.getI(),
  902.                                                  MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  903.                                                  MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(),
  904.                                                          kR.getRightAscensionOfAscendingNode()),
  905.                                                  MathUtils.normalizeAngle(kO.getAnomaly(positionAngleType),
  906.                                                          kR.getAnomaly(positionAngleType)),
  907.                                                  positionAngleType,
  908.                                                  kO.getFrame(),
  909.                                                  kO.getDate(),
  910.                                                  kO.getMu());
  911.             }

  913.         }

  915.         /** {@inheritDoc} */
  916.         @Override
  917.         public boolean isPositionAngleBased() {
  918.             return true;
  919.         }

  921.     };

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

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

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

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

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

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

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

  944.     /** Name for eccentricity. */
  945.     public static final String ECC   = "e";

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

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

  953.     /** Name for inclination. */
  954.     public static final String INC   = "i";

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

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

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

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

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

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

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

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

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

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

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

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

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

  995.     /** Convert an orbit to the instance type.
  996.      * <p>
  997.      * The returned orbit is the specified instance itself if its type already matches,
  998.      * otherwise, a new orbit of the proper type created
  999.      * </p>
  1000.      * @param orbit orbit to convert
  1001.      * @return converted orbit with type guaranteed to match (so it can be cast safely)
  1002.      */
  1003.     public abstract Orbit convertType(Orbit orbit);

  1005.     /** Convert orbit to state array.
  1006.      * <p>
  1007.      * Note that all implementations of this method <em>must</em> be consistent with the
  1008.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1009.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1010.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1011.      * </p>
  1012.      * @param orbit orbit to map
  1013.      * @param type type of the angle
  1014.      * @param stateVector flat array into which the state vector should be mapped
  1015.      * (it can have more than 6 elements, extra elements are untouched)
  1016.      * @param stateVectorDot flat array into which the state vector derivative should be mapped
  1017.      * (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)
  1018.      */
  1019.     public abstract void mapOrbitToArray(Orbit orbit, PositionAngleType type, double[] stateVector, double[] stateVectorDot);

  1021.      /** Convert state array to orbital parameters.
  1022.      * <p>
  1023.      * Note that all implementations of this method <em>must</em> be consistent with the
  1024.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1025.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1026.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1027.      * </p>
  1028.      * @param array state as a flat array
  1029.      * (it can have more than 6 elements, extra elements are ignored)
  1030.      * @param arrayDot state derivative as a flat array
  1031.      * (it can be null, in which case Keplerian motion is assumed,
  1032.      * and it can have more than 6 elements, extra elements are ignored)
  1033.      * @param type type of the angle
  1034.      * @param date integration date
  1035.      * @param mu central attraction coefficient used for propagation (m³/s²)
  1036.      * @param frame frame in which integration is performed
  1037.      * @return orbit corresponding to the flat array as a space dynamics object
  1038.      */
  1039.     public abstract Orbit mapArrayToOrbit(double[] array, double[] arrayDot, PositionAngleType type,
  1040.                                           AbsoluteDate date, double mu, Frame frame);

  1042.     /** Convert an orbit to the instance type.
  1043.      * <p>
  1044.      * The returned orbit is the specified instance itself if its type already matches,
  1045.      * otherwise, a new orbit of the proper type created
  1046.      * </p>
  1047.      * @param <T> CalculusFieldElement used
  1048.      * @param orbit orbit to convert
  1049.      * @return converted orbit with type guaranteed to match (so it can be cast safely)
  1050.      */
  1051.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertType(FieldOrbit<T> orbit);

  1053.     /** Convert orbit to state array.
  1054.      * <p>
  1055.      * Note that all implementations of this method <em>must</em> be consistent with the
  1056.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1057.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1058.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1059.      * </p>
  1060.      * @param <T> CalculusFieldElement used
  1061.      * @param orbit orbit to map
  1062.      * @param type type of the angle
  1063.      * @param stateVector flat array into which the state vector should be mapped
  1064.      * (it can have more than 6 elements, extra elements are untouched)
  1065.      * @param stateVectorDot flat array into which the state vector derivative should be mapped
  1066.      * (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)
  1067.      */
  1068.     public abstract <T extends CalculusFieldElement<T>>void mapOrbitToArray(FieldOrbit<T> orbit, PositionAngleType type,
  1069.                                                                             T[] stateVector, T[] stateVectorDot);


  1072.     /** Convert state array to orbital parameters.
  1073.      * <p>
  1074.      * Note that all implementations of this method <em>must</em> be consistent with the
  1075.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1076.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1077.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1078.      * </p>
  1079.      * @param <T> CalculusFieldElement used
  1080.      * @param array state as a flat array
  1081.      * (it can have more than 6 elements, extra elements are ignored)
  1082.      * @param arrayDot state derivative as a flat array
  1083.      * (it can be null, in which case Keplerian motion is assumed,
  1084.      * @param type type of the angle
  1085.      * @param date integration date
  1086.      * @param mu central attraction coefficient used for propagation (m³/s²)
  1087.      * @param frame frame in which integration is performed
  1088.      * @return orbit corresponding to the flat array as a space dynamics object
  1089.      */
  1090.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> mapArrayToOrbit(T[] array,
  1091.                                                                                       T[] arrayDot,
  1092.                                                                                       PositionAngleType type,
  1093.                                                                                       FieldAbsoluteDate<T> date,
  1094.                                                                                       T mu, Frame frame);

  1096.     /** Convert an orbit to the "Fielded" instance type.
  1097.      * @param <T> CalculusFieldElement used
  1098.      * @param field CalculusField
  1099.      * @param orbit base orbit
  1100.      * @return converted FieldOrbit with type guaranteed to match (so it can be cast safely)
  1101.      * @since 12.0
  1102.      */
  1103.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertToFieldOrbit(Field<T> field,
  1104.                                                                                            Orbit orbit);

  1106.     /** Get parameters drivers initialized from a reference orbit.
  1107.      * @param dP user specified position error
  1108.      * @param orbit reference orbit
  1109.      * @param type type of the angle
  1110.      * @return parameters drivers initialized from reference orbit
  1111.      */
  1112.     public abstract ParameterDriversList getDrivers(double dP, Orbit orbit,
  1113.                                                     PositionAngleType type);

  1115.     /** Normalize one orbit with respect to a reference one.
  1116.      * <p>
  1117.      * Given a, angular component ζ of an orbit and the corresponding
  1118.      * angular component ζᵣ in the reference orbit, the angular component
  1119.      * ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ
  1120.      * where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended
  1121.      * to avoid too large discontinuities and is particularly useful
  1122.      * for normalizing the orbit after an impulsive maneuver with respect
  1123.      * to the reference picked up before the maneuver.
  1124.      * </p>
  1125.      * @param <T> CalculusFieldElement used
  1126.      * @param orbit orbit to normalize
  1127.      * @param reference reference orbit
  1128.      * @return normalized orbit (the type is guaranteed to match {@link OrbitType})
  1129.      * @since 11.1
  1130.      */
  1131.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> normalize(FieldOrbit<T> orbit,
  1132.                                                                                 FieldOrbit<T> reference);

  1134.     /** Normalize one orbit with respect to a reference one.
  1135.      * <p>
  1136.      * Given a, angular component ζ of an orbit and the corresponding
  1137.      * angular component ζᵣ in the reference orbit, the angular component
  1138.      * ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ
  1139.      * where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended
  1140.      * to avoid too large discontinuities and is particularly useful
  1141.      * for normalizing the orbit after an impulsive maneuver with respect
  1142.      * to the reference picked up before the maneuver.
  1143.      * </p>
  1144.      * @param orbit orbit to normalize
  1145.      * @param reference reference orbit
  1146.      * @return normalized orbit (the type is guaranteed to match {@link OrbitType})
  1147.      * @since 11.1
  1148.      */
  1149.     public abstract Orbit normalize(Orbit orbit, Orbit reference);

  1151.     /** Tells if the orbit type is based on position angles or not.
  1152.      * @return true if based on {@link PositionAngleType}
  1153.      * @since 12.0
  1154.      */
  1155.     public abstract boolean isPositionAngleBased();

  1157.     /** Compute scaling factor for parameters drivers.
  1158.      * <p>
  1159.      * The scales are estimated from partial derivatives properties of orbits,
  1160.      * starting from a scalar position error specified by the user.
  1161.      * Considering the energy conservation equation V = sqrt(mu (2/r - 1/a)),
  1162.      * we get at constant energy (i.e. on a Keplerian trajectory):
  1163.      * <pre>
  1164.      * V r² |dV| = mu |dr|
  1165.      * </pre>
  1166.      * <p> So we deduce a scalar velocity error consistent with the position error.
  1167.      * From here, we apply orbits Jacobians matrices to get consistent scales
  1168.      * on orbital parameters.
  1169.      *
  1170.      * @param dP user specified position error
  1171.      * @param orbit reference orbit
  1172.      * @return scaling factor array
  1173.      */
  1174.     protected double[] scale(final double dP, final Orbit orbit) {

  1176.         // estimate the scalar velocity error
  1177.         final PVCoordinates pv = orbit.getPVCoordinates();
  1178.         final double r2 = pv.getPosition().getNormSq();
  1179.         final double v  = pv.getVelocity().getNorm();
  1180.         final double dV = orbit.getMu() * dP / (v * r2);

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

  1184.         // convert the orbit to the desired type
  1185.         final double[][] jacobian = new double[6][6];
  1186.         final Orbit converted = convertType(orbit);
  1187.         converted.getJacobianWrtCartesian(PositionAngleType.TRUE, jacobian);

  1189.         for (int i = 0; i < 6; ++i) {
  1190.             final double[] row = jacobian[i];
  1191.             scale[i] = FastMath.abs(row[0]) * dP +
  1192.                        FastMath.abs(row[1]) * dP +
  1193.                        FastMath.abs(row[2]) * dP +
  1194.                        FastMath.abs(row[3]) * dV +
  1195.                        FastMath.abs(row[4]) * dV +
  1196.                        FastMath.abs(row[5]) * dV;
  1197.             if (Double.isNaN(scale[i])) {
  1198.                 throw new OrekitException(OrekitMessages.SINGULAR_JACOBIAN_FOR_ORBIT_TYPE, this);
  1199.             }
  1200.         }

  1202.         return scale;

  1204.     }

  1206. }
Created with JaCoCo 0.8.12.202403310830