LOFType.java

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

  19. import org.hipparchus.CalculusFieldElement;
  20. import org.hipparchus.Field;
  21. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  22. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  23. import org.hipparchus.geometry.euclidean.threed.Rotation;
  24. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  25. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  26. import org.orekit.errors.OrekitException;
  27. import org.orekit.errors.OrekitMessages;
  28. import org.orekit.files.ccsds.definitions.OrbitRelativeFrame;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.FieldAbsoluteDate;
  31. import org.orekit.utils.FieldPVCoordinates;
  32. import org.orekit.utils.PVCoordinates;

  34. /**
  35.  * Enumerate for different types of Local Orbital Frames.
  36.  *
  37.  * @author Luc Maisonobe
  38.  * @author Maxime Journot
  39.  * @author Vincent Cucchietti
  40.  */
  41. public enum LOFType implements LOF {

  43.     /** Constant for TNW frame
  44.      * (X axis aligned with velocity, Z axis aligned with orbital momentum).
  45.      * <p>
  46.      * The axes of this frame are parallel to the axes of the {@link #VNC}
  47.      * and {@link #NTW} frames:
  48.      * </p>
  49.      * <ul>
  50.      *   <li>X<sub>TNW</sub> =  X<sub>VNC</sub> =  Y<sub>NTW</sub></li>
  51.      *   <li>Y<sub>TNW</sub> = -Z<sub>VNC</sub> = -X<sub>NTW</sub></li>
  52.      *   <li>Z<sub>TNW</sub> =  Y<sub>VNC</sub> =  Z<sub>NTW</sub></li>
  53.      * </ul>
  54.      *
  55.      * @see #VNC
  56.      * @see #NTW
  57.      */
  58.     TNW {
  59.         /** {@inheritDoc} */
  60.         @Override
  61.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  62.             return new Rotation(pv.getVelocity(), pv.getMomentum(),
  63.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  64.         }

  66.         /** {@inheritDoc} */
  67.         @Override
  68.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  69.                                                                                          final FieldPVCoordinates<T> pv) {
  70.             return new FieldRotation<>(pv.getVelocity(), pv.getMomentum(),
  71.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  72.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  73.         }

  75.         /** {@inheritDoc} */
  76.         @Override
  77.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  78.             return OrbitRelativeFrame.TNW;
  79.         }

  81.     },

  83.     /**
  84.      * Constant for TNW frame considered inertial (X axis aligned with velocity, Z axis aligned with orbital momentum).
  85.      * <p>
  86.      * The axes of this frame are parallel to the axes of the {@link #VNC} and {@link #NTW} frames:
  87.      * </p>
  88.      * <ul>
  89.      *   <li>X<sub>TNW</sub> =  X<sub>VNC</sub> =  Y<sub>NTW</sub></li>
  90.      *   <li>Y<sub>TNW</sub> = -Z<sub>VNC</sub> = -X<sub>NTW</sub></li>
  91.      *   <li>Z<sub>TNW</sub> =  Y<sub>VNC</sub> =  Z<sub>NTW</sub></li>
  92.      * </ul>
  93.      *
  94.      * @see #VNC
  95.      * @see #NTW
  96.      */
  97.     TNW_INERTIAL {
  98.         /** {@inheritDoc} */
  99.         @Override
  100.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  101.             return TNW.rotationFromInertial(pv);
  102.         }

  104.         /** {@inheritDoc} */
  105.         @Override
  106.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  107.                                                                                          final FieldPVCoordinates<T> pv) {
  108.             return TNW.rotationFromInertial(field, pv);
  109.         }

  111.         /** {@inheritDoc} */
  112.         @Override
  113.         public boolean isQuasiInertial() {
  114.             return true;
  115.         }

  117.         /** {@inheritDoc} */
  118.         @Override
  119.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  120.             return OrbitRelativeFrame.TNW_INERTIAL;
  121.         }

  123.     },

  125.     /** Constant for QSW frame
  126.      * (X axis aligned with position, Z axis aligned with orbital momentum).
  127.      * <p>
  128.      * This frame is also known as the {@link #LVLH} frame, both constants are equivalent.
  129.      * </p>
  130.      * <p>
  131.      * The axes of these frames are parallel to the axes of the {@link #VVLH} frame:
  132.      * </p>
  133.      * <ul>
  134.      *   <li>X<sub>QSW/LVLH</sub> = -Z<sub>VVLH</sub></li>
  135.      *   <li>Y<sub>QSW/LVLH</sub> =  X<sub>VVLH</sub></li>
  136.      *   <li>Z<sub>QSW/LVLH</sub> = -Y<sub>VVLH</sub></li>
  137.      * </ul>
  138.      *
  139.      * @see #LVLH
  140.      * @see #VVLH
  141.      */
  142.     QSW {
  143.         /** {@inheritDoc} */
  144.         @Override
  145.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  146.             return new Rotation(pv.getPosition(), pv.getMomentum(),
  147.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  148.         }

  150.         /** {@inheritDoc} */
  151.         @Override
  152.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  153.                                                                                          final FieldPVCoordinates<T> pv) {
  154.             return new FieldRotation<>(pv.getPosition(), pv.getMomentum(),
  155.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  156.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  157.         }

  159.         /** {@inheritDoc} */
  160.         @Override
  161.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  162.             return OrbitRelativeFrame.QSW;
  163.         }

  165.     },

  167.     /**
  168.      * Constant for QSW frame considered inertial (X axis aligned with position, Z axis aligned with orbital momentum).
  169.      * <p>
  170.      * This frame is also known as the {@link #LVLH} frame, both constants are equivalent.
  171.      * </p>
  172.      * <p>
  173.      * The axes of these frames are parallel to the axes of the {@link #VVLH} frame:
  174.      * </p>
  175.      * <ul>
  176.      *   <li>X<sub>QSW/LVLH</sub> = -Z<sub>VVLH</sub></li>
  177.      *   <li>Y<sub>QSW/LVLH</sub> =  X<sub>VVLH</sub></li>
  178.      *   <li>Z<sub>QSW/LVLH</sub> = -Y<sub>VVLH</sub></li>
  179.      * </ul>
  180.      *
  181.      * @see #LVLH
  182.      * @see #VVLH
  183.      */
  184.     QSW_INERTIAL {
  185.         /** {@inheritDoc} */
  186.         @Override
  187.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  188.             return QSW.rotationFromInertial(pv);
  189.         }

  191.         /** {@inheritDoc} */
  192.         @Override
  193.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  194.                                                                                          final FieldPVCoordinates<T> pv) {
  195.             return QSW.rotationFromInertial(field, pv);
  196.         }

  198.         /** {@inheritDoc} */
  199.         @Override
  200.         public boolean isQuasiInertial() {
  201.             return true;
  202.         }

  204.         /** {@inheritDoc} */
  205.         @Override
  206.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  207.             return OrbitRelativeFrame.RSW_INERTIAL;
  208.         }

  210.     },

  212.     /** Constant for Local Vertical, Local Horizontal frame
  213.      * (X axis aligned with position, Z axis aligned with orbital momentum).
  214.      * <p>
  215.      * BEWARE! Depending on the background (software used, textbook, community),
  216.      * different incompatible definitions for LVLH are used. This one is consistent
  217.      * with Vallado's book and with AGI's STK. However CCSDS standard, Wertz, and
  218.      * a.i. solutions' FreeFlyer use another definition (see {@link #LVLH_CCSDS}).
  219.      * </p>
  220.      * <p>
  221.      * This frame is also known as the {@link #QSW} frame, both constants are equivalent.
  222.      * </p>
  223.      * <p>
  224.      * The axes of these frames are parallel to the axes of the {@link #LVLH_CCSDS} frame:
  225.      * </p>
  226.      * <ul>
  227.      *   <li>X<sub>LVLH/QSW</sub> = -Z<sub>LVLH_CCSDS</sub></li>
  228.      *   <li>Y<sub>LVLH/QSW</sub> =  X<sub>LVLH_CCSDS</sub></li>
  229.      *   <li>Z<sub>LVLH/QSW</sub> = -Y<sub>LVLH_CCSDS</sub></li>
  230.      * </ul>
  231.      *
  232.      * @see #QSW
  233.      * @see #VVLH
  234.      */
  235.     LVLH {
  236.         /** {@inheritDoc} */
  237.         @Override
  238.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  239.             return new Rotation(pv.getPosition(), pv.getMomentum(),
  240.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  241.         }

  243.         /** {@inheritDoc} */
  244.         @Override
  245.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  246.                                                                                          final FieldPVCoordinates<T> pv) {
  247.             return new FieldRotation<>(pv.getPosition(), pv.getMomentum(),
  248.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  249.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  250.         }

  252.         /** {@inheritDoc} */
  253.         @Override
  254.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  255.             throw new OrekitException(OrekitMessages.CCSDS_DIFFERENT_LVLH_DEFINITION);
  256.         }

  258.     },

  260.     /**
  261.      * Constant for Local Vertical, Local Horizontal frame considered inertial (X axis aligned with position, Z axis
  262.      * aligned with orbital momentum).
  263.      * <p>
  264.      * BEWARE! Depending on the background (software used, textbook, community), different incompatible definitions for
  265.      * LVLH are used. This one is consistent with Vallado's book and with AGI's STK. However CCSDS standard, Wertz, and
  266.      * a.i. solutions' FreeFlyer use another definition (see {@link #LVLH_CCSDS}).
  267.      * </p>
  268.      * <p>
  269.      * This frame is also known as the {@link #QSW} frame, both constants are equivalent.
  270.      * </p>
  271.      * <p>
  272.      * The axes of these frames are parallel to the axes of the {@link #LVLH_CCSDS} frame:
  273.      * </p>
  274.      * <ul>
  275.      *   <li>X<sub>LVLH/QSW</sub> = -Z<sub>LVLH_CCSDS</sub></li>
  276.      *   <li>Y<sub>LVLH/QSW</sub> =  X<sub>LVLH_CCSDS</sub></li>
  277.      *   <li>Z<sub>LVLH/QSW</sub> = -Y<sub>LVLH_CCSDS</sub></li>
  278.      * </ul>
  279.      *
  280.      * @see #QSW
  281.      * @see #VVLH
  282.      */
  283.     LVLH_INERTIAL {
  284.         /** {@inheritDoc} */
  285.         @Override
  286.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  287.             return LVLH.rotationFromInertial(pv);
  288.         }

  290.         /** {@inheritDoc} */
  291.         @Override
  292.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  293.                                                                                          final FieldPVCoordinates<T> pv) {
  294.             return LVLH.rotationFromInertial(field, pv);
  295.         }

  297.         /** {@inheritDoc} */
  298.         @Override
  299.         public boolean isQuasiInertial() {
  300.             return true;
  301.         }

  303.         /** {@inheritDoc} */
  304.         @Override
  305.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  306.             throw new OrekitException(OrekitMessages.CCSDS_DIFFERENT_LVLH_DEFINITION);
  307.         }

  309.     },

  311.     /** Constant for Local Vertical, Local Horizontal frame as defined by CCSDS
  312.      * (Z axis aligned with opposite of position, Y axis aligned with opposite of orbital momentum).
  313.      * <p>
  314.      * BEWARE! Depending on the background (software used, textbook, community),
  315.      * different incompatible definitions for LVLH are used. This one is consistent
  316.      * with CCSDS standard, Wertz, and a.i. solutions' FreeFlyer. However Vallado's
  317.      * book and with AGI's STK use another definition (see {@link #LVLH}).
  318.      * </p>
  319.      * <p>
  320.      * The axes of this frame are parallel to the axes of both the {@link #QSW} and {@link #LVLH} frames:
  321.      * </p>
  322.      * <ul>
  323.      *   <li>X<sub>LVLH_CCSDS/VVLH</sub> =  Y<sub>QSW/LVLH</sub></li>
  324.      *   <li>Y<sub>LVLH_CCSDS/VVLH</sub> = -Z<sub>QSW/LVLH</sub></li>
  325.      *   <li>Z<sub>LVLH_CCSDS/VVLH</sub> = -X<sub>QSW/LVLH</sub></li>
  326.      * </ul>
  327.      *
  328.      * @see #QSW
  329.      * @see #LVLH
  330.      * @since 11.0
  331.      */
  332.     LVLH_CCSDS {
  333.         /** {@inheritDoc} */
  334.         @Override
  335.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  336.             return new Rotation(pv.getPosition(), pv.getMomentum(),
  337.                                 Vector3D.MINUS_K, Vector3D.MINUS_J);
  338.         }

  340.         /** {@inheritDoc} */
  341.         @Override
  342.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  343.                                                                                          final FieldPVCoordinates<T> pv) {
  344.             return new FieldRotation<>(pv.getPosition(), pv.getMomentum(),
  345.                                        new FieldVector3D<>(field, Vector3D.MINUS_K),
  346.                                        new FieldVector3D<>(field, Vector3D.MINUS_J));
  347.         }

  349.         /** {@inheritDoc} */
  350.         @Override
  351.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  352.             return OrbitRelativeFrame.LVLH;
  353.         }

  355.     },

  357.     /**
  358.      * Constant for Local Vertical, Local Horizontal frame as defined by CCSDS considered inertial (Z axis aligned with
  359.      * opposite of position, Y axis aligned with opposite of orbital momentum).
  360.      * <p>
  361.      * BEWARE! Depending on the background (software used, textbook, community), different incompatible definitions for
  362.      * LVLH are used. This one is consistent with CCSDS standard, Wertz, and a.i. solutions' FreeFlyer. However
  363.      * Vallado's book and with AGI's STK use another definition (see {@link #LVLH}).
  364.      * </p>
  365.      * <p>
  366.      * The axes of this frame are parallel to the axes of both the {@link #QSW} and {@link #LVLH} frames:
  367.      * </p>
  368.      * <ul>
  369.      *   <li>X<sub>LVLH_CCSDS/VVLH</sub> =  Y<sub>QSW/LVLH</sub></li>
  370.      *   <li>Y<sub>LVLH_CCSDS/VVLH</sub> = -Z<sub>QSW/LVLH</sub></li>
  371.      *   <li>Z<sub>LVLH_CCSDS/VVLH</sub> = -X<sub>QSW/LVLH</sub></li>
  372.      * </ul>
  373.      *
  374.      * @see #QSW
  375.      * @see #LVLH
  376.      * @since 11.0
  377.      */
  378.     LVLH_CCSDS_INERTIAL {
  379.         /** {@inheritDoc} */
  380.         @Override
  381.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  382.             return LVLH_CCSDS.rotationFromInertial(pv);
  383.         }

  385.         /** {@inheritDoc} */
  386.         @Override
  387.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  388.                                                                                          final FieldPVCoordinates<T> pv) {
  389.             return LVLH_CCSDS.rotationFromInertial(field, pv);
  390.         }

  392.         /** {@inheritDoc} */
  393.         @Override
  394.         public boolean isQuasiInertial() {
  395.             return true;
  396.         }

  398.         /** {@inheritDoc} */
  399.         @Override
  400.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  401.             return OrbitRelativeFrame.LVLH_INERTIAL;
  402.         }

  404.     },

  406.     /** Constant for Vehicle Velocity, Local Horizontal frame
  407.      * (Z axis aligned with opposite of position, Y axis aligned with opposite of orbital momentum).
  408.      * <p>
  409.      * This is another name for {@link #LVLH_CCSDS}, kept here for compatibility with STK.
  410.      * </p>
  411.      * <p>
  412.      * Beware that the name is misleading: in the general case (i.e. not perfectly circular),
  413.      * none of the axes is perfectly aligned with velocity! The preferred name for this
  414.      * should be {@link #LVLH_CCSDS}.
  415.      * </p>
  416.      * <p>
  417.      * The axes of this frame are parallel to the axes of both the {@link #QSW} and {@link #LVLH} frames:
  418.      * </p>
  419.      * <ul>
  420.      *   <li>X<sub>LVLH_CCSDS/VVLH</sub> =  Y<sub>QSW/LVLH</sub></li>
  421.      *   <li>Y<sub>LVLH_CCSDS/VVLH</sub> = -Z<sub>QSW/LVLH</sub></li>
  422.      *   <li>Z<sub>LVLH_CCSDS/VVLH</sub> = -X<sub>QSW/LVLH</sub></li>
  423.      * </ul>
  424.      * @see #LVLH_CCSDS
  425.      */
  426.     VVLH {
  427.         /** {@inheritDoc} */
  428.         @Override
  429.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  430.             return LVLH_CCSDS.rotationFromInertial(pv);
  431.         }

  433.         /** {@inheritDoc} */
  434.         @Override
  435.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  436.                                                                                          final FieldPVCoordinates<T> pv) {
  437.             return LVLH_CCSDS.rotationFromInertial(field, pv);
  438.         }

  440.         /** {@inheritDoc} */
  441.         @Override
  442.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  443.             return OrbitRelativeFrame.LVLH;
  444.         }

  446.     },

  448.     /**
  449.      * Constant for Vehicle Velocity, Local Horizontal frame considered inertial (Z axis aligned with opposite of
  450.      * position, Y axis aligned with opposite of orbital momentum).
  451.      * <p>
  452.      * This is another name for {@link #LVLH_CCSDS}, kept here for compatibility with STK.
  453.      * </p>
  454.      * <p>
  455.      * Beware that the name is misleading: in the general case (i.e. not perfectly circular), none of the axes is
  456.      * perfectly aligned with velocity! The preferred name for this should be {@link #LVLH_CCSDS}.
  457.      * </p>
  458.      * <p>
  459.      * The axes of this frame are parallel to the axes of both the {@link #QSW} and {@link #LVLH} frames:
  460.      * </p>
  461.      * <ul>
  462.      *   <li>X<sub>LVLH_CCSDS/VVLH</sub> =  Y<sub>QSW/LVLH</sub></li>
  463.      *   <li>Y<sub>LVLH_CCSDS/VVLH</sub> = -Z<sub>QSW/LVLH</sub></li>
  464.      *   <li>Z<sub>LVLH_CCSDS/VVLH</sub> = -X<sub>QSW/LVLH</sub></li>
  465.      * </ul>
  466.      *
  467.      * @see #LVLH_CCSDS
  468.      */
  469.     VVLH_INERTIAL {
  470.         /** {@inheritDoc} */
  471.         @Override
  472.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  473.             return VVLH.rotationFromInertial(pv);
  474.         }

  476.         /** {@inheritDoc} */
  477.         @Override
  478.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  479.                                                                                          final FieldPVCoordinates<T> pv) {
  480.             return VVLH.rotationFromInertial(field, pv);
  481.         }

  483.         /** {@inheritDoc} */
  484.         @Override
  485.         public boolean isQuasiInertial() {
  486.             return true;
  487.         }

  489.         /** {@inheritDoc} */
  490.         @Override
  491.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  492.             return OrbitRelativeFrame.LVLH_INERTIAL;
  493.         }

  495.     },

  497.     /** Constant for Velocity - Normal - Co-normal frame
  498.      * (X axis aligned with velocity, Y axis aligned with orbital momentum).
  499.      * <p>
  500.      * The axes of this frame are parallel to the axes of the {@link #TNW}
  501.      * and {@link #NTW} frames:
  502.      * </p>
  503.      * <ul>
  504.      *   <li>X<sub>VNC</sub> =  X<sub>TNW</sub> = Y<sub>NTW</sub></li>
  505.      *   <li>Y<sub>VNC</sub> =  Z<sub>TNW</sub> = Z<sub>NTW</sub></li>
  506.      *   <li>Z<sub>VNC</sub> = -Y<sub>TNW</sub> = X<sub>NTW</sub></li>
  507.      * </ul>
  508.      *
  509.      * @see #TNW
  510.      * @see #NTW
  511.      */
  512.     VNC {
  513.         /** {@inheritDoc} */
  514.         @Override
  515.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  516.             return new Rotation(pv.getVelocity(), pv.getMomentum(),
  517.                                 Vector3D.PLUS_I, Vector3D.PLUS_J);
  518.         }

  520.         /** {@inheritDoc} */
  521.         @Override
  522.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  523.                                                                                          final FieldPVCoordinates<T> pv) {
  524.             return new FieldRotation<>(pv.getVelocity(), pv.getMomentum(),
  525.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  526.                                        new FieldVector3D<>(field, Vector3D.PLUS_J));
  527.         }

  529.         /** {@inheritDoc} */
  530.         @Override
  531.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  532.             return OrbitRelativeFrame.VNC_ROTATING;
  533.         }

  535.     },

  537.     /**
  538.      * Constant for Velocity - Normal - Co-normal frame considered inertial (X axis aligned with velocity, Y axis
  539.      * aligned with orbital momentum).
  540.      * <p>
  541.      * The axes of this frame are parallel to the axes of the {@link #TNW} and {@link #NTW} frames:
  542.      * </p>
  543.      * <ul>
  544.      *   <li>X<sub>VNC</sub> =  X<sub>TNW</sub> = Y<sub>NTW</sub></li>
  545.      *   <li>Y<sub>VNC</sub> =  Z<sub>TNW</sub> = Z<sub>NTW</sub></li>
  546.      *   <li>Z<sub>VNC</sub> = -Y<sub>TNW</sub> = X<sub>NTW</sub></li>
  547.      * </ul>
  548.      *
  549.      * @see #TNW
  550.      * @see #NTW
  551.      */
  552.     VNC_INERTIAL {
  553.         /** {@inheritDoc} */
  554.         @Override
  555.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  556.             return VNC.rotationFromInertial(pv);
  557.         }

  559.         /** {@inheritDoc} */
  560.         @Override
  561.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  562.                                                                                          final FieldPVCoordinates<T> pv) {
  563.             return VNC.rotationFromInertial(field, pv);
  564.         }

  566.         /** {@inheritDoc} */
  567.         @Override
  568.         public boolean isQuasiInertial() {
  569.             return true;
  570.         }

  572.         /** {@inheritDoc} */
  573.         @Override
  574.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  575.             return OrbitRelativeFrame.VNC_INERTIAL;
  576.         }

  578.     },

  580.     /**
  581.      * Constant for Equinoctial Coordinate System (X axis aligned with ascending node, Z axis aligned with orbital
  582.      * momentum).
  583.      *
  584.      * @since 11.0
  585.      */
  586.     EQW {
  587.         /** {@inheritDoc} */
  588.         @Override
  589.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  590.             final Vector3D m = pv.getMomentum();
  591.             return new Rotation(new Vector3D(-m.getY(), m.getX(), 0), m,
  592.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  593.         }

  595.         /** {@inheritDoc} */
  596.         @Override
  597.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  598.                                                                                          final FieldPVCoordinates<T> pv) {
  599.             final FieldVector3D<T> m = pv.getMomentum();
  600.             return new FieldRotation<>(new FieldVector3D<>(m.getY().negate(), m.getX(), field.getZero()),
  601.                                        m,
  602.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  603.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  604.         }

  606.         /** {@inheritDoc} */
  607.         @Override
  608.         public boolean isQuasiInertial() {
  609.             return true;
  610.         }

  612.         /** {@inheritDoc} */
  613.         @Override
  614.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  615.             return OrbitRelativeFrame.EQW_INERTIAL;
  616.         }

  618.     },

  620.     /** Constant for Transverse Velocity Normal coordinate system
  621.      * (Y axis aligned with velocity, Z axis aligned with orbital momentum).
  622.      * <p>
  623.      * The axes of this frame are parallel to the axes of the {@link #TNW}
  624.      * and {@link #VNC} frames:
  625.      * </p>
  626.      * <ul>
  627.      *   <li>X<sub>NTW</sub> = -Y<sub>TNW</sub> = Z<sub>VNC</sub></li>
  628.      *   <li>Y<sub>NTW</sub> =  X<sub>TNW</sub> = X<sub>VNC</sub></li>
  629.      *   <li>Z<sub>NTW</sub> =  Z<sub>TNW</sub> = Y<sub>VNC</sub></li>
  630.      * </ul>
  631.      * @see #TNW
  632.      * @see #VNC
  633.      * @since 11.0
  634.      */
  635.     NTW {
  636.         /** {@inheritDoc} */
  637.         @Override
  638.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  639.             return new Rotation(pv.getVelocity(), pv.getMomentum(),
  640.                                 Vector3D.PLUS_J, Vector3D.PLUS_K);
  641.         }

  643.         /** {@inheritDoc} */
  644.         @Override
  645.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  646.                                                                                          final FieldPVCoordinates<T> pv) {
  647.             return new FieldRotation<>(pv.getVelocity(), pv.getMomentum(),
  648.                                        new FieldVector3D<>(field, Vector3D.PLUS_J),
  649.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  650.         }

  652.         /** {@inheritDoc} */
  653.         @Override
  654.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  655.             return OrbitRelativeFrame.NTW_ROTATING;
  656.         }

  658.     },

  660.     /**
  661.      * Constant for Transverse Velocity Normal coordinate system considered inertial (Y axis aligned with velocity, Z
  662.      * axis aligned with orbital momentum).
  663.      * <p>
  664.      * The axes of this frame are parallel to the axes of the {@link #TNW} and {@link #VNC} frames:
  665.      * </p>
  666.      * <ul>
  667.      *   <li>X<sub>NTW</sub> = -Y<sub>TNW</sub> = Z<sub>VNC</sub></li>
  668.      *   <li>Y<sub>NTW</sub> =  X<sub>TNW</sub> = X<sub>VNC</sub></li>
  669.      *   <li>Z<sub>NTW</sub> =  Z<sub>TNW</sub> = Y<sub>VNC</sub></li>
  670.      * </ul>
  671.      *
  672.      * @see #TNW
  673.      * @see #VNC
  674.      * @since 11.0
  675.      */
  676.     NTW_INERTIAL {
  677.         /** {@inheritDoc} */
  678.         @Override
  679.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  680.             return NTW.rotationFromInertial(pv);
  681.         }

  683.         /** {@inheritDoc} */
  684.         @Override
  685.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  686.                                                                                          final FieldPVCoordinates<T> pv) {
  687.             return NTW.rotationFromInertial(field, pv);
  688.         }

  690.         /** {@inheritDoc} */
  691.         @Override
  692.         public boolean isQuasiInertial() {
  693.             return true;
  694.         }

  696.         /** {@inheritDoc} */
  697.         @Override
  698.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  699.             return OrbitRelativeFrame.NTW_INERTIAL;
  700.         }

  702.     },

  704.     /**
  705.      * Constant for East-North-Up frame.
  706.      * (Z aligned with position, North Pole in the (+Y, ±Z) half-plane)
  707.      * @see #NED
  708.      * @since 13.0
  709.      */
  710.     ENU {
  711.         /** {@inheritDoc} */
  712.         @Override
  713.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  714.             return new Rotation(pv.getPosition(), east(pv),
  715.                                 Vector3D.PLUS_K, Vector3D.PLUS_I);
  716.         }

  718.         /** {@inheritDoc} */
  719.         @Override
  720.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  721.                                                                                          final FieldPVCoordinates<T> pv) {
  722.             return new FieldRotation<>(pv.getPosition(), east(pv),
  723.                                        FieldVector3D.getPlusK(field), FieldVector3D.getPlusI(field));
  724.         }

  726.         /** {@inheritDoc} */
  727.         @Override
  728.         public boolean isQuasiInertial() {
  729.             return false;
  730.         }

  732.         /** {@inheritDoc} */
  733.         @Override
  734.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  735.             return null;
  736.         }

  738.     },

  740.     /**
  741.      * Constant for North-East-Down frame.
  742.      * (Z aligned with opposite of position, North Pole in the (+X, ±Z) half-plane)
  743.      * @see #ENU
  744.      * @since 13.0
  745.      */
  746.     NED {
  747.         /** {@inheritDoc} */
  748.         @Override
  749.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  750.             return new Rotation(pv.getPosition(), east(pv),
  751.                                 Vector3D.MINUS_K, Vector3D.PLUS_J);
  752.         }

  754.         /** {@inheritDoc} */
  755.         @Override
  756.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  757.                                                                                          final FieldPVCoordinates<T> pv) {
  758.             return new FieldRotation<>(pv.getPosition(), east(pv),
  759.                                        FieldVector3D.getMinusK(field), FieldVector3D.getPlusJ(field));
  760.         }

  762.         /** {@inheritDoc} */
  763.         @Override
  764.         public boolean isQuasiInertial() {
  765.             return false;
  766.         }

  768.         /** {@inheritDoc} */
  769.         @Override
  770.         public OrbitRelativeFrame toOrbitRelativeFrame() {
  771.             return null;
  772.         }

  774.     };

  776.     /** {@inheritDoc} */
  777.     public String getName() {
  778.         return this.name();
  779.     }

  781.     /**
  782.      * Get the rotation from input to output {@link LOFType local orbital frame}.
  783.      * <p>
  784.      * This rotation does not include any time derivatives. If first time derivatives (i.e. rotation rate) is needed as well,
  785.      * the full {@link #transformFromLOFInToLOFOut(LOF, LOF, AbsoluteDate, PVCoordinates)} method must be called and
  786.      * the complete rotation transform must be extracted from it.
  787.      *
  788.      * @param in input commonly used local orbital frame
  789.      * @param out output commonly used local orbital frame
  790.      * @param pv position-velocity of the spacecraft in some inertial frame
  791.      *
  792.      * @return rotation from input to output local orbital frame
  793.      */
  794.     static Rotation rotationFromLOFInToLOFOut(final LOFType in, final LOFType out, final PVCoordinates pv) {
  795.         return out.rotationFromLOF(in, pv);
  796.     }

  798.     /**
  799.      * Get the rotation from input to output {@link LOFType local orbital frame}.
  800.      * <p>
  801.      * This rotation does not include any time derivatives. If first time derivatives (i.e. rotation rate) is needed as well,
  802.      * the full {@link #transformFromLOFInToLOFOut(LOF, LOF, FieldAbsoluteDate, FieldPVCoordinates)}  method must be called and
  803.      * the complete rotation transform must be extracted from it.
  804.      *
  805.      * @param field field to which the elements belong
  806.      * @param in input commonly used local orbital frame
  807.      * @param out output commonly used local orbital frame
  808.      * @param pv position-velocity of the spacecraft in some inertial frame
  809.      * @param <T> type of the field elements
  810.      *
  811.      * @return rotation from input to output local orbital frame
  812.      */
  813.     static <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromLOFInToLOFOut(final Field<T> field,
  814.                                                                                           final LOFType in,
  815.                                                                                           final LOFType out,
  816.                                                                                           final FieldPVCoordinates<T> pv) {
  817.         return out.rotationFromLOF(field, in, pv);
  818.     }

  820.     /**
  821.      * Get the rotation from input {@link LOF local orbital frame} to the instance.
  822.      * <p>
  823.      * This rotation does not include any time derivatives. If first time derivatives (i.e. rotation rate) is needed as well,
  824.      * the full {@link #transformFromLOF(LOF, AbsoluteDate, PVCoordinates)} method must be called and the complete rotation
  825.      * transform must be extracted from it.
  826.      *
  827.      * @param fromLOF input local orbital frame
  828.      * @param pv position-velocity of the spacecraft in some inertial frame
  829.      *
  830.      * @return rotation from input local orbital frame to the instance
  831.      */
  832.     public Rotation rotationFromLOF(final LOFType fromLOF, final PVCoordinates pv) {

  834.         // First compute the rotation from the input LOF to the pivot inertial
  835.         final Rotation fromLOFToInertial = fromLOF.rotationFromInertial(pv).revert();

  837.         // Then compute the rotation from the pivot inertial to the output LOF
  838.         final Rotation inertialToThis = this.rotationFromInertial(pv);

  840.         // Output composed rotation
  841.         return fromLOFToInertial.compose(inertialToThis, RotationConvention.FRAME_TRANSFORM);
  842.     }

  844.     /**
  845.      * Get the rotation from input {@link LOFType local orbital frame} to the instance.
  846.      * <p>
  847.      * This rotation does not include any time derivatives. If first time derivatives (i.e. rotation rate) is needed as well,
  848.      * the full {@link #transformFromLOF(LOF, FieldAbsoluteDate, FieldPVCoordinates)} method must be called and the complete
  849.      * rotation transform must be extracted from it.
  850.      *
  851.      * @param field field to which the elements belong
  852.      * @param fromLOF input local orbital frame
  853.      * @param pv position-velocity of the spacecraft in some inertial frame
  854.      * @param <T> type of the field elements
  855.      *
  856.      * @return rotation from input local orbital frame to the instance
  857.      */
  858.     public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromLOF(final Field<T> field,
  859.                                                                                 final LOFType fromLOF,
  860.                                                                                 final FieldPVCoordinates<T> pv) {

  862.         // First compute the rotation from the input LOF to the pivot inertial
  863.         final FieldRotation<T> fromLOFToInertial = fromLOF.rotationFromInertial(field, pv).revert();

  865.         // Then compute the rotation from the pivot inertial to the output LOF
  866.         final FieldRotation<T> inertialToThis = this.rotationFromInertial(field, pv);

  868.         // Output composed rotation
  869.         return fromLOFToInertial.compose(inertialToThis, RotationConvention.FRAME_TRANSFORM);
  870.     }

  872.     /**
  873.      * {@inheritDoc} It is unnecessary to use this method when dealing with {@link LOFType}, use
  874.      * {@link #rotationFromInertial(PVCoordinates)} instead.
  875.      */
  876.     @Override
  877.     public Rotation rotationFromInertial(final AbsoluteDate date, final PVCoordinates pv) {
  878.         return rotationFromInertial(pv);
  879.     }

  881.     /**
  882.      * Get the rotation from inertial frame to local orbital frame.
  883.      * <p>
  884.      * This rotation does not include any time derivatives. If first time derivatives (i.e. rotation rate) is needed as well,
  885.      * the full {@link #transformFromInertial(AbsoluteDate, PVCoordinates)} method must be called and
  886.      * the complete rotation transform must be extracted from it.
  887.      * </p>
  888.      *
  889.      * @param pv position-velocity of the spacecraft in some inertial frame
  890.      *
  891.      * @return rotation from inertial frame to local orbital frame
  892.      */
  893.     public abstract Rotation rotationFromInertial(PVCoordinates pv);

  895.     /**
  896.      * {@inheritDoc} It is unnecessary to use this method when dealing with {@link LOFType}, use
  897.      * {@link #rotationFromInertial(Field, FieldPVCoordinates)} instead.
  898.      */
  899.     @Override
  900.     public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  901.                                                                                      final FieldAbsoluteDate<T> date,
  902.                                                                                      final FieldPVCoordinates<T> pv) {
  903.         return rotationFromInertial(field, pv);
  904.     }

  906.     /**
  907.      * Get the rotation from inertial frame to local orbital frame.
  908.      * <p>
  909.      * This rotation does not include any time derivatives. If first time derivatives (i.e. rotation rate) is needed as well,
  910.      * the full {@link #transformFromInertial(FieldAbsoluteDate, FieldPVCoordinates)} method must be
  911.      * called and the complete rotation transform must be extracted from it.
  912.      * </p>
  913.      *
  914.      * @param field field to which the elements belong
  915.      * @param pv position-velocity of the spacecraft in some inertial frame
  916.      * @param <T> type of the field elements
  917.      *
  918.      * @return rotation from inertial frame to local orbital frame
  919.      */
  920.     public abstract <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(Field<T> field,
  921.                                                                                               FieldPVCoordinates<T> pv);

  923.     /**
  924.      * Convert current local orbital frame to CCSDS equivalent orbit relative frame when possible, null otherwise.
  925.      *
  926.      * @return CCSDS equivalent orbit relative frame when possible, null otherwise
  927.      *
  928.      * @see OrbitRelativeFrame
  929.      */
  930.     public abstract OrbitRelativeFrame toOrbitRelativeFrame();

  932.     /** Compute East direction.
  933.      * @param pv position-velocity of the spacecraft in some inertial frame
  934.      * @return East direction
  935.      * @since 13.0
  936.      */
  937.     private static Vector3D east(final PVCoordinates pv) {
  938.         final Vector3D p = pv.getPosition();
  939.         final double px = p.getX();
  940.         final double py = p.getY();
  941.         return (px == 0.0 && py == 0.0) ? Vector3D.PLUS_J : new Vector3D(-py, px, 0);
  942.     }

  944.     /** Compute East direction.
  945.      * @param <T> type of the field elements
  946.      * @param pv position-velocity of the spacecraft in some inertial frame
  947.      * @return East direction
  948.      * @since 13.0
  949.      */
  950.     private static <T extends CalculusFieldElement<T>> FieldVector3D<T> east(final FieldPVCoordinates<T> pv) {
  951.         final FieldVector3D<T> p = pv.getPosition();
  952.         final T px = p.getX();
  953.         final T py = p.getY();
  954.         return (px.isZero() && py.isZero()) ?
  955.                FieldVector3D.getPlusJ(px.getField()) :
  956.                new FieldVector3D<>(py.negate(), px, px.getField().getZero());
  957.     }

  959. }
Created with JaCoCo 0.8.12.202403310830