LOFType.java

  1. /* Copyright 2002-2022 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.Field;
  20. import org.hipparchus.CalculusFieldElement;
  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.Vector3D;
  25. import org.orekit.time.AbsoluteDate;
  26. import org.orekit.time.FieldAbsoluteDate;
  27. import org.orekit.utils.FieldPVCoordinates;
  28. import org.orekit.utils.PVCoordinates;

  30. /** Enumerate for different types of Local Orbital Frames.
  31.  * @author Luc Maisonobe
  32.  */
  33. public enum LOFType {

  35.     /** Constant for TNW frame
  36.      * (X axis aligned with velocity, Z axis aligned with orbital momentum).
  37.      * <p>
  38.      * The axes of this frame are parallel to the axes of the {@link #VNC}
  39.      * and {@link #NTW} frames:
  40.      * <ul>
  41.      *   <li>X<sub>TNW</sub> =  X<sub>VNC</sub> =  Y<sub>NTW</sub></li>
  42.      *   <li>Y<sub>TNW</sub> = -Z<sub>VNC</sub> = -X<sub>NTW</sub></li>
  43.      *   <li>Z<sub>TNW</sub> =  Y<sub>VNC</sub> =  Z<sub>NTW</sub></li>
  44.      * </ul>
  45.      *
  46.      * @see #VNC
  47.      * @see #NTW
  48.      */
  49.     TNW {

  51.         /** {@inheritDoc} */
  52.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  53.             return new Rotation(pv.getVelocity(), pv.getMomentum(),
  54.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  55.         }

  57.         /** {@inheritDoc} */
  58.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  59.                                                                                      final FieldPVCoordinates<T> pv) {
  60.             return new FieldRotation<>(pv.getVelocity(), pv.getMomentum(),
  61.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  62.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  63.         }

  65.     },

  67.     /** Constant for QSW frame
  68.      * (X axis aligned with position, Z axis aligned with orbital momentum).
  69.      * <p>
  70.      * This frame is also known as the {@link #LVLH} frame, both constants are equivalent.
  71.      * </p>
  72.      * <p>
  73.      * The axes of these frames are parallel to the axes of the {@link #VVLH} frame:
  74.      * <ul>
  75.      *   <li>X<sub>QSW/LVLH</sub> = -Z<sub>VVLH</sub></li>
  76.      *   <li>Y<sub>QSW/LVLH</sub> =  X<sub>VVLH</sub></li>
  77.      *   <li>Z<sub>QSW/LVLH</sub> = -Y<sub>VVLH</sub></li>
  78.      * </ul>
  79.      *
  80.      * @see #LVLH
  81.      * @see #VVLH
  82.      */
  83.     QSW {

  85.         /** {@inheritDoc} */
  86.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  87.             return new Rotation(pv.getPosition(), pv.getMomentum(),
  88.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  89.         }

  91.         /** {@inheritDoc} */
  92.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  93.                                                                                      final FieldPVCoordinates<T> pv) {
  94.             return new FieldRotation<>(pv.getPosition(), pv.getMomentum(),
  95.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  96.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  97.         }

  99.     },

  101.     /** Constant for Local Vertical, Local Horizontal frame
  102.      * (X axis aligned with position, Z axis aligned with orbital momentum).
  103.      * <p>
  104.      * BEWARE! Depending on the background (software used, textbook, community),
  105.      * different incompatible definitions for LVLH are used. This one is consistent
  106.      * with Vallado's book and with AGI's STK. However CCSDS standard, Wertz, and
  107.      * a.i. solutions' FreeFlyer use another definition (see {@link #LVLH_CCSDS}).
  108.      * </p>
  109.      * <p>
  110.      * This frame is also known as the {@link #QSW} frame, both constants are equivalent.
  111.      * </p>
  112.      * <p>
  113.      * The axes of these frames are parallel to the axes of the {@link #LVLH_CCSDS} frame:
  114.      * <ul>
  115.      *   <li>X<sub>LVLH/QSW</sub> = -Z<sub>LVLH_CCSDS</sub></li>
  116.      *   <li>Y<sub>LVLH/QSW</sub> =  X<sub>LVLH_CCSDS</sub></li>
  117.      *   <li>Z<sub>LVLH/QSW</sub> = -Y<sub>LVLH_CCSDS</sub></li>
  118.      * </ul>
  119.      *
  120.      * @see #QSW
  121.      * @see #VVLH
  122.      */
  123.     LVLH {

  125.         /** {@inheritDoc} */
  126.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  127.             return new Rotation(pv.getPosition(), pv.getMomentum(),
  128.                                 Vector3D.PLUS_I, Vector3D.PLUS_K);
  129.         }

  131.         /** {@inheritDoc} */
  132.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  133.                                                                                      final FieldPVCoordinates<T> pv) {
  134.             return new FieldRotation<>(pv.getPosition(), pv.getMomentum(),
  135.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  136.                                        new FieldVector3D<>(field, Vector3D.PLUS_K));
  137.         }

  139.     },

  141.     /** Constant for Local Vertical, Local Horizontal frame as defined by CCSDS
  142.      * (Z axis aligned with opposite of position, Y axis aligned with opposite of orbital momentum).
  143.      * <p>
  144.      * BEWARE! Depending on the background (software used, textbook, community),
  145.      * different incompatible definitions for LVLH are used. This one is consistent
  146.      * with CCSDS standard, Wertz, and a.i. solutions' FreeFlyer. However Vallado's
  147.      * book and with AGI's STK use another definition (see {@link #LVLH}).
  148.      * </p>
  149.      * <p>
  150.      * The axes of this frame are parallel to the axes of both the {@link #QSW} and {@link #LVLH} frames:
  151.      * <ul>
  152.      *   <li>X<sub>LVLH_CCSDS/VVLH</sub> =  Y<sub>QSW/LVLH</sub></li>
  153.      *   <li>Y<sub>LVLH_CCSDS/VVLH</sub> = -Z<sub>QSW/LVLH</sub></li>
  154.      *   <li>Z<sub>LVLH_CCSDS/VVLH</sub> = -X<sub>QSW/LVLH</sub></li>
  155.      * </ul>
  156.      *
  157.      * @see #QSW
  158.      * @see #LVLH
  159.      * @since 11.0
  160.      */
  161.     LVLH_CCSDS {

  163.         /** {@inheritDoc} */
  164.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  165.             return new Rotation(pv.getPosition(), pv.getMomentum(),
  166.                                 Vector3D.MINUS_K, Vector3D.MINUS_J);
  167.         }

  169.         /** {@inheritDoc} */
  170.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  171.                                                                                      final FieldPVCoordinates<T> pv) {
  172.             return new FieldRotation<>(pv.getPosition(), pv.getMomentum(),
  173.                                        new FieldVector3D<>(field, Vector3D.MINUS_K),
  174.                                        new FieldVector3D<>(field, Vector3D.MINUS_J));
  175.         }

  177.     },

  179.     /** Constant for Vehicle Velocity, Local Horizontal frame
  180.      * (Z axis aligned with opposite of position, Y axis aligned with opposite of orbital momentum).
  181.      * <p>
  182.      * This is another name for {@link #LVLH_CCSDS}, kept here for compatibility with STK.
  183.      * </p>
  184.      * <p>
  185.      * Beware that the name is misleading: in the general case (i.e. not perfectly circular),
  186.      * none of the axes is perfectly aligned with velocity! The preferred name for this
  187.      * should be {@link #LVLH_CCSDS}.
  188.      * </p>
  189.      * <p>
  190.      * The axes of this frame are parallel to the axes of both the {@link #QSW} and {@link #LVLH} frames:
  191.      * <ul>
  192.      *   <li>X<sub>LVLH_CCSDS/VVLH</sub> =  Y<sub>QSW/LVLH</sub></li>
  193.      *   <li>Y<sub>LVLH_CCSDS/VVLH</sub> = -Z<sub>QSW/LVLH</sub></li>
  194.      *   <li>Z<sub>LVLH_CCSDS/VVLH</sub> = -X<sub>QSW/LVLH</sub></li>
  195.      * </ul>
  196.      * @see #LVLH_CCSDS
  197.      */
  198.     VVLH {

  200.         /** {@inheritDoc} */
  201.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  202.             return LVLH_CCSDS.rotationFromInertial(pv);
  203.         }

  205.         /** {@inheritDoc} */
  206.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  207.                                                                                      final FieldPVCoordinates<T> pv) {
  208.             return LVLH_CCSDS.rotationFromInertial(field, pv);
  209.         }

  211.     },

  213.     /** Constant for Velocity - Normal - Co-normal frame
  214.      * (X axis aligned with velocity, Y axis aligned with orbital momentum).
  215.      * <p>
  216.      * The axes of this frame are parallel to the axes of the {@link #TNW}
  217.      * and {@link #NTW} frames:
  218.      * <ul>
  219.      *   <li>X<sub>VNC</sub> =  X<sub>TNW</sub> = Y<sub>NTW</sub></li>
  220.      *   <li>Y<sub>VNC</sub> =  Z<sub>TNW</sub> = Z<sub>NTW</sub></li>
  221.      *   <li>Z<sub>VNC</sub> = -Y<sub>TNW</sub> = X<sub>NTW</sub></li>
  222.      * </ul>
  223.      *
  224.      * @see #TNW
  225.      * @see #NTW
  226.      */
  227.     VNC {

  229.         /** {@inheritDoc} */
  230.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  231.             return new Rotation(pv.getVelocity(), pv.getMomentum(),
  232.                                 Vector3D.PLUS_I, Vector3D.PLUS_J);
  233.         }

  235.         @Override
  236.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  237.                                                                                      final FieldPVCoordinates<T> pv) {
  238.             return new FieldRotation<>(pv.getVelocity(), pv.getMomentum(),
  239.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  240.                                        new FieldVector3D<>(field, Vector3D.PLUS_J));
  241.         }

  243.     },

  245.     /** Constant for Equinoctial Coordinate System
  246.      * (X axis aligned with ascending node, Z axis aligned with orbital momentum).
  247.      * @since 11.0
  248.      */
  249.     EQW {

  251.         /** {@inheritDoc} */
  252.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  253.             final Vector3D m = pv.getMomentum();
  254.             return new Rotation(new Vector3D(-m.getY(), m.getX(), 0), m,
  255.                                 Vector3D.PLUS_I, Vector3D.PLUS_J);
  256.         }

  258.         @Override
  259.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  260.                                                                                      final FieldPVCoordinates<T> pv) {
  261.             final FieldVector3D<T> m = pv.getMomentum();
  262.             return new FieldRotation<>(new FieldVector3D<>(m.getY().negate(), m.getX(), field.getZero()),
  263.                                        m,
  264.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  265.                                        new FieldVector3D<>(field, Vector3D.PLUS_J));
  266.         }

  268.     },

  270.     /** Constant for Transverse Velocity Normal coordinate system
  271.      * (Y axis aligned with velocity, Z axis aligned with orbital momentum).
  272.      * <p>
  273.      * The axes of this frame are parallel to the axes of the {@link #TNW}
  274.      * and {@link #VNC} frames:
  275.      * <ul>
  276.      *   <li>X<sub>NTW</sub> = -Y<sub>TNW</sub> = Z<sub>VNC</sub></li>
  277.      *   <li>Y<sub>NTW</sub> =  X<sub>TNW</sub> = X<sub>VNC</sub></li>
  278.      *   <li>Z<sub>NTW</sub> =  Z<sub>TNW</sub> = Y<sub>VNC</sub></li>
  279.      * </ul>
  280.      * @see #TNW
  281.      * @see #VNC
  282.      * @since 11.0
  283.      */
  284.     NTW {

  286.         /** {@inheritDoc} */
  287.         public Rotation rotationFromInertial(final PVCoordinates pv) {
  288.             final Vector3D m = pv.getMomentum();
  289.             return new Rotation(new Vector3D(-m.getY(), m.getX(), 0), m,
  290.                                 Vector3D.PLUS_I, Vector3D.PLUS_J);
  291.         }

  293.         @Override
  294.         public <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(final Field<T> field,
  295.                                                                                      final FieldPVCoordinates<T> pv) {
  296.             final FieldVector3D<T> m = pv.getMomentum();
  297.             return new FieldRotation<>(new FieldVector3D<>(m.getY().negate(), m.getX(), field.getZero()),
  298.                                        m,
  299.                                        new FieldVector3D<>(field, Vector3D.PLUS_I),
  300.                                        new FieldVector3D<>(field, Vector3D.PLUS_J));
  301.         }

  303.     };

  305.     /** Get the transform from an inertial frame defining position-velocity and the local orbital frame.
  306.      * @param date current date
  307.      * @param pv position-velocity of the spacecraft in some inertial frame
  308.      * @return transform from the frame where position-velocity are defined to local orbital frame
  309.      */
  310.     public Transform transformFromInertial(final AbsoluteDate date, final PVCoordinates pv) {

  312.         // compute the translation part of the transform
  313.         final Transform translation = new Transform(date, pv.negate());

  315.         // compute the rotation part of the transform
  316.         final Rotation r = rotationFromInertial(pv);
  317.         final Vector3D p = pv.getPosition();
  318.         final Vector3D momentum = pv.getMomentum();
  319.         final Transform rotation =
  320.                 new Transform(date, r, new Vector3D(1.0 / p.getNormSq(), r.applyTo(momentum)));

  322.         return new Transform(date, translation, rotation);

  324.     }

  326.     /** Get the transform from an inertial frame defining position-velocity and the local orbital frame.
  327.      * @param date current date
  328.      * @param pv position-velocity of the spacecraft in some inertial frame
  329.      * @param <T> type of the fiels elements
  330.      * @return transform from the frame where position-velocity are defined to local orbital frame
  331.      * @since 9.0
  332.      */
  333.     public <T extends CalculusFieldElement<T>> FieldTransform<T> transformFromInertial(final FieldAbsoluteDate<T> date,
  334.                                                                                    final FieldPVCoordinates<T> pv) {

  336.         // compute the translation part of the transform
  337.         final FieldTransform<T> translation = new FieldTransform<>(date, pv.negate());

  339.         // compute the rotation part of the transform
  340.         final FieldRotation<T> r = rotationFromInertial(date.getField(), pv);
  341.         final FieldVector3D<T> p = pv.getPosition();
  342.         final FieldVector3D<T> momentum = pv.getMomentum();
  343.         final FieldTransform<T> rotation =
  344.                 new FieldTransform<T>(date, r, new FieldVector3D<>(p.getNormSq().reciprocal(), r.applyTo(momentum)));

  346.         return new FieldTransform<>(date, translation, rotation);

  348.     }

  350.     /** Get the rotation from inertial frame to local orbital frame.
  351.      * <p>
  352.      * This rotation does not include any time derivatives. If first
  353.      * time derivatives (i.e. rotation rate) is needed as well, the full
  354.      * {@link #transformFromInertial(AbsoluteDate, PVCoordinates) transformFromInertial}
  355.      * method must be called and the complete rotation transform must be extracted
  356.      * from it.
  357.      * </p>
  358.      * @param pv position-velocity of the spacecraft in some inertial frame
  359.      * @return rotation from inertial frame to local orbital frame
  360.      */
  361.     public abstract Rotation rotationFromInertial(PVCoordinates pv);

  363.     /** Get the rotation from inertial frame to local orbital frame.
  364.      * <p>
  365.      * This rotation does not include any time derivatives. If first
  366.      * time derivatives (i.e. rotation rate) is needed as well, the full
  367.      * {@link #transformFromInertial(FieldAbsoluteDate, FieldPVCoordinates) transformFromInertial}
  368.      * method must be called and the complete rotation transform must be extracted
  369.      * from it.
  370.      * </p>
  371.      * @param field field to which the elements belong
  372.      * @param pv position-velocity of the spacecraft in some inertial frame
  373.      * @param <T> type of the field elements
  374.      * @return rotation from inertial frame to local orbital frame
  375.      * @since 9.0
  376.      */
  377.     public abstract <T extends CalculusFieldElement<T>> FieldRotation<T> rotationFromInertial(Field<T> field,
  378.                                                                                           FieldPVCoordinates<T> pv);

  380. }
Created with JaCoCo 0.8.7.202105040129