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);

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

  380.         }

  382.         /** {@inheritDoc} */
  383.         @Override
  384.         public <T extends CalculusFieldElement<T>> FieldCircularOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  386.             // convert input to proper type
  387.             final FieldCircularOrbit<T> cO = convertType(orbit);
  388.             final FieldCircularOrbit<T> cR = convertType(reference);

  390.             // perform normalization
  391.             if (cO.hasDerivatives()) {
  392.                 return new FieldCircularOrbit<>(cO.getA(),
  393.                                                 cO.getCircularEx(),
  394.                                                 cO.getCircularEy(),
  395.                                                 cO.getI(),
  396.                                                 MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(), cR.getRightAscensionOfAscendingNode()),
  397.                                                 MathUtils.normalizeAngle(cO.getAlphaV(), cR.getAlphaV()),
  398.                                                 cO.getADot(),
  399.                                                 cO.getCircularExDot(),
  400.                                                 cO.getCircularEyDot(),
  401.                                                 cO.getIDot(),
  402.                                                 cO.getRightAscensionOfAscendingNodeDot(),
  403.                                                 cO.getAlphaVDot(),
  404.                                                 PositionAngleType.TRUE,
  405.                                                 cO.getFrame(),
  406.                                                 cO.getDate(),
  407.                                                 cO.getMu());
  408.             } else {
  409.                 return new FieldCircularOrbit<>(cO.getA(),
  410.                                                 cO.getCircularEx(),
  411.                                                 cO.getCircularEy(),
  412.                                                 cO.getI(),
  413.                                                 MathUtils.normalizeAngle(cO.getRightAscensionOfAscendingNode(), cR.getRightAscensionOfAscendingNode()),
  414.                                                 MathUtils.normalizeAngle(cO.getAlphaV(), cR.getAlphaV()),
  415.                                                 PositionAngleType.TRUE,
  416.                                                 cO.getFrame(),
  417.                                                 cO.getDate(),
  418.                                                 cO.getMu());
  419.             }

  421.         }

  423.         /** {@inheritDoc} */
  424.         @Override
  425.         public boolean isPositionAngleBased() {
  426.             return true;
  427.         }

  429.     },

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

  434.         /** {@inheritDoc} */
  435.         @Override
  436.         public EquinoctialOrbit convertType(final Orbit orbit) {
  437.             return (orbit.getType() == this) ? (EquinoctialOrbit) orbit : new EquinoctialOrbit(orbit);
  438.         }

  440.         /** {@inheritDoc} */
  441.         @Override
  442.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  443.                                     final double[] stateVector, final double[] stateVectorDot) {

  445.             final EquinoctialOrbit equinoctialOrbit =
  446.                 (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(orbit);

  448.             stateVector[0] = equinoctialOrbit.getA();
  449.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  450.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  451.             stateVector[3] = equinoctialOrbit.getHx();
  452.             stateVector[4] = equinoctialOrbit.getHy();
  453.             stateVector[5] = equinoctialOrbit.getL(type);

  455.             if (stateVectorDot != null) {
  456.                 if (orbit.hasDerivatives()) {
  457.                     stateVectorDot[0] = equinoctialOrbit.getADot();
  458.                     stateVectorDot[1] = equinoctialOrbit.getEquinoctialExDot();
  459.                     stateVectorDot[2] = equinoctialOrbit.getEquinoctialEyDot();
  460.                     stateVectorDot[3] = equinoctialOrbit.getHxDot();
  461.                     stateVectorDot[4] = equinoctialOrbit.getHyDot();
  462.                     stateVectorDot[5] = equinoctialOrbit.getLDot(type);
  463.                 } else {
  464.                     Arrays.fill(stateVectorDot, 0, 6, Double.NaN);
  465.                 }
  466.             }

  468.         }

  470.         /** {@inheritDoc} */
  471.         @Override
  472.         public EquinoctialOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  473.                                                 final AbsoluteDate date, final double mu, final Frame frame) {
  474.             if (stateVectorDot == null) {
  475.                 // we don't have orbit derivatives
  476.                 return new EquinoctialOrbit(stateVector[0], stateVector[1], stateVector[2],
  477.                                             stateVector[3], stateVector[4], stateVector[5],
  478.                                             type, frame, date, mu);
  479.             } else {
  480.                 // we have orbit derivatives
  481.                 return new EquinoctialOrbit(stateVector[0],    stateVector[1],    stateVector[2],
  482.                                             stateVector[3],    stateVector[4],    stateVector[5],
  483.                                             stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  484.                                             stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  485.                                             type, frame, date, mu);
  486.             }
  487.         }

  489.         /** {@inheritDoc} */
  490.         @Override
  491.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> convertType(final FieldOrbit<T> orbit) {
  492.             return (orbit.getType() == this) ? (FieldEquinoctialOrbit<T>) orbit : new FieldEquinoctialOrbit<>(orbit);
  493.         }

  495.         /** {@inheritDoc} */
  496.         @Override
  497.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  498.                                                                         final PositionAngleType type,
  499.                                                                         final T[] stateVector,
  500.                                                                         final T[] stateVectorDot) {

  502.             final FieldEquinoctialOrbit<T> equinoctialOrbit =
  503.                 (FieldEquinoctialOrbit<T>) OrbitType.EQUINOCTIAL.convertType(orbit);

  505.             stateVector[0] = equinoctialOrbit.getA();
  506.             stateVector[1] = equinoctialOrbit.getEquinoctialEx();
  507.             stateVector[2] = equinoctialOrbit.getEquinoctialEy();
  508.             stateVector[3] = equinoctialOrbit.getHx();
  509.             stateVector[4] = equinoctialOrbit.getHy();
  510.             stateVector[5] = equinoctialOrbit.getL(type);

  512.             if (stateVectorDot != null) {
  513.                 if (orbit.hasDerivatives()) {
  514.                     stateVectorDot[0] = equinoctialOrbit.getADot();
  515.                     stateVectorDot[1] = equinoctialOrbit.getEquinoctialExDot();
  516.                     stateVectorDot[2] = equinoctialOrbit.getEquinoctialEyDot();
  517.                     stateVectorDot[3] = equinoctialOrbit.getHxDot();
  518.                     stateVectorDot[4] = equinoctialOrbit.getHyDot();
  519.                     stateVectorDot[5] = equinoctialOrbit.getLDot(type);
  520.                 } else {
  521.                     Arrays.fill(stateVectorDot, 0, 6, orbit.getZero().add(Double.NaN));
  522.                 }
  523.             }

  525.         }

  527.         /** {@inheritDoc} */
  528.         @Override
  529.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> mapArrayToOrbit(final T[] stateVector,
  530.                                                                                             final T[] stateVectorDot,
  531.                                                                                             final PositionAngleType type,
  532.                                                                                             final FieldAbsoluteDate<T> date,
  533.                                                                                             final T mu, final Frame frame) {
  534.             if (stateVectorDot == null) {
  535.                 // we don't have orbit derivatives
  536.                 return new FieldEquinoctialOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  537.                                                    stateVector[3], stateVector[4], stateVector[5],
  538.                                                    type, frame, date, mu);
  539.             } else {
  540.                 // we have orbit derivatives
  541.                 return new FieldEquinoctialOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  542.                                                    stateVector[3],    stateVector[4],    stateVector[5],
  543.                                                    stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  544.                                                    stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  545.                                                    type, frame, date, mu);
  546.             }
  547.         }

  549.         /** {@inheritDoc} */
  550.         @Override
  551.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> convertToFieldOrbit(final Field<T> field,
  552.                                                                                                 final Orbit orbit) {
  553.             return new FieldEquinoctialOrbit<>(field, EQUINOCTIAL.convertType(orbit));
  554.         }

  556.         /** {@inheritDoc} */
  557.         @Override
  558.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  559.             final ParameterDriversList drivers = new ParameterDriversList();
  560.             final double[] array = new double[6];
  561.             mapOrbitToArray(orbit, type, array, null);
  562.             final double[] scale = scale(dP, orbit);
  563.             final String name = type == PositionAngleType.MEAN ?
  564.                                     MEAN_LON_ARG :
  565.                                     type == PositionAngleType.ECCENTRIC ? ECC_LON_ARG : TRUE_LON_ARG;
  566.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  567.             drivers.add(new ParameterDriver(E_X,  array[1], scale[1], -1.0, 1.0));
  568.             drivers.add(new ParameterDriver(E_Y,  array[2], scale[2], -1.0, 1.0));
  569.             drivers.add(new ParameterDriver(H_X,  array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  570.             drivers.add(new ParameterDriver(H_Y,  array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  571.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  572.             return drivers;
  573.         }

  575.         /** {@inheritDoc} */
  576.         @Override
  577.         public EquinoctialOrbit normalize(final Orbit orbit, final Orbit reference) {

  579.             // convert input to proper type
  580.             final EquinoctialOrbit eO = convertType(orbit);
  581.             final EquinoctialOrbit eR = convertType(reference);

  583.             // perform normalization
  584.             if (eO.hasDerivatives()) {
  585.                 return new EquinoctialOrbit(eO.getA(),
  586.                                             eO.getEquinoctialEx(),
  587.                                             eO.getEquinoctialEy(),
  588.                                             eO.getHx(),
  589.                                             eO.getHy(),
  590.                                             MathUtils.normalizeAngle(eO.getLv(), eR.getLv()),
  591.                                             eO.getADot(),
  592.                                             eO.getEquinoctialExDot(),
  593.                                             eO.getEquinoctialEyDot(),
  594.                                             eO.getHxDot(),
  595.                                             eO.getHyDot(),
  596.                                             eO.getLvDot(),
  597.                                             PositionAngleType.TRUE,
  598.                                             eO.getFrame(),
  599.                                             eO.getDate(),
  600.                                             eO.getMu());
  601.             } else {
  602.                 return new EquinoctialOrbit(eO.getA(),
  603.                                             eO.getEquinoctialEx(),
  604.                                             eO.getEquinoctialEy(),
  605.                                             eO.getHx(),
  606.                                             eO.getHy(),
  607.                                             MathUtils.normalizeAngle(eO.getLv(), eR.getLv()),
  608.                                             PositionAngleType.TRUE,
  609.                                             eO.getFrame(),
  610.                                             eO.getDate(),
  611.                                             eO.getMu());
  612.             }

  614.         }

  616.         /** {@inheritDoc} */
  617.         @Override
  618.         public <T extends CalculusFieldElement<T>> FieldEquinoctialOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  620.             // convert input to proper type
  621.             final FieldEquinoctialOrbit<T> eO = convertType(orbit);
  622.             final FieldEquinoctialOrbit<T> eR = convertType(reference);

  624.             // perform normalization
  625.             if (eO.hasDerivatives()) {
  626.                 return new FieldEquinoctialOrbit<>(eO.getA(),
  627.                                                    eO.getEquinoctialEx(),
  628.                                                    eO.getEquinoctialEy(),
  629.                                                    eO.getHx(),
  630.                                                    eO.getHy(),
  631.                                                    MathUtils.normalizeAngle(eO.getLv(), eR.getLv()),
  632.                                                    eO.getADot(),
  633.                                                    eO.getEquinoctialExDot(),
  634.                                                    eO.getEquinoctialEyDot(),
  635.                                                    eO.getHxDot(),
  636.                                                    eO.getHyDot(),
  637.                                                    eO.getLvDot(),
  638.                                                    PositionAngleType.TRUE,
  639.                                                    eO.getFrame(),
  640.                                                    eO.getDate(),
  641.                                                    eO.getMu());
  642.             } else {
  643.                 return new FieldEquinoctialOrbit<>(eO.getA(),
  644.                                                    eO.getEquinoctialEx(),
  645.                                                    eO.getEquinoctialEy(),
  646.                                                    eO.getHx(),
  647.                                                    eO.getHy(),
  648.                                                    MathUtils.normalizeAngle(eO.getLv(), eR.getLv()),
  649.                                                    PositionAngleType.TRUE,
  650.                                                    eO.getFrame(),
  651.                                                    eO.getDate(),
  652.                                                    eO.getMu());
  653.             }

  655.         }

  657.         /** {@inheritDoc} */
  658.         @Override
  659.         public boolean isPositionAngleBased() {
  660.             return true;
  661.         }

  663.     },

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

  668.         /** {@inheritDoc} */
  669.         @Override
  670.         public KeplerianOrbit convertType(final Orbit orbit) {
  671.             return (orbit.getType() == this) ? (KeplerianOrbit) orbit : new KeplerianOrbit(orbit);
  672.         }

  674.         /** {@inheritDoc} */
  675.         @Override
  676.         public void mapOrbitToArray(final Orbit orbit, final PositionAngleType type,
  677.                                     final double[] stateVector, final double[] stateVectorDot) {

  679.             final KeplerianOrbit keplerianOrbit =
  680.                 (KeplerianOrbit) OrbitType.KEPLERIAN.convertType(orbit);

  682.             stateVector[0] = keplerianOrbit.getA();
  683.             stateVector[1] = keplerianOrbit.getE();
  684.             stateVector[2] = keplerianOrbit.getI();
  685.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  686.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  687.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  689.             if (stateVectorDot != null) {
  690.                 if (orbit.hasDerivatives()) {
  691.                     stateVectorDot[0] = keplerianOrbit.getADot();
  692.                     stateVectorDot[1] = keplerianOrbit.getEDot();
  693.                     stateVectorDot[2] = keplerianOrbit.getIDot();
  694.                     stateVectorDot[3] = keplerianOrbit.getPerigeeArgumentDot();
  695.                     stateVectorDot[4] = keplerianOrbit.getRightAscensionOfAscendingNodeDot();
  696.                     stateVectorDot[5] = keplerianOrbit.getAnomalyDot(type);
  697.                 } else {
  698.                     Arrays.fill(stateVectorDot, 0, 6, Double.NaN);
  699.                 }
  700.             }

  702.         }

  704.         /** {@inheritDoc} */
  705.         @Override
  706.         public KeplerianOrbit mapArrayToOrbit(final double[] stateVector, final double[] stateVectorDot, final PositionAngleType type,
  707.                                               final AbsoluteDate date, final double mu, final Frame frame) {
  708.             if (stateVectorDot == null) {
  709.                 // we don't have orbit derivatives
  710.                 return new KeplerianOrbit(stateVector[0], stateVector[1], stateVector[2],
  711.                                           stateVector[3], stateVector[4], stateVector[5],
  712.                                           type, frame, date, mu);
  713.             } else {
  714.                 // we have orbit derivatives
  715.                 return new KeplerianOrbit(stateVector[0],    stateVector[1],    stateVector[2],
  716.                                           stateVector[3],    stateVector[4],    stateVector[5],
  717.                                           stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  718.                                           stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  719.                                           type, frame, date, mu);
  720.             }
  721.         }

  723.         /** {@inheritDoc} */
  724.         @Override
  725.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> convertType(final FieldOrbit<T> orbit) {
  726.             return (orbit.getType() == this) ? (FieldKeplerianOrbit<T>) orbit : new FieldKeplerianOrbit<>(orbit);
  727.         }

  729.         /** {@inheritDoc} */
  730.         @Override
  731.         public <T extends CalculusFieldElement<T>> void mapOrbitToArray(final FieldOrbit<T> orbit,
  732.                                                                         final PositionAngleType type,
  733.                                                                         final T[] stateVector,
  734.                                                                         final T[] stateVectorDot) {
  735.             final FieldKeplerianOrbit<T> keplerianOrbit =
  736.                             (FieldKeplerianOrbit<T>) OrbitType.KEPLERIAN.convertType(orbit);

  738.             stateVector[0] = keplerianOrbit.getA();
  739.             stateVector[1] = keplerianOrbit.getE();
  740.             stateVector[2] = keplerianOrbit.getI();
  741.             stateVector[3] = keplerianOrbit.getPerigeeArgument();
  742.             stateVector[4] = keplerianOrbit.getRightAscensionOfAscendingNode();
  743.             stateVector[5] = keplerianOrbit.getAnomaly(type);

  745.             if (stateVectorDot != null) {
  746.                 if (orbit.hasDerivatives()) {
  747.                     stateVectorDot[0] = keplerianOrbit.getADot();
  748.                     stateVectorDot[1] = keplerianOrbit.getEDot();
  749.                     stateVectorDot[2] = keplerianOrbit.getIDot();
  750.                     stateVectorDot[3] = keplerianOrbit.getPerigeeArgumentDot();
  751.                     stateVectorDot[4] = keplerianOrbit.getRightAscensionOfAscendingNodeDot();
  752.                     stateVectorDot[5] = keplerianOrbit.getAnomalyDot(type);
  753.                 } else {
  754.                     Arrays.fill(stateVectorDot, 0, 6, orbit.getZero().add(Double.NaN));
  755.                 }
  756.             }

  758.         }

  760.         /** {@inheritDoc} */
  761.         @Override
  762.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> mapArrayToOrbit(final T[] stateVector,
  763.                                                                                           final T[] stateVectorDot,
  764.                                                                                           final PositionAngleType type,
  765.                                                                                           final FieldAbsoluteDate<T> date,
  766.                                                                                           final T mu, final Frame frame) {
  767.             if (stateVectorDot == null) {
  768.                 // we don't have orbit derivatives
  769.                 return new FieldKeplerianOrbit<>(stateVector[0], stateVector[1], stateVector[2],
  770.                                                  stateVector[3], stateVector[4], stateVector[5],
  771.                                                  type, frame, date, mu);
  772.             } else {
  773.                 // we have orbit derivatives
  774.                 return new FieldKeplerianOrbit<>(stateVector[0],    stateVector[1],    stateVector[2],
  775.                                                  stateVector[3],    stateVector[4],    stateVector[5],
  776.                                                  stateVectorDot[0], stateVectorDot[1], stateVectorDot[2],
  777.                                                  stateVectorDot[3], stateVectorDot[4], stateVectorDot[5],
  778.                                                  type, frame, date, mu);
  779.             }
  780.         }

  782.         /** {@inheritDoc} */
  783.         @Override
  784.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> convertToFieldOrbit(final Field<T> field,
  785.                                                                                               final Orbit orbit) {
  786.             return new FieldKeplerianOrbit<>(field, KEPLERIAN.convertType(orbit));
  787.         }

  789.         /** {@inheritDoc} */
  790.         @Override
  791.         public ParameterDriversList getDrivers(final double dP, final Orbit orbit, final PositionAngleType type) {
  792.             final ParameterDriversList drivers = new ParameterDriversList();
  793.             final double[] array = new double[6];
  794.             mapOrbitToArray(orbit, type, array, null);
  795.             final double[] scale = scale(dP, orbit);
  796.             final String name = type == PositionAngleType.MEAN ?
  797.                                     MEAN_ANOM :
  798.                                     type == PositionAngleType.ECCENTRIC ? ECC_ANOM : TRUE_ANOM;
  799.             drivers.add(new ParameterDriver(A,    array[0], scale[0],  0.0, Double.POSITIVE_INFINITY));
  800.             drivers.add(new ParameterDriver(ECC,  array[1], scale[1],  0.0, 1.0));
  801.             drivers.add(new ParameterDriver(INC,  array[2], scale[2],  0.0, FastMath.PI));
  802.             drivers.add(new ParameterDriver(PA,   array[3], scale[3], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  803.             drivers.add(new ParameterDriver(RAAN, array[4], scale[4], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  804.             drivers.add(new ParameterDriver(name, array[5], scale[5], Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
  805.             return drivers;
  806.         }

  808.         /** {@inheritDoc} */
  809.         @Override
  810.         public KeplerianOrbit normalize(final Orbit orbit, final Orbit reference) {

  812.             // convert input to proper type
  813.             final KeplerianOrbit kO = convertType(orbit);
  814.             final KeplerianOrbit kR = convertType(reference);

  816.             // perform normalization
  817.             if (kO.hasDerivatives()) {
  818.                 return new KeplerianOrbit(kO.getA(),
  819.                                           kO.getE(),
  820.                                           kO.getI(),
  821.                                           MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  822.                                           MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(), kR.getRightAscensionOfAscendingNode()),
  823.                                           MathUtils.normalizeAngle(kO.getTrueAnomaly(), kR.getTrueAnomaly()),
  824.                                           kO.getADot(),
  825.                                           kO.getEDot(),
  826.                                           kO.getIDot(),
  827.                                           kO.getPerigeeArgumentDot(),
  828.                                           kO.getRightAscensionOfAscendingNodeDot(),
  829.                                           kO.getTrueAnomalyDot(),
  830.                                           PositionAngleType.TRUE,
  831.                                           kO.getFrame(),
  832.                                           kO.getDate(),
  833.                                           kO.getMu());
  834.             } else {
  835.                 return new KeplerianOrbit(kO.getA(),
  836.                                           kO.getE(),
  837.                                           kO.getI(),
  838.                                           MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  839.                                           MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(), kR.getRightAscensionOfAscendingNode()),
  840.                                           MathUtils.normalizeAngle(kO.getTrueAnomaly(), kR.getTrueAnomaly()),
  841.                                           PositionAngleType.TRUE,
  842.                                           kO.getFrame(),
  843.                                           kO.getDate(),
  844.                                           kO.getMu());
  845.             }

  847.         }

  849.         /** {@inheritDoc} */
  850.         @Override
  851.         public <T extends CalculusFieldElement<T>> FieldKeplerianOrbit<T> normalize(final FieldOrbit<T> orbit, final FieldOrbit<T> reference) {

  853.             // convert input to proper type
  854.             final FieldKeplerianOrbit<T> kO = convertType(orbit);
  855.             final FieldKeplerianOrbit<T> kR = convertType(reference);

  857.             // perform normalization
  858.             if (kO.hasDerivatives()) {
  859.                 return new FieldKeplerianOrbit<>(kO.getA(),
  860.                                                  kO.getE(),
  861.                                                  kO.getI(),
  862.                                                  MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  863.                                                  MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(), kR.getRightAscensionOfAscendingNode()),
  864.                                                  MathUtils.normalizeAngle(kO.getTrueAnomaly(), kR.getTrueAnomaly()),
  865.                                                  kO.getADot(),
  866.                                                  kO.getEDot(),
  867.                                                  kO.getIDot(),
  868.                                                  kO.getPerigeeArgumentDot(),
  869.                                                  kO.getRightAscensionOfAscendingNodeDot(),
  870.                                                  kO.getTrueAnomalyDot(),
  871.                                                  PositionAngleType.TRUE,
  872.                                                  kO.getFrame(),
  873.                                                  kO.getDate(),
  874.                                                  kO.getMu());
  875.             } else {
  876.                 return new FieldKeplerianOrbit<>(kO.getA(),
  877.                                                  kO.getE(),
  878.                                                  kO.getI(),
  879.                                                  MathUtils.normalizeAngle(kO.getPerigeeArgument(), kR.getPerigeeArgument()),
  880.                                                  MathUtils.normalizeAngle(kO.getRightAscensionOfAscendingNode(), kR.getRightAscensionOfAscendingNode()),
  881.                                                  MathUtils.normalizeAngle(kO.getTrueAnomaly(), kR.getTrueAnomaly()),
  882.                                                  PositionAngleType.TRUE,
  883.                                                  kO.getFrame(),
  884.                                                  kO.getDate(),
  885.                                                  kO.getMu());
  886.             }

  888.         }

  890.         /** {@inheritDoc} */
  891.         @Override
  892.         public boolean isPositionAngleBased() {
  893.             return true;
  894.         }

  896.     };

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

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

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

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

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

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

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

  919.     /** Name for eccentricity. */
  920.     public static final String ECC   = "e";

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

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

  928.     /** Name for inclination. */
  929.     public static final String INC   = "i";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1017.     /** Convert an orbit to the instance type.
  1018.      * <p>
  1019.      * The returned orbit is the specified instance itself if its type already matches,
  1020.      * otherwise, a new orbit of the proper type created
  1021.      * </p>
  1022.      * @param <T> CalculusFieldElement used
  1023.      * @param orbit orbit to convert
  1024.      * @return converted orbit with type guaranteed to match (so it can be cast safely)
  1025.      */
  1026.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertType(FieldOrbit<T> orbit);

  1028.     /** Convert orbit to state array.
  1029.      * <p>
  1030.      * Note that all implementations of this method <em>must</em> be consistent with the
  1031.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1032.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1033.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1034.      * </p>
  1035.      * @param <T> CalculusFieldElement used
  1036.      * @param orbit orbit to map
  1037.      * @param type type of the angle
  1038.      * @param stateVector flat array into which the state vector should be mapped
  1039.      * (it can have more than 6 elements, extra elements are untouched)
  1040.      * @param stateVectorDot flat array into which the state vector derivative should be mapped
  1041.      * (it can be null if derivatives are not desired, and it can have more than 6 elements, extra elements are untouched)
  1042.      */
  1043.     public abstract <T extends CalculusFieldElement<T>>void mapOrbitToArray(FieldOrbit<T> orbit, PositionAngleType type,
  1044.                                                                             T[] stateVector, T[] stateVectorDot);


  1047.     /** Convert state array to orbital parameters.
  1048.      * <p>
  1049.      * Note that all implementations of this method <em>must</em> be consistent with the
  1050.      * implementation of the {@link org.orekit.orbits.Orbit#getJacobianWrtCartesian(
  1051.      * PositionAngleType, double[][]) Orbit.getJacobianWrtCartesian}
  1052.      * method for the corresponding orbit type in terms of parameters order and meaning.
  1053.      * </p>
  1054.      * @param <T> CalculusFieldElement used
  1055.      * @param array state as a flat array
  1056.      * (it can have more than 6 elements, extra elements are ignored)
  1057.      * @param arrayDot state derivative as a flat array
  1058.      * (it can be null, in which case Keplerian motion is assumed,
  1059.      * @param type type of the angle
  1060.      * @param date integration date
  1061.      * @param mu central attraction coefficient used for propagation (m³/s²)
  1062.      * @param frame frame in which integration is performed
  1063.      * @return orbit corresponding to the flat array as a space dynamics object
  1064.      */
  1065.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> mapArrayToOrbit(T[] array,
  1066.                                                                                       T[] arrayDot,
  1067.                                                                                       PositionAngleType type,
  1068.                                                                                       FieldAbsoluteDate<T> date,
  1069.                                                                                       T mu, Frame frame);

  1071.     /** Convert an orbit to the "Fielded" instance type.
  1072.      * @param <T> CalculusFieldElement used
  1073.      * @param field CalculusField
  1074.      * @param orbit base orbit
  1075.      * @return converted FieldOrbit with type guaranteed to match (so it can be cast safely)
  1076.      * @since 12.0
  1077.      */
  1078.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> convertToFieldOrbit(Field<T> field,
  1079.                                                                                            Orbit orbit);

  1081.     /** Get parameters drivers initialized from a reference orbit.
  1082.      * @param dP user specified position error
  1083.      * @param orbit reference orbit
  1084.      * @param type type of the angle
  1085.      * @return parameters drivers initialized from reference orbit
  1086.      */
  1087.     public abstract ParameterDriversList getDrivers(double dP, Orbit orbit,
  1088.                                                     PositionAngleType type);

  1090.     /** Normalize one orbit with respect to a reference one.
  1091.      * <p>
  1092.      * Given a, angular component ζ of an orbit and the corresponding
  1093.      * angular component ζᵣ in the reference orbit, the angular component
  1094.      * ζₙ of the normalized orbit will be ζₙ = ζ + 2kπ
  1095.      * where k is chosen such that ζᵣ - π ≤ ζₙ ≤ ζᵣ + π. This is intended
  1096.      * to avoid too large discontinuities and is particularly useful
  1097.      * for normalizing the orbit after an impulsive maneuver with respect
  1098.      * to the reference picked up before the maneuver.
  1099.      * </p>
  1100.      * @param <T> CalculusFieldElement used
  1101.      * @param orbit orbit to normalize
  1102.      * @param reference reference orbit
  1103.      * @return normalized orbit (the type is guaranteed to match {@link OrbitType})
  1104.      * @since 11.1
  1105.      */
  1106.     public abstract <T extends CalculusFieldElement<T>> FieldOrbit<T> normalize(FieldOrbit<T> orbit,
  1107.                                                                                 FieldOrbit<T> reference);

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

  1126.     /** Tells if the orbit type is based on position angles or not.
  1127.      * @return true if based on {@link PositionAngleType}
  1128.      * @since 12.0
  1129.      */
  1130.     public abstract boolean isPositionAngleBased();

  1132.     /** Compute scaling factor for parameters drivers.
  1133.      * <p>
  1134.      * The scales are estimated from partial derivatives properties of orbits,
  1135.      * starting from a scalar position error specified by the user.
  1136.      * Considering the energy conservation equation V = sqrt(mu (2/r - 1/a)),
  1137.      * we get at constant energy (i.e. on a Keplerian trajectory):
  1138.      * <pre>
  1139.      * V r² |dV| = mu |dr|
  1140.      * </pre>
  1141.      * <p> So we deduce a scalar velocity error consistent with the position error.
  1142.      * From here, we apply orbits Jacobians matrices to get consistent scales
  1143.      * on orbital parameters.
  1144.      *
  1145.      * @param dP user specified position error
  1146.      * @param orbit reference orbit
  1147.      * @return scaling factor array
  1148.      */
  1149.     protected double[] scale(final double dP, final Orbit orbit) {

  1151.         // estimate the scalar velocity error
  1152.         final PVCoordinates pv = orbit.getPVCoordinates();
  1153.         final double r2 = pv.getPosition().getNormSq();
  1154.         final double v  = pv.getVelocity().getNorm();
  1155.         final double dV = orbit.getMu() * dP / (v * r2);

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

  1159.         // convert the orbit to the desired type
  1160.         final double[][] jacobian = new double[6][6];
  1161.         final Orbit converted = convertType(orbit);
  1162.         converted.getJacobianWrtCartesian(PositionAngleType.TRUE, jacobian);

  1164.         for (int i = 0; i < 6; ++i) {
  1165.             final double[] row = jacobian[i];
  1166.             scale[i] = FastMath.abs(row[0]) * dP +
  1167.                        FastMath.abs(row[1]) * dP +
  1168.                        FastMath.abs(row[2]) * dP +
  1169.                        FastMath.abs(row[3]) * dV +
  1170.                        FastMath.abs(row[4]) * dV +
  1171.                        FastMath.abs(row[5]) * dV;
  1172.             if (Double.isNaN(scale[i])) {
  1173.                 throw new OrekitException(OrekitMessages.SINGULAR_JACOBIAN_FOR_ORBIT_TYPE, this);
  1174.             }
  1175.         }

  1177.         return scale;

  1179.     }

  1181. }
Created with JaCoCo 0.8.11.202310140853