CCSDSFrame.java

  1. /* Copyright 2002-2020 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.files.ccsds;

  19. import org.orekit.annotation.DefaultDataContext;
  20. import org.orekit.data.DataContext;
  21. import org.orekit.errors.OrekitException;
  22. import org.orekit.errors.OrekitMessages;
  23. import org.orekit.frames.Frame;
  24. import org.orekit.frames.ITRFVersion;
  25. import org.orekit.frames.LOFType;
  26. import org.orekit.utils.IERSConventions;

  28. /** Frames used in CCSDS Orbit Data Messages.
  29.  * @author Steven Ports
  30.  * @since 6.1
  31.  */
  32. public enum CCSDSFrame {

  34.     /** Earth Mean Equator and Equinox of J2000. */
  35.     EME2000(null) {

  37.         /** {@inheritDoc} */
  38.         @Override
  39.         public Frame getFrame(final IERSConventions conventions,
  40.                               final boolean simpleEOP,
  41.                               final DataContext dataContext) {
  42.             return dataContext.getFrames().getEME2000();
  43.         }

  45.     },

  47.     /** Geocentric Celestial Reference Frame. */
  48.     GCRF(null) {

  50.         /** {@inheritDoc} */
  51.         @Override
  52.         public Frame getFrame(final IERSConventions conventions,
  53.                               final boolean simpleEOP,
  54.                               final DataContext dataContext) {
  55.             return dataContext.getFrames().getGCRF();
  56.         }

  58.     },

  60.     /** Greenwich Rotating Coordinates. */
  61.     GRC(null) {

  63.         /** {@inheritDoc} */
  64.         @Override
  65.         public Frame getFrame(final IERSConventions conventions,
  66.                               final boolean simpleEOP,
  67.                               final DataContext dataContext) {
  68.             if (conventions == null) {
  69.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  70.             }
  71.             return dataContext.getFrames().getITRFEquinox(conventions, simpleEOP);
  72.         }

  74.     },

  76.     /** International Celestial Reference Frame. */
  77.     ICRF(null) {

  79.         /** {@inheritDoc} */
  80.         @Override
  81.         public Frame getFrame(final IERSConventions conventions,
  82.                               final boolean simpleEOP,
  83.                               final DataContext dataContext) {
  84.             return dataContext.getFrames().getICRF();
  85.         }

  87.     },

  89.     /** International Terrestrial Reference Frame 2014. */
  90.     ITRF2014(null) {

  92.         /** {@inheritDoc} */
  93.         @Override
  94.         public Frame getFrame(final IERSConventions conventions,
  95.                               final boolean simpleEOP,
  96.                               final DataContext dataContext) {
  97.             if (conventions == null) {
  98.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  99.             }
  100.             return dataContext.getFrames()
  101.                     .getITRF(ITRFVersion.ITRF_2014, conventions, simpleEOP);
  102.         }

  104.     },

  106.     /** International Terrestrial Reference Frame 2008. */
  107.     ITRF2008(null) {

  109.         /** {@inheritDoc} */
  110.         @Override
  111.         public Frame getFrame(final IERSConventions conventions,
  112.                               final boolean simpleEOP,
  113.                               final DataContext dataContext) {
  114.             if (conventions == null) {
  115.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  116.             }
  117.             return dataContext.getFrames()
  118.                     .getITRF(ITRFVersion.ITRF_2008, conventions, simpleEOP);
  119.         }

  121.     },

  123.     /** International Terrestrial Reference Frame 2005. */
  124.     ITRF2005(null) {

  126.         /** {@inheritDoc} */
  127.         @Override
  128.         public Frame getFrame(final IERSConventions conventions,
  129.                               final boolean simpleEOP,
  130.                               final DataContext dataContext) {
  131.             if (conventions == null) {
  132.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  133.             }
  134.             return dataContext.getFrames()
  135.                     .getITRF(ITRFVersion.ITRF_2005, conventions, simpleEOP);
  136.         }

  138.     },

  140.     /** International Terrestrial Reference Frame 2000. */
  141.     ITRF2000(null) {

  143.         /** {@inheritDoc} */
  144.         @Override
  145.         public Frame getFrame(final IERSConventions conventions,
  146.                               final boolean simpleEOP,
  147.                               final DataContext dataContext) {
  148.             if (conventions == null) {
  149.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  150.             }
  151.             return dataContext.getFrames()
  152.                     .getITRF(ITRFVersion.ITRF_2000, conventions, simpleEOP);
  153.         }

  155.     },

  157.     /** International Terrestrial Reference Frame 1993. */
  158.     ITRF93(null) {

  160.         /** {@inheritDoc} */
  161.         @Override
  162.         public Frame getFrame(final IERSConventions conventions,
  163.                               final boolean simpleEOP,
  164.                               final DataContext dataContext) {
  165.             if (conventions == null) {
  166.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  167.             }
  168.             return dataContext.getFrames()
  169.                     .getITRF(ITRFVersion.ITRF_93, conventions, simpleEOP);
  170.         }

  172.     },

  174.     /** International Terrestrial Reference Frame 1997. */
  175.     ITRF97(null) {

  177.         /** {@inheritDoc} */
  178.         @Override
  179.         public Frame getFrame(final IERSConventions conventions,
  180.                               final boolean simpleEOP,
  181.                               final DataContext dataContext) {
  182.             if (conventions == null) {
  183.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  184.             }
  185.             return dataContext.getFrames()
  186.                     .getITRF(ITRFVersion.ITRF_97, conventions, simpleEOP);
  187.         }

  189.     },

  191.     /** Mars Centered Inertial. */
  192.     MCI(null) {

  194.         /** {@inheritDoc} */
  195.         @Override
  196.         public Frame getFrame(final IERSConventions conventions,
  197.                               final boolean simpleEOP,
  198.                               final DataContext dataContext) {
  199.             return dataContext.getCelestialBodies().getMars()
  200.                     .getInertiallyOrientedFrame();
  201.         }

  203.     },

  205.     /** True of Date, Rotating. */
  206.     TDR(null) {

  208.         /** {@inheritDoc} */
  209.         @Override
  210.         public Frame getFrame(final IERSConventions conventions,
  211.                               final boolean simpleEOP,
  212.                               final DataContext dataContext) {
  213.             if (conventions == null) {
  214.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  215.             }
  216.             return dataContext.getFrames().getGTOD(conventions, simpleEOP);
  217.         }

  219.     },

  221.     /**
  222.      * True Equator Mean Equinox.
  223.      * TEME may be used only for OMMs based on NORAD
  224.      * Two Line Element sets, and in no other circumstances.
  225.      */
  226.     TEME(null) {

  228.         /** {@inheritDoc} */
  229.         @Override
  230.         public Frame getFrame(final IERSConventions conventions,
  231.                               final boolean simpleEOP,
  232.                               final DataContext dataContext) {
  233.             return dataContext.getFrames().getTEME();
  234.         }

  236.     },

  238.     /** True of Date. */
  239.     TOD(null) {

  241.         /** {@inheritDoc} */
  242.         @Override
  243.         public Frame getFrame(final IERSConventions conventions,
  244.                               final boolean simpleEOP,
  245.                               final DataContext dataContext) {
  246.             if (conventions == null) {
  247.                 throw new OrekitException(OrekitMessages.CCSDS_UNKNOWN_CONVENTIONS);
  248.             }
  249.             return dataContext.getFrames().getTOD(conventions, simpleEOP);
  250.         }

  252.     },

  254.     /** Radial, Transverse (along-track) and Normal. */
  255.     RTN(LOFType.QSW),

  257.     /** Another name for Radial, Transverse (along-track) and Normal. */
  258.     RSW(LOFType.QSW),

  260.     /** TNW : x-axis along the velocity vector, W along the orbital angular momentum vector and
  261.     N completes the right handed system. */
  262.     TNW(LOFType.TNW);

  264.     /** Type of Local Orbital Frame (may be null). */
  265.     private final LOFType lofType;

  267.     /** Simple constructor.
  268.      * @param lofType type of Local Orbital Frame (null if frame is not a Local Orbital Frame)
  269.      */
  270.     CCSDSFrame(final LOFType lofType) {
  271.         this.lofType = lofType;
  272.     }

  274.     /** Check if the frame is a Local Orbital frame.
  275.      * @return true if the frame is a Local Orbital Frame
  276.      */
  277.     public boolean isLof() {
  278.         return lofType != null;
  279.     }

  281.     /** Get the type of Local Orbital frame.
  282.      * <p>
  283.      * If the frame is not a Local Orbital frame (i.e. if this method returns null),
  284.      * then the {@link #getFrame(IERSConventions, boolean, DataContext) getFrame} method
  285.      * must be used to retrieve the absolute frame.
  286.      * </p>
  287.      * @return type of Local Orbital Frame, or null if the frame is not a local orbital frame
  288.      * @see #isLof()
  289.      */
  290.     public LOFType getLofType() {
  291.         return lofType;
  292.     }

  294.     /**
  295.      * Get the frame corresponding to the CCSDS constant.
  296.      *
  297.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  298.      *
  299.      * @param conventions IERS conventions to use
  300.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  301.      * @return frame corresponding to the CCSDS constant
  302.      * @see #isLof()
  303.      * @see #getFrame(IERSConventions, boolean, DataContext)
  304.      */
  305.     @DefaultDataContext
  306.     public Frame getFrame(final IERSConventions conventions, final boolean simpleEOP) {
  307.         return getFrame(conventions, simpleEOP, DataContext.getDefault());
  308.     }

  310.     /**
  311.      * Get the frame corresponding to the CCSDS constant.
  312.      * @param conventions IERS conventions to use
  313.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  314.      * @param dataContext to use when creating the frame.
  315.      * @return frame corresponding to the CCSDS constant
  316.      * @see #isLof()
  317.      * @since 10.1
  318.      */
  319.     public Frame getFrame(final IERSConventions conventions,
  320.                           final boolean simpleEOP,
  321.                           final DataContext dataContext) {
  322.         throw new OrekitException(OrekitMessages.CCSDS_INVALID_FRAME, toString());
  323.     }

  325. }
Created with JaCoCo 0.8.5.201910111838