FramesFactory.java

  1. /* Copyright 2002-2013 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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 java.util.ArrayList;
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;
  23. import java.util.SortedSet;
  24. import java.util.TreeSet;

  26. import org.orekit.bodies.CelestialBodyFactory;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.time.AbsoluteDate;
  29. import org.orekit.time.ChronologicalComparator;
  30. import org.orekit.utils.Constants;
  31. import org.orekit.utils.IERSConventions;
  32. import org.orekit.utils.OrekitConfiguration;


  35. /** Factory for predefined reference frames.
  36.  *
  37.  * <h5> FramesFactory Presentation </h5>
  38.  * <p>
  39.  * Several predefined reference {@link Frame frames} are implemented in OREKIT.
  40.  * They are linked together in a tree with the <i>Geocentric
  41.  * Celestial Reference Frame</i> (GCRF) as the root of the tree.
  42.  * This factory is designed to:
  43.  * </p>
  44.  * <ul>
  45.  *   <li>build the frames tree consistently,</li>
  46.  *   <li>avoid rebuilding some frames that may be costly to recreate all the time,</li>
  47.  *   <li>set up interpolation/caching features for some frames that may induce costly computation</li>
  48.  *   <li>streamline the {@link EOPHistory Earth Orientation Parameters} history loading.</li>
  49.  * </ul>
  50.  * <h5> Reference Frames </h5>
  51.  * <p>
  52.  * The user can retrieve those reference frames using various static methods, the most
  53.  * important ones being: {@link #getFrame(Predefined)}, {@link #getGCRF()},
  54.  * {@link #getCIRF(IERSConventions, boolean)} {@link #getTIRF(IERSConventions, boolean)},
  55.  * {@link #getITRF(IERSConventions, boolean)}, {@link #getEME2000()},
  56.  * {@link #getMOD(IERSConventions)}, {@link #getTOD(IERSConventions)},
  57.  * {@link #getGTOD(IERSConventions)}, {@link #getITRFEquinox(IERSConventions, boolean)},
  58.  * {@link #getTEME()} and {@link #getVeis1950()}.
  59.  * </p>
  60.  * <h5> International Terrestrial Reference Frame</h5>
  61.  * <p>
  62.  * This frame is the current (as of 2013) reference realization of
  63.  * the International Terrestrial Reference System produced by IERS.
  64.  * It is described in <a href="ftp://tai.bipm.org/iers/conv2010/tn36.pdf">
  65.  * IERS conventions (2010)</a>. It replaces the Earth Centered Earth Fixed
  66.  * frame which is the reference frame for GPS satellites.
  67.  * </p>
  68.  * <p>
  69.  * This frame is used to define position on solid Earth. It rotates with
  70.  * the Earth and includes the pole motion with respect to Earth crust as
  71.  * provided by {@link org.orekit.data.DataProvidersManager IERS data}.
  72.  * Its pole axis is the IERS Reference Pole (IRP).
  73.  * </p>
  74.  * <p>
  75.  * Previous realizations of the ITRS are available and linked together using
  76.  * {@link HelmertTransformation Helmert transformations}. Parameters for all
  77.  * ITRS realizations since 1988 are available from the ITRF site <a
  78.  * href="ftp://itrf.ensg.ign.fr/pub/itrf/ITRF.TP"> ftp://itrf.ensg.ign.fr/pub/itrf/ITRF.TP</a>).
  79.  * Orekit provides a {@link HelmertTransformation.Predefined#createTransformedITRF(Frame,
  80.  * String) utility} method to build simply several of them and link them together.
  81.  * </p>
  82.  * <p>
  83.  * ITRF can be built using the new non-rotating origin paradigm
  84.  * mandated by IAU 2000 resolution B1.8 and any supported {@link IERSConventions
  85.  * IERS conventions} (even IERS 1996 can be used with non-rotating origin paradigm,
  86.  * despite the resolution was not yet adopted at conventions publication time.
  87.  * </p>
  88.  * <p>
  89.  * ITRF can also be built using the classical equinox paradigm used prior to IAU 2000
  90.  * resolution B1.8 and any supported {@link IERSConventions IERS conventions} (even
  91.  * IERS 2003 and 2010 can be used with equinox paradigm, despite the resolution is
  92.  * in effect now). The choice of paradigm (non-rotating origin or equinox) and the
  93.  * choice of IERS conventions (i.e. the choice of precession/nutation models) can
  94.  * be made independently by user, Orekit provides all alternatives.
  95.  * </p>
  96.  * <h5>Intermediate frames</h5>
  97.  * <p>
  98.  * Orekit also provides all the intermediate frames that are needed to transform
  99.  * between GCRF and ITRF, along the two paths: ITRF/TIRF/CIRF/GCRF for the
  100.  * non-rotating origin paradigm and ITRF/GTOD/TOD/MOD/EME2000/GCRF for the equinox
  101.  * paradigm.
  102.  * </p>
  103.  * <h5> Earth Orientation Parameters </h5>
  104.  * <p>
  105.  * This factory also handles loading of Earth Orientation Parameters (EOP) needed
  106.  * for accurate transformations between inertial and Earth fixed frames, using
  107.  * {@link org.orekit.data.DataProvidersManager} features. EOP are IERS conventions
  108.  * dependent, because they correspond to correction to the precession/nutation
  109.  * models. When EOP should be applied, but EOP data are not available, then a null
  110.  * (0.0) correction is used. This can occur when no EOP data is loaded, or when the
  111.  * requested date is beyond the time span of the loaded EOP data. Using a null
  112.  * correction can result in coarse accuracy. To check the time span covered by EOP data use
  113.  * {@link #getEOPHistory(IERSConventions, boolean)}, {@link EOPHistory#getStartDate()},
  114.  * and {@link EOPHistory#getEndDate()}.
  115.  * <p>
  116.  * For more on configuring the EOP data Orekit uses see
  117.  * <a href="https://www.orekit.org/forge/projects/orekit/wiki/Configuration">
  118.  * https://www.orekit.org/forge/projects/orekit/wiki/Configuration</a>.
  119.  * <p>
  120.  * Here is a schematic representation of the predefined reference frames tree:
  121.  * </p>
  122.  * <pre>
  123.  *                                                                  GCRF
  124.  *                                                                    |
  125.  *                                                 |-----------------------------------------------
  126.  *                                                 |                         |     Frame bias     |
  127.  *                                                 |                         |                 EME2000
  128.  *                                                 |                         |                    |
  129.  *                                                 |                         | Precession effects |
  130.  *                                                 |                         |                    |
  131.  *           Bias, Precession and Nutation effects |                        MOD                  MOD  (Mean Equator Of Date)
  132.  *                                                 |                         |             w/o EOP corrections
  133.  *                                                 |                         |  Nutation effects  |
  134.  *    (Celestial Intermediate Reference Frame)   CIRF                        |                    |
  135.  *                                                 |                        TOD                  TOD  (True Equator Of Date)
  136.  *                          Earth natural rotation |                         |             w/o EOP corrections
  137.  *                                                 |-------------            |    Sidereal Time   |
  138.  *                                                 |            |            |                    |
  139.  *  (Terrestrial Intermediate Reference Frame)   TIRF         TIRF         GTOD                 GTOD  (Greenwich True Of Date)
  140.  *                                                 |    w/o tidal effects                  w/o EOP corrections
  141.  *                                     Pole motion |            |                                 |
  142.  *                                                 |            |                                 |-------------
  143.  *                                                 |            |                                 |            |
  144.  * (International Terrestrial Reference Frame)   ITRF         ITRF                              ITRF        VEIS1950
  145.  *                                                 |    w/o tidal effects                   equinox-based
  146.  *                                                 |            |
  147.  *                                           other ITRF     other ITRF
  148.  *                                                      w/o tidal effects
  149.  * </pre>
  150.  * <p>
  151.  * This is a utility class, so its constructor is private.
  152.  * </p>
  153.  * @author Guylaine Prat
  154.  * @author Luc Maisonobe
  155.  * @author Pascal Parraud
  156.  */
  157. public class FramesFactory {

  159.     /** Default regular expression for the Rapid Data and Prediction EOP columns files (IAU1980 compatibles). */
  160.     public static final String RAPID_DATA_PREDICTION_COLUMNS_1980_FILENAME = "^finals\\.[^.]*$";

  162.     /** Default regular expression for the Rapid Data and Prediction EOP XML files (IAU1980 compatibles). */
  163.     public static final String RAPID_DATA_PREDICTION_XML_1980_FILENAME = "^finals\\..*\\.xml$";

  165.     /** Default regular expression for the EOPC04 files (IAU1980 compatibles). */
  166.     public static final String EOPC04_1980_FILENAME = "^eopc04_08\\.(\\d\\d)$";

  168.     /** Default regular expression for the BulletinB files (IAU1980 compatibles). */
  169.     public static final String BULLETINB_1980_FILENAME = "^bulletinb((-\\d\\d\\d\\.txt)|(\\.\\d\\d\\d))$";

  171.     /** Default regular expression for the Rapid Data and Prediction EOP columns files (IAU2000 compatibles). */
  172.     public static final String RAPID_DATA_PREDICITON_COLUMNS_2000_FILENAME = "^finals2000A\\.[^.]*$";

  174.     /** Default regular expression for the Rapid Data and Prediction EOP XML files (IAU2000 compatibles). */
  175.     public static final String RAPID_DATA_PREDICITON_XML_2000_FILENAME = "^finals2000A\\..*\\.xml$";

  177.     /** Default regular expression for the EOPC04 files (IAU2000 compatibles). */
  178.     public static final String EOPC04_2000_FILENAME = "^eopc04_08_IAU2000\\.(\\d\\d)$";

  180.     /** Default regular expression for the BulletinB files (IAU2000 compatibles). */
  181.     public static final String BULLETINB_2000_FILENAME = "^bulletinb_IAU2000((-\\d\\d\\d\\.txt)|(\\.\\d\\d\\d))$";

  183.     /** Predefined frames. */
  184.     private static transient Map<Predefined, FactoryManagedFrame> FRAMES =
  185.         new HashMap<Predefined, FactoryManagedFrame>();

  187.     /** Loaders for Earth Orientation parameters. */
  188.     private static final Map<IERSConventions, List<EOPHistoryLoader>> EOP_HISTORY_LOADERS =
  189.         new HashMap<IERSConventions, List<EOPHistoryLoader>>();

  191.     /** Private constructor.
  192.      * <p>This class is a utility class, it should neither have a public
  193.      * nor a default constructor. This private constructor prevents
  194.      * the compiler from generating one automatically.</p>
  195.      */
  196.     private FramesFactory() {
  197.     }

  199.     /** Add the default loaders EOP history (IAU 1980 precession/nutation).
  200.      * <p>
  201.      * The default loaders look for IERS EOP 08 C04 and bulletins B files. They
  202.      * correspond to {@link IERSConventions#IERS_1996 IERS 1996} conventions.
  203.      * </p>
  204.      * @param rapidDataColumnsSupportedNames regular expression for supported
  205.      * rapid data columns EOP files names
  206.      * (may be null if the default IERS file names are used)
  207.      * @param rapidDataXMLSupportedNames regular expression for supported
  208.      * rapid data XML EOP files names
  209.      * (may be null if the default IERS file names are used)
  210.      * @param eopC04SupportedNames regular expression for supported EOP 08 C04 files names
  211.      * (may be null if the default IERS file names are used)
  212.      * @param bulletinBSupportedNames regular expression for supported bulletin B files names
  213.      * (may be null if the default IERS file names are used)
  214.      * @see <a href="http://hpiers.obspm.fr/eoppc/eop/eopc04/">IERS EOP 08 C04 files</a>
  215.      * @see #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader)
  216.      * @see #clearEOPHistoryLoaders()
  217.      * @see #addDefaultEOP2000HistoryLoaders(String, String, String, String)
  218.      */
  219.     public static void addDefaultEOP1980HistoryLoaders(final String rapidDataColumnsSupportedNames,
  220.                                                        final String rapidDataXMLSupportedNames,
  221.                                                        final String eopC04SupportedNames,
  222.                                                        final String bulletinBSupportedNames) {
  223.         final String rapidColNames =
  224.                 (rapidDataColumnsSupportedNames == null) ?
  225.                 RAPID_DATA_PREDICTION_COLUMNS_1980_FILENAME : rapidDataColumnsSupportedNames;
  226.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  227.                             new RapidDataAndPredictionColumnsLoader(false, rapidColNames));
  228.         final String rapidXmlNames =
  229.                 (rapidDataXMLSupportedNames == null) ?
  230.                 RAPID_DATA_PREDICTION_XML_1980_FILENAME : rapidDataXMLSupportedNames;
  231.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  232.                             new RapidDataAndPredictionXMLLoader(rapidXmlNames));
  233.         final String eopcNames =
  234.                 (eopC04SupportedNames == null) ? EOPC04_1980_FILENAME : eopC04SupportedNames;
  235.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  236.                             new EOP08C04FilesLoader(eopcNames));
  237.         final String bulBNames =
  238.             (bulletinBSupportedNames == null) ? BULLETINB_1980_FILENAME : bulletinBSupportedNames;
  239.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  240.                             new BulletinBFilesLoader(bulBNames));
  241.     }

  243.     /** Add the default loaders for EOP history (IAU 2000/2006 precession/nutation).
  244.      * <p>
  245.      * The default loaders look for IERS EOP 08 C04 and bulletins B files. They
  246.      * correspond to both {@link IERSConventions#IERS_2003 IERS 2003} and {@link
  247.      * IERSConventions#IERS_2010 IERS 2010} conventions.
  248.      * </p>
  249.      * @param rapidDataColumnsSupportedNames regular expression for supported
  250.      * rapid data columns EOP files names
  251.      * (may be null if the default IERS file names are used)
  252.      * @param rapidDataXMLSupportedNames regular expression for supported
  253.      * rapid data XML EOP files names
  254.      * (may be null if the default IERS file names are used)
  255.      * @param eopC04SupportedNames regular expression for supported EOP 08 C04 files names
  256.      * (may be null if the default IERS file names are used)
  257.      * @param bulletinBSupportedNames regular expression for supported bulletin B files names
  258.      * (may be null if the default IERS file names are used)
  259.      * @see <a href="http://hpiers.obspm.fr/eoppc/eop/eopc04/">IERS EOP 08 C04 files</a>
  260.      * @see #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader)
  261.      * @see #clearEOPHistoryLoaders()
  262.      * @see #addDefaultEOP1980HistoryLoaders(String, String, String, String)
  263.      */
  264.     public static void addDefaultEOP2000HistoryLoaders(final String rapidDataColumnsSupportedNames,
  265.                                                        final String rapidDataXMLSupportedNames,
  266.                                                        final String eopC04SupportedNames,
  267.                                                        final String bulletinBSupportedNames) {
  268.         final String rapidColNames =
  269.                 (rapidDataColumnsSupportedNames == null) ?
  270.                 RAPID_DATA_PREDICITON_COLUMNS_2000_FILENAME : rapidDataColumnsSupportedNames;
  271.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  272.                             new RapidDataAndPredictionColumnsLoader(true, rapidColNames));
  273.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  274.                             new RapidDataAndPredictionColumnsLoader(true, rapidColNames));
  275.         final String rapidXmlNames =
  276.             (rapidDataXMLSupportedNames == null) ?
  277.             RAPID_DATA_PREDICITON_XML_2000_FILENAME : rapidDataXMLSupportedNames;
  278.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  279.                             new RapidDataAndPredictionXMLLoader(rapidXmlNames));
  280.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  281.                             new RapidDataAndPredictionXMLLoader(rapidXmlNames));
  282.         final String eopcNames =
  283.             (eopC04SupportedNames == null) ? EOPC04_2000_FILENAME : eopC04SupportedNames;
  284.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  285.                             new EOP08C04FilesLoader(eopcNames));
  286.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  287.                             new EOP08C04FilesLoader(eopcNames));
  288.         final String bulBNames =
  289.             (bulletinBSupportedNames == null) ? BULLETINB_2000_FILENAME : bulletinBSupportedNames;
  290.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  291.                             new BulletinBFilesLoader(bulBNames));
  292.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  293.                             new BulletinBFilesLoader(bulBNames));
  294.     }

  296.     /** Add a loader for Earth Orientation Parameters history.
  297.      * @param conventions IERS conventions to which EOP history applies
  298.      * @param loader custom loader to add for the EOP history
  299.      * @see #addDefaultEOP1980HistoryLoaders(String, String, String, String)
  300.      * @see #clearEOPHistoryLoaders()
  301.      */
  302.     public static void addEOPHistoryLoader(final IERSConventions conventions, final EOPHistoryLoader loader) {
  303.         synchronized (EOP_HISTORY_LOADERS) {
  304.             if (!EOP_HISTORY_LOADERS.containsKey(conventions)) {
  305.                 EOP_HISTORY_LOADERS.put(conventions, new ArrayList<EOPHistoryLoader>());
  306.             }
  307.             EOP_HISTORY_LOADERS.get(conventions).add(loader);
  308.         }
  309.     }

  311.     /** Clear loaders for Earth Orientation Parameters history.
  312.      * @see #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader)
  313.      * @see #addDefaultEOP1980HistoryLoaders(String, String, String, String)
  314.      */
  315.     public static void clearEOPHistoryLoaders() {
  316.         synchronized (EOP_HISTORY_LOADERS) {
  317.             EOP_HISTORY_LOADERS.clear();
  318.         }
  319.     }

  321.     /** Get Earth Orientation Parameters history.
  322.      * <p>
  323.      * If no {@link EOPHistoryLoader} has been added by calling {@link
  324.      * #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader) addEOPHistoryLoader}
  325.      * or if {@link #clearEOPHistoryLoaders() clearEOPHistoryLoaders} has been
  326.      * called afterwards, the {@link #addDefaultEOP1980HistoryLoaders(String, String,
  327.      * String, String)} and {@link #addDefaultEOP2000HistoryLoaders(String, String,
  328.      * String, String)} methods will be called automatically with supported file names
  329.      * parameters all set to null, in order to get the default loaders configuration.
  330.      * </p>
  331.      * @param conventions conventions for which EOP history is requested
  332.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  333.      * @return Earth Orientation Parameters history
  334.      * @exception OrekitException if the data cannot be loaded
  335.      */
  336.     public static EOPHistory getEOPHistory(final IERSConventions conventions, final boolean simpleEOP)
  337.         throws OrekitException {

  339.         synchronized (EOP_HISTORY_LOADERS) {

  341.             //TimeStamped based set needed to remove duplicates
  342.             if (EOP_HISTORY_LOADERS.isEmpty()) {
  343.                 addDefaultEOP2000HistoryLoaders(null, null, null, null);
  344.                 addDefaultEOP1980HistoryLoaders(null, null, null, null);
  345.             }

  347.             OrekitException pendingException = null;
  348.             final SortedSet<EOPEntry> data = new TreeSet<EOPEntry>(new ChronologicalComparator());

  350.             // try to load canonical data if available
  351.             if (EOP_HISTORY_LOADERS.containsKey(conventions)) {
  352.                 for (final EOPHistoryLoader loader : EOP_HISTORY_LOADERS.get(conventions)) {
  353.                     try {
  354.                         loader.fillHistory(conventions.getNutationCorrectionConverter(), data);
  355.                     } catch (OrekitException oe) {
  356.                         pendingException = oe;
  357.                     }
  358.                 }
  359.             }

  361.             if (data.isEmpty() && pendingException != null) {
  362.                 throw pendingException;
  363.             }

  365.             final EOPHistory history = new EOPHistory(conventions, data, simpleEOP);
  366.             history.checkEOPContinuity(5 * Constants.JULIAN_DAY);
  367.             return history;

  369.         }

  371.     }

  373.     /** Get one of the predefined frames.
  374.      * @param factoryKey key of the frame within the factory
  375.      * @return the predefined frame
  376.      * @exception OrekitException if frame cannot be built due to missing data
  377.      */
  378.     @SuppressWarnings("deprecation")
  379.     public static Frame getFrame(final Predefined factoryKey)
  380.         throws OrekitException {
  381.         switch (factoryKey) {
  382.         case GCRF :
  383.             return getGCRF();
  384.         case ICRF :
  385.             return getICRF();
  386.         case EME2000 :
  387.             return getEME2000();
  388.         case ITRF_2008_WITHOUT_TIDAL_EFFECTS :
  389.         case ITRF_CIO_CONV_2010_SIMPLE_EOP :
  390.             return getITRF(IERSConventions.IERS_2010, true);
  391.         case ITRF_2008_WITH_TIDAL_EFFECTS :
  392.         case ITRF_CIO_CONV_2010_ACCURATE_EOP :
  393.             return getITRF(IERSConventions.IERS_2010, false);
  394.         case ITRF_CIO_CONV_2003_SIMPLE_EOP :
  395.             return getITRF(IERSConventions.IERS_2003, true);
  396.         case ITRF_CIO_CONV_2003_ACCURATE_EOP :
  397.             return getITRF(IERSConventions.IERS_2003, false);
  398.         case ITRF_CIO_CONV_1996_SIMPLE_EOP :
  399.             return getITRF(IERSConventions.IERS_1996, true);
  400.         case ITRF_CIO_CONV_1996_ACCURATE_EOP :
  401.             return getITRF(IERSConventions.IERS_1996, false);
  402.         case ITRF_2005_WITHOUT_TIDAL_EFFECTS :
  403.             return getITRF2005(true);
  404.         case ITRF_2005_WITH_TIDAL_EFFECTS :
  405.             return getITRF2005(false);
  406.         case ITRF_2000_WITHOUT_TIDAL_EFFECTS :
  407.             return getITRF2000(true);
  408.         case ITRF_2000_WITH_TIDAL_EFFECTS :
  409.             return getITRF2000(false);
  410.         case ITRF_97_WITHOUT_TIDAL_EFFECTS :
  411.             return getITRF97(true);
  412.         case ITRF_97_WITH_TIDAL_EFFECTS :
  413.             return getITRF97(false);
  414.         case ITRF_93_WITHOUT_TIDAL_EFFECTS :
  415.             return getITRF93(true);
  416.         case ITRF_93_WITH_TIDAL_EFFECTS :
  417.             return getITRF93(false);
  418.         case ITRF_EQUINOX_CONV_2010_SIMPLE_EOP :
  419.             return getITRFEquinox(IERSConventions.IERS_2010, true);
  420.         case ITRF_EQUINOX_CONV_2010_ACCURATE_EOP :
  421.             return getITRFEquinox(IERSConventions.IERS_2010, false);
  422.         case ITRF_EQUINOX_CONV_2003_SIMPLE_EOP :
  423.             return getITRFEquinox(IERSConventions.IERS_2003, true);
  424.         case ITRF_EQUINOX_CONV_2003_ACCURATE_EOP :
  425.             return getITRFEquinox(IERSConventions.IERS_2003, false);
  426.         case ITRF_EQUINOX :
  427.         case ITRF_EQUINOX_CONV_1996_SIMPLE_EOP :
  428.             return getITRFEquinox(IERSConventions.IERS_1996, true);
  429.         case ITRF_EQUINOX_CONV_1996_ACCURATE_EOP :
  430.             return getITRFEquinox(IERSConventions.IERS_1996, false);
  431.         case TIRF_2000_CONV_2010_WITHOUT_TIDAL_EFFECTS :
  432.         case TIRF_CONVENTIONS_2010_SIMPLE_EOP :
  433.             return getTIRF(IERSConventions.IERS_2010, true);
  434.         case TIRF_2000_CONV_2010_WITH_TIDAL_EFFECTS :
  435.         case TIRF_CONVENTIONS_2010_ACCURATE_EOP :
  436.             return getTIRF(IERSConventions.IERS_2010, false);
  437.         case TIRF_2000_CONV_2003_WITHOUT_TIDAL_EFFECTS :
  438.         case TIRF_CONVENTIONS_2003_SIMPLE_EOP :
  439.             return getTIRF(IERSConventions.IERS_2003, true);
  440.         case TIRF_2000_CONV_2003_WITH_TIDAL_EFFECTS :
  441.         case TIRF_CONVENTIONS_2003_ACCURATE_EOP :
  442.             return getTIRF(IERSConventions.IERS_2003, false);
  443.         case TIRF_CONVENTIONS_1996_SIMPLE_EOP :
  444.             return getTIRF(IERSConventions.IERS_1996, true);
  445.         case TIRF_CONVENTIONS_1996_ACCURATE_EOP :
  446.             return getTIRF(IERSConventions.IERS_1996, false);
  447.         case CIRF_2000_CONV_2010 :
  448.         case CIRF_CONVENTIONS_2010_ACCURATE_EOP :
  449.             return getCIRF(IERSConventions.IERS_2010, false);
  450.         case CIRF_CONVENTIONS_2010_SIMPLE_EOP :
  451.             return getCIRF(IERSConventions.IERS_2010, true);
  452.         case CIRF_2000_CONV_2003 :
  453.         case CIRF_CONVENTIONS_2003_ACCURATE_EOP :
  454.             return getCIRF(IERSConventions.IERS_2003, false);
  455.         case CIRF_CONVENTIONS_2003_SIMPLE_EOP :
  456.             return getCIRF(IERSConventions.IERS_2003, true);
  457.         case CIRF_CONVENTIONS_1996_ACCURATE_EOP :
  458.             return getCIRF(IERSConventions.IERS_1996, false);
  459.         case CIRF_CONVENTIONS_1996_SIMPLE_EOP :
  460.             return getCIRF(IERSConventions.IERS_1996, true);
  461.         case VEIS_1950 :
  462.             return getVeis1950();
  463.         case GTOD_WITHOUT_EOP_CORRECTIONS :
  464.             return getGTOD(IERSConventions.IERS_1996, false, true);
  465.         case GTOD_CONVENTIONS_2010_ACCURATE_EOP :
  466.             return getGTOD(IERSConventions.IERS_2010, true, false);
  467.         case GTOD_CONVENTIONS_2010_SIMPLE_EOP :
  468.             return getGTOD(IERSConventions.IERS_2010, true, true);
  469.         case GTOD_CONVENTIONS_2003_ACCURATE_EOP :
  470.             return getGTOD(IERSConventions.IERS_2003, true, false);
  471.         case GTOD_CONVENTIONS_2003_SIMPLE_EOP :
  472.             return getGTOD(IERSConventions.IERS_2003, true, true);
  473.         case GTOD_WITH_EOP_CORRECTIONS :
  474.         case GTOD_CONVENTIONS_1996_ACCURATE_EOP :
  475.             return getGTOD(IERSConventions.IERS_1996, true, false);
  476.         case GTOD_CONVENTIONS_1996_SIMPLE_EOP :
  477.             return getGTOD(IERSConventions.IERS_1996, true, true);
  478.         case TOD_WITHOUT_EOP_CORRECTIONS :
  479.             return getTOD(IERSConventions.IERS_1996, false, true);
  480.         case TOD_CONVENTIONS_2010_ACCURATE_EOP :
  481.             return getTOD(IERSConventions.IERS_2010, true, false);
  482.         case TOD_CONVENTIONS_2010_SIMPLE_EOP :
  483.             return getTOD(IERSConventions.IERS_2010, true, true);
  484.         case TOD_CONVENTIONS_2003_ACCURATE_EOP :
  485.             return getTOD(IERSConventions.IERS_2003, true, false);
  486.         case TOD_CONVENTIONS_2003_SIMPLE_EOP :
  487.             return getTOD(IERSConventions.IERS_2003, true, true);
  488.         case TOD_WITH_EOP_CORRECTIONS :
  489.         case TOD_CONVENTIONS_1996_ACCURATE_EOP :
  490.             return getTOD(IERSConventions.IERS_1996, true, false);
  491.         case TOD_CONVENTIONS_1996_SIMPLE_EOP :
  492.             return getTOD(IERSConventions.IERS_1996, true, true);
  493.         case MOD_WITHOUT_EOP_CORRECTIONS :
  494.             return getMOD(IERSConventions.IERS_1996, false);
  495.         case MOD_CONVENTIONS_2010 :
  496.             return getMOD(IERSConventions.IERS_2010, true);
  497.         case MOD_CONVENTIONS_2003 :
  498.             return getMOD(IERSConventions.IERS_2003, true);
  499.         case MOD_WITH_EOP_CORRECTIONS :
  500.         case MOD_CONVENTIONS_1996 :
  501.             return getMOD(IERSConventions.IERS_1996, true);
  502.         case TEME :
  503.             return getTEME();
  504.         default :
  505.             throw OrekitException.createInternalError(null);
  506.         }
  507.     }

  509.     /** Get the unique GCRF frame.
  510.      * <p>The GCRF frame is the root frame in the frame tree.</p>
  511.      * @return the unique instance of the GCRF frame
  512.      */
  513.     public static Frame getGCRF() {
  514.         return Frame.getRoot();
  515.     }

  517.     /** Get the unique ICRF frame.
  518.      * <p>The ICRF frame is centered at solar system barycenter and aligned
  519.      * with EME2000.</p>
  520.      * @return the unique instance of the ICRF frame
  521.      * @exception OrekitException if solar system ephemerides cannot be loaded
  522.      */
  523.     public static Frame getICRF() throws OrekitException {
  524.         return CelestialBodyFactory.getSolarSystemBarycenter().getInertiallyOrientedFrame();
  525.     }

  527.     /** Get the unique EME2000 frame.
  528.      * <p>The EME2000 frame is also called the J2000 frame.
  529.      * The former denomination is preferred in Orekit.</p>
  530.      * @return the unique instance of the EME2000 frame
  531.      */
  532.     public static FactoryManagedFrame getEME2000() {
  533.         synchronized (FramesFactory.class) {

  535.             // try to find an already built frame
  536.             FactoryManagedFrame frame = FRAMES.get(Predefined.EME2000);

  538.             if (frame == null) {
  539.                 // it's the first time we need this frame, build it and store it
  540.                 frame = new FactoryManagedFrame(getGCRF(), new EME2000Provider(), true, Predefined.EME2000);
  541.                 FRAMES.put(Predefined.EME2000, frame);
  542.             }

  544.             return frame;

  546.         }
  547.     }

  549.     /** Get the ITRF2008 reference frame, using IERS 2010 conventions.
  550.      * @param conventions IERS conventions to apply
  551.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  552.      * @return the selected reference frame singleton.
  553.      * @exception OrekitException if data embedded in the library cannot be read
  554.      * @since 6.1
  555.      */
  556.     public static FactoryManagedFrame getITRF(final IERSConventions conventions,
  557.                                               final boolean simpleEOP)
  558.         throws OrekitException {
  559.         synchronized (FramesFactory.class) {

  561.             // try to find an already built frame
  562.             final Predefined factoryKey;
  563.             switch (conventions) {
  564.             case IERS_1996 :
  565.                 factoryKey = simpleEOP ?
  566.                              Predefined.ITRF_CIO_CONV_1996_SIMPLE_EOP :
  567.                              Predefined.ITRF_CIO_CONV_1996_ACCURATE_EOP;
  568.                 break;
  569.             case IERS_2003 :
  570.                 factoryKey = simpleEOP ?
  571.                              Predefined.ITRF_CIO_CONV_2003_SIMPLE_EOP :
  572.                              Predefined.ITRF_CIO_CONV_2003_ACCURATE_EOP;
  573.                 break;
  574.             case IERS_2010 :
  575.                 factoryKey = simpleEOP ?
  576.                              Predefined.ITRF_CIO_CONV_2010_SIMPLE_EOP :
  577.                              Predefined.ITRF_CIO_CONV_2010_ACCURATE_EOP;
  578.                 break;
  579.             default :
  580.                 // this should never happen
  581.                 throw OrekitException.createInternalError(null);
  582.             }
  583.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  585.             if (frame == null) {
  586.                 // it's the first time we need this frame, build it and store it
  587.                 final Frame tirfFrame = getTIRF(conventions, simpleEOP);
  588.                 final TIRFProvider tirfProvider = (TIRFProvider) tirfFrame.getTransformProvider();
  589.                 frame = new FactoryManagedFrame(tirfFrame,
  590.                                                 new ITRFProvider(tirfProvider.getEOPHistory()),
  591.                                                 false, factoryKey);
  592.                 FRAMES.put(factoryKey, frame);
  593.             }

  595.             return frame;

  597.         }
  598.     }

  600.     /** Get the ITRF2008 reference frame, using IERS 2010 conventions and ignoring tidal effects.
  601.      * @return the selected reference frame singleton.
  602.      * @exception OrekitException if the precession-nutation model data embedded in the
  603.      * library cannot be read.
  604.      * @deprecated as of 6.1, replaced with {@link #getITRF(IERSConventions, boolean)}
  605.      */
  606.     @Deprecated
  607.     public static FactoryManagedFrame getITRF2008() throws OrekitException {
  608.         return getITRF2008(true);
  609.     }

  611.     /** Get the ITRF2008 reference frame, using IERS 2010 conventions.
  612.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  613.      * @return the selected reference frame singleton.
  614.      * @exception OrekitException if the precession-nutation model data embedded in the
  615.      * library cannot be read.
  616.      * @deprecated as of 6.1, replaced with {@link #getITRF(IERSConventions, boolean)}
  617.      */
  618.     @Deprecated
  619.     public static FactoryManagedFrame getITRF2008(final boolean simpleEOP) throws OrekitException {
  620.         return getITRF(IERSConventions.IERS_2010, simpleEOP);
  621.     }

  623.     /** Get the ITRF2005 reference frame, using IERS 2010 conventions and ignoring tidal effects.
  624.      * @return the selected reference frame singleton.
  625.      * @exception OrekitException if the precession-nutation model data embedded in the
  626.      * library cannot be read.
  627.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  628.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_2005}
  629.      */
  630.     @Deprecated
  631.     public static FactoryManagedFrame getITRF2005() throws OrekitException {
  632.         return getITRF2005(true);
  633.     }

  635.     /** Get the ITRF2005 reference frame, using IERS 2010 conventions.
  636.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  637.      * @return the selected reference frame singleton.
  638.      * @exception OrekitException if the precession-nutation model data embedded in the
  639.      * library cannot be read.
  640.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  641.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_2005}
  642.      */
  643.     @Deprecated
  644.     public static FactoryManagedFrame getITRF2005(final boolean simpleEOP) throws OrekitException {

  646.         final Predefined factoryKey = simpleEOP ?
  647.                                       Predefined.ITRF_2005_WITHOUT_TIDAL_EFFECTS :
  648.                                       Predefined.ITRF_2005_WITH_TIDAL_EFFECTS;

  650.         return getITRSRealization(factoryKey, getITRF2008(simpleEOP),
  651.                                   HelmertTransformation.Predefined.ITRF_2008_TO_ITRF_2005);

  653.     }

  655.     /** Get the ITRF2000 reference frame, ignoring tidal effects.
  656.      * @return the selected reference frame singleton.
  657.      * @exception OrekitException if the precession-nutation model data embedded in the
  658.      * library cannot be read.
  659.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  660.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_2000}
  661.      */
  662.     @Deprecated
  663.     public static FactoryManagedFrame getITRF2000() throws OrekitException {
  664.         return getITRF2000(true);
  665.     }

  667.     /** Get the ITRF2000 reference frame.
  668.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  669.      * @return the selected reference frame singleton.
  670.      * @exception OrekitException if the precession-nutation model data embedded in the
  671.      * library cannot be read.
  672.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  673.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_2000}
  674.      */
  675.     @Deprecated
  676.     public static FactoryManagedFrame getITRF2000(final boolean simpleEOP) throws OrekitException {

  678.         final Predefined factoryKey = simpleEOP ?
  679.                                       Predefined.ITRF_2000_WITHOUT_TIDAL_EFFECTS :
  680.                                       Predefined.ITRF_2000_WITH_TIDAL_EFFECTS;

  682.         return getITRSRealization(factoryKey, getITRF2008(simpleEOP),
  683.                                   HelmertTransformation.Predefined.ITRF_2008_TO_ITRF_2000);

  685.     }

  687.     /** Get the ITRF97 reference frame, ignoring tidal effects.
  688.      * @return the selected reference frame singleton.
  689.      * @exception OrekitException if the precession-nutation model data embedded in the
  690.      * library cannot be read.
  691.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  692.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_97}
  693.      */
  694.     @Deprecated
  695.     public static FactoryManagedFrame getITRF97() throws OrekitException {
  696.         return getITRF97(true);
  697.     }

  699.     /** Get the ITRF97 reference frame.
  700.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  701.      * @return the selected reference frame singleton.
  702.      * @exception OrekitException if the precession-nutation model data embedded in the
  703.      * library cannot be read.
  704.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  705.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_97}
  706.      */
  707.     @Deprecated
  708.     public static FactoryManagedFrame getITRF97(final boolean simpleEOP) throws OrekitException {

  710.         final Predefined factoryKey = simpleEOP ?
  711.                                       Predefined.ITRF_97_WITHOUT_TIDAL_EFFECTS :
  712.                                       Predefined.ITRF_97_WITH_TIDAL_EFFECTS;

  714.         return getITRSRealization(factoryKey, getITRF2008(simpleEOP),
  715.                                   HelmertTransformation.Predefined.ITRF_2008_TO_ITRF_97);

  717.     }

  719.     /** Get the ITRF93 reference frame, ignoring tidal effects.
  720.      * @return the selected reference frame singleton.
  721.      * @exception OrekitException if the precession-nutation model data embedded in the
  722.      * library cannot be read.
  723.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  724.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_93}
  725.      */
  726.     @Deprecated
  727.     public static FactoryManagedFrame getITRF93() throws OrekitException {
  728.         return getITRF93(true);
  729.     }

  731.     /** Get the ITRF93 reference frame.
  732.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  733.      * @return the selected reference frame singleton.
  734.      * @exception OrekitException if the precession-nutation model data embedded in the
  735.      * library cannot be read.
  736.      * @deprecated as of 6.1, replaced by {@link #getITRF(IERSConventions, boolean)} and
  737.      * {@link HelmertTransformation.Predefined#ITRF_2008_TO_ITRF_93}
  738.      */
  739.     @Deprecated
  740.     public static FactoryManagedFrame getITRF93(final boolean simpleEOP) throws OrekitException {

  742.         final Predefined factoryKey = simpleEOP ?
  743.                                       Predefined.ITRF_93_WITHOUT_TIDAL_EFFECTS :
  744.                                       Predefined.ITRF_93_WITH_TIDAL_EFFECTS;

  746.         return getITRSRealization(factoryKey, getITRF2008(simpleEOP),
  747.                                   HelmertTransformation.Predefined.ITRF_2008_TO_ITRF_93);

  749.     }

  751.     /** Get an ITRS realization reference frame.
  752.      * @param factoryKey key of the frame within the factory
  753.      * @param parent parent frame to which the Helmert transformation should be applied
  754.      * to define the desired realization
  755.      * @param predefined predefined transformation between parent frame and created frame
  756.      * @return the selected reference frame singleton.
  757.      * @exception OrekitException if the precession-nutation model data embedded in the
  758.      * library cannot be read.
  759.      */
  760.     private static FactoryManagedFrame getITRSRealization(final Predefined factoryKey, final Frame parent,
  761.                                                           final HelmertTransformation.Predefined predefined)
  762.         throws OrekitException {
  763.         synchronized (FramesFactory.class) {

  765.             // try to find an already built frame
  766.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  768.             if (frame == null) {
  769.                 // it's the first time we need this frame, build it and store it
  770.                 final Frame nonFactoryManaged = predefined.createTransformedITRF(parent, factoryKey.getName());
  771.                 final TransformProvider provider = nonFactoryManaged.getTransformProvider();
  772.                 frame = new FactoryManagedFrame(parent, provider, false, factoryKey);
  773.                 FRAMES.put(factoryKey, frame);

  775.             }

  777.             return frame;

  779.         }
  780.     }

  782.     /** Get the TIRF reference frame, ignoring tidal effects.
  783.      * @param conventions IERS conventions to apply
  784.      * @return the selected reference frame singleton.
  785.      * @exception OrekitException if the precession-nutation model data embedded in the
  786.      * library cannot be read.
  787.      * @deprecated since 6.1 replaced with {@link #getTIRF(IERSConventions)}
  788.      */
  789.     @Deprecated
  790.     public static FactoryManagedFrame getTIRF2000(final IERSConventions conventions) throws OrekitException {
  791.         return getTIRF(conventions);
  792.     }

  794.     /** Get the TIRF reference frame, ignoring tidal effects.
  795.      * @param conventions IERS conventions to apply
  796.      * @return the selected reference frame singleton.
  797.      * @exception OrekitException if the precession-nutation model data embedded in the
  798.      * library cannot be read.
  799.      */
  800.     public static FactoryManagedFrame getTIRF(final IERSConventions conventions) throws OrekitException {
  801.         return getTIRF(conventions, true);
  802.     }

  804.     /** Get the TIRF reference frame.
  805.      * @param conventions IERS conventions to apply
  806.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  807.      * @return the selected reference frame singleton.
  808.      * @exception OrekitException if the precession-nutation model data embedded in the
  809.      * library cannot be read.
  810.      * @deprecated since 6.1 replaced with {@link #getTIRF(IERSConventions, boolean)}
  811.      */
  812.     @Deprecated
  813.     public static FactoryManagedFrame getTIRF2000(final IERSConventions conventions,
  814.                                                   final boolean simpleEOP) throws OrekitException {
  815.         return getTIRF(conventions, simpleEOP);
  816.     }

  818.     /** Get the TIRF reference frame.
  819.      * @param conventions IERS conventions to apply
  820.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  821.      * @return the selected reference frame singleton.
  822.      * @exception OrekitException if the precession-nutation model data embedded in the
  823.      * library cannot be read.
  824.      * @since 6.1
  825.      */
  826.     public static FactoryManagedFrame getTIRF(final IERSConventions conventions,
  827.                                               final boolean simpleEOP)
  828.         throws OrekitException {
  829.         synchronized (FramesFactory.class) {

  831.             // try to find an already built frame
  832.             final Predefined factoryKey;
  833.             switch (conventions) {
  834.             case IERS_1996 :
  835.                 factoryKey = simpleEOP ?
  836.                              Predefined.TIRF_CONVENTIONS_1996_SIMPLE_EOP :
  837.                              Predefined.TIRF_CONVENTIONS_1996_ACCURATE_EOP;
  838.                 break;
  839.             case IERS_2003 :
  840.                 factoryKey = simpleEOP ?
  841.                              Predefined.TIRF_CONVENTIONS_2003_SIMPLE_EOP :
  842.                              Predefined.TIRF_CONVENTIONS_2003_ACCURATE_EOP;
  843.                 break;
  844.             case IERS_2010 :
  845.                 factoryKey = simpleEOP ?
  846.                              Predefined.TIRF_CONVENTIONS_2010_SIMPLE_EOP :
  847.                              Predefined.TIRF_CONVENTIONS_2010_ACCURATE_EOP;
  848.                 break;
  849.             default :
  850.                 // this should never happen
  851.                 throw OrekitException.createInternalError(null);
  852.             }
  853.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  855.             if (frame == null) {
  856.                 // it's the first time we need this frame, build it and store it
  857.                 final Frame cirf = getCIRF(conventions, simpleEOP);
  858.                 final InterpolatingTransformProvider cirfInterpolating =
  859.                         (InterpolatingTransformProvider) cirf.getTransformProvider();
  860.                 final CIRFProvider cirfRaw = (CIRFProvider) cirfInterpolating.getRawProvider();
  861.                 final EOPHistory eopHistory = cirfRaw.getEOPHistory();
  862.                 frame = new FactoryManagedFrame(cirf, new TIRFProvider(eopHistory), false, factoryKey);
  863.                 FRAMES.put(factoryKey, frame);
  864.             }

  866.             return frame;

  868.         }
  869.     }

  871.     /** Get the CIRF2000 reference frame.
  872.      * @param conventions IERS conventions to apply
  873.      * @return the selected reference frame singleton.
  874.      * @exception OrekitException if the precession-nutation model data embedded in the
  875.      * library cannot be read.
  876.      * @deprecated since 6.1 repaced with {@link #getCIRF(IERSConventions, boolean)}
  877.      */
  878.     @Deprecated
  879.     public static FactoryManagedFrame getCIRF2000(final IERSConventions conventions) throws OrekitException {
  880.         return getCIRF(conventions, false);
  881.     }

  883.     /** Get the CIRF2000 reference frame.
  884.      * @param conventions IERS conventions to apply
  885.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  886.      * @return the selected reference frame singleton.
  887.      * @exception OrekitException if the precession-nutation model data embedded in the
  888.      * library cannot be read.
  889.      */
  890.     public static FactoryManagedFrame getCIRF(final IERSConventions conventions,
  891.                                               final boolean simpleEOP)
  892.         throws OrekitException {
  893.         synchronized (FramesFactory.class) {

  895.             // try to find an already built frame
  896.             final Predefined factoryKey;
  897.             switch (conventions) {
  898.             case IERS_1996 :
  899.                 factoryKey = simpleEOP ?
  900.                              Predefined.CIRF_CONVENTIONS_1996_SIMPLE_EOP :
  901.                              Predefined.CIRF_CONVENTIONS_1996_ACCURATE_EOP;
  902.                 break;
  903.             case IERS_2003 :
  904.                 factoryKey = simpleEOP ?
  905.                              Predefined.CIRF_CONVENTIONS_2003_SIMPLE_EOP :
  906.                              Predefined.CIRF_CONVENTIONS_2003_ACCURATE_EOP;
  907.                 break;
  908.             case IERS_2010 :
  909.                 factoryKey = simpleEOP ?
  910.                              Predefined.CIRF_CONVENTIONS_2010_SIMPLE_EOP :
  911.                              Predefined.CIRF_CONVENTIONS_2010_ACCURATE_EOP;
  912.                 break;
  913.             default :
  914.                 // this should never happen
  915.                 throw OrekitException.createInternalError(null);
  916.             }
  917.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  919.             if (frame == null) {
  920.                 // it's the first time we need this frame, build it and store it
  921.                 final EOPHistory eopHistory = FramesFactory.getEOPHistory(conventions, simpleEOP);
  922.                 final TransformProvider interpolating =
  923.                         new InterpolatingTransformProvider(new CIRFProvider(eopHistory), true, false,
  924.                                                            AbsoluteDate.PAST_INFINITY, AbsoluteDate.FUTURE_INFINITY,
  925.                                                            6, Constants.JULIAN_DAY / 24,
  926.                                                            OrekitConfiguration.getCacheSlotsNumber(),
  927.                                                            Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  928.                 frame = new FactoryManagedFrame(getGCRF(), interpolating, true, factoryKey);
  929.                 FRAMES.put(factoryKey, frame);
  930.             }

  932.             return frame;

  934.         }
  935.     }

  937.     /** Get the VEIS 1950 reference frame.
  938.      * <p>Its parent frame is the GTOD frame with IERS 1996 conventions without EOP corrections.<p>
  939.      * @return the selected reference frame singleton.
  940.      * @exception OrekitException if data embedded in the library cannot be read
  941.      */
  942.     public static FactoryManagedFrame getVeis1950() throws OrekitException {
  943.         synchronized (FramesFactory.class) {

  945.             // try to find an already built frame
  946.             final Predefined factoryKey = Predefined.VEIS_1950;
  947.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  949.             if (frame == null) {
  950.                 // it's the first time we need this frame, build it and store it
  951.                 frame = new FactoryManagedFrame(FramesFactory.getGTOD(IERSConventions.IERS_1996, false, true),
  952.                                                 new VEISProvider(), true, factoryKey);
  953.                 FRAMES.put(factoryKey, frame);
  954.             }

  956.             return frame;

  958.         }
  959.     }

  961.     /** Get the equinox-based ITRF reference frame.
  962.      * @return the selected reference frame singleton.
  963.      * @exception OrekitException if data embedded in the library cannot be read
  964.      * @deprecated since 6.1 replaced with {@link #getITRFEquinox(IERSConventions, boolean)}
  965.      */
  966.     @Deprecated
  967.     public static FactoryManagedFrame getITRFEquinox() throws OrekitException {
  968.         return getITRFEquinox(IERSConventions.IERS_1996, true);
  969.     }

  971.     /** Get the equinox-based ITRF reference frame.
  972.      * @param conventions IERS conventions to apply
  973.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  974.      * @return the selected reference frame singleton.
  975.      * @exception OrekitException if data embedded in the library cannot be read
  976.      * @since 6.1
  977.      */
  978.     public static FactoryManagedFrame getITRFEquinox(final IERSConventions conventions,
  979.                                                      final boolean simpleEOP)
  980.         throws OrekitException {
  981.         synchronized (FramesFactory.class) {

  983.             // try to find an already built frame
  984.             final Predefined factoryKey;
  985.             switch (conventions) {
  986.             case IERS_1996 :
  987.                 factoryKey = simpleEOP ?
  988.                              Predefined.ITRF_EQUINOX_CONV_1996_SIMPLE_EOP :
  989.                              Predefined.ITRF_EQUINOX_CONV_1996_ACCURATE_EOP;
  990.                 break;
  991.             case IERS_2003 :
  992.                 factoryKey = simpleEOP ?
  993.                              Predefined.ITRF_EQUINOX_CONV_2003_SIMPLE_EOP :
  994.                              Predefined.ITRF_EQUINOX_CONV_2003_ACCURATE_EOP;
  995.                 break;
  996.             case IERS_2010 :
  997.                 factoryKey = simpleEOP ?
  998.                              Predefined.ITRF_EQUINOX_CONV_2010_SIMPLE_EOP :
  999.                              Predefined.ITRF_EQUINOX_CONV_2010_ACCURATE_EOP;
  1000.                 break;
  1001.             default :
  1002.                 // this should never happen
  1003.                 throw OrekitException.createInternalError(null);
  1004.             }
  1005.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1007.             if (frame == null) {
  1008.                 // it's the first time we need this frame, build it and store it
  1009.                 final Frame gtod = getGTOD(conventions, true, simpleEOP);
  1010.                 final InterpolatingTransformProvider gtodInterpolating =
  1011.                         (InterpolatingTransformProvider) gtod.getTransformProvider();
  1012.                 final GTODProvider gtodRaw    = (GTODProvider) gtodInterpolating.getRawProvider();
  1013.                 final EOPHistory   eopHistory = gtodRaw.getEOPHistory();
  1014.                 frame = new FactoryManagedFrame(gtod, new ITRFProvider(eopHistory), false, factoryKey);
  1015.                 FRAMES.put(factoryKey, frame);
  1016.             }

  1018.             return frame;

  1020.         }
  1021.     }

  1023.     /** Get the GTOD reference frame.
  1024.      * <p>
  1025.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1026.      * consistency with legacy software that don't handle EOP correction parameters.
  1027.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1028.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  1029.      * For this reason, setting this parameter to false is restricted to {@link
  1030.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  1031.      * IERSConventions IERS conventions} cannot be freely chosen here.
  1032.      * </p>
  1033.      * @param applyEOPCorr if true, EOP corrections are applied (here, dut1 and lod)
  1034.      * @return the selected reference frame singleton.
  1035.      * @exception OrekitException if data embedded in the library cannot be read
  1036.      */
  1037.     public static FactoryManagedFrame getGTOD(final boolean applyEOPCorr) throws OrekitException {
  1038.         return getGTOD(IERSConventions.IERS_1996, applyEOPCorr, true);
  1039.     }

  1041.     /** Get the GTOD reference frame.
  1042.      * @param conventions IERS conventions to apply
  1043.      * @return the selected reference frame singleton.
  1044.      * @exception OrekitException if data embedded in the library cannot be read
  1045.      * @deprecated as of 6.1, replaced with {@link #getGTOD(IERSConventions, boolean)}
  1046.      */
  1047.     @Deprecated
  1048.     public static FactoryManagedFrame getGTOD(final IERSConventions conventions)
  1049.         throws OrekitException {
  1050.         return getGTOD(conventions, true, true);
  1051.     }

  1053.     /** Get the GTOD reference frame.
  1054.      * @param conventions IERS conventions to apply
  1055.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1056.      * @return the selected reference frame singleton.
  1057.      * @exception OrekitException if data embedded in the library cannot be read
  1058.      */
  1059.     public static FactoryManagedFrame getGTOD(final IERSConventions conventions,
  1060.                                               final boolean simpleEOP)
  1061.         throws OrekitException {
  1062.         return getGTOD(conventions, true, simpleEOP);
  1063.     }

  1065.     /** Get the GTOD reference frame.
  1066.      * <p>
  1067.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1068.      * consistency with legacy software that don't handle EOP correction parameters.
  1069.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1070.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  1071.      * For this reason, setting this parameter to false is restricted to {@link
  1072.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence this method is private.
  1073.      * </p>
  1074.      * @param conventions IERS conventions to apply
  1075.      * @param applyEOPCorr if true, EOP corrections are applied (here, dut1 and lod)
  1076.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1077.      * @return the selected reference frame singleton.
  1078.      * @exception OrekitException if data embedded in the library cannot be read
  1079.      */
  1080.     private static FactoryManagedFrame getGTOD(final IERSConventions conventions,
  1081.                                                final boolean applyEOPCorr,
  1082.                                                final boolean simpleEOP)
  1083.         throws OrekitException {

  1085.         if (conventions != IERSConventions.IERS_1996 && !applyEOPCorr) {
  1086.             // this should never happen as this method is private and called
  1087.             // only above with controlled input
  1088.             throw OrekitException.createInternalError(null);
  1089.         }

  1091.         synchronized (FramesFactory.class) {

  1093.             // try to find an already built frame
  1094.             final Predefined factoryKey;
  1095.             switch (conventions) {
  1096.             case IERS_1996 :
  1097.                 factoryKey = applyEOPCorr ?
  1098.                              (simpleEOP ? Predefined.GTOD_CONVENTIONS_1996_SIMPLE_EOP : Predefined.GTOD_CONVENTIONS_1996_ACCURATE_EOP) :
  1099.                              Predefined.GTOD_WITHOUT_EOP_CORRECTIONS;
  1100.                 break;
  1101.             case IERS_2003 :
  1102.                 factoryKey = simpleEOP ?
  1103.                              Predefined.GTOD_CONVENTIONS_2003_SIMPLE_EOP :
  1104.                              Predefined.GTOD_CONVENTIONS_2003_ACCURATE_EOP;
  1105.                 break;
  1106.             case IERS_2010 :
  1107.                 factoryKey = simpleEOP ?
  1108.                              Predefined.GTOD_CONVENTIONS_2010_SIMPLE_EOP :
  1109.                              Predefined.GTOD_CONVENTIONS_2010_ACCURATE_EOP;
  1110.                 break;
  1111.             default :
  1112.                 // this should never happen
  1113.                 throw OrekitException.createInternalError(null);
  1114.             }
  1115.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1117.             if (frame == null) {
  1118.                 // it's the first time we need this frame, build it and store it
  1119.                 final Frame tod = getTOD(conventions, applyEOPCorr, simpleEOP);
  1120.                 final InterpolatingTransformProvider todInterpolating =
  1121.                         (InterpolatingTransformProvider) tod.getTransformProvider();
  1122.                 final TODProvider       todRaw     = (TODProvider) todInterpolating.getRawProvider();
  1123.                 final EOPHistory        eopHistory = todRaw.getEOPHistory();
  1124.                 final GTODProvider      gtodRaw    = new GTODProvider(conventions, eopHistory);
  1125.                 final TransformProvider gtodInterpolating =
  1126.                         new InterpolatingTransformProvider(gtodRaw, true, false,
  1127.                                                            AbsoluteDate.PAST_INFINITY, AbsoluteDate.FUTURE_INFINITY,
  1128.                                                            todInterpolating.getGridPoints(), todInterpolating.getStep(),
  1129.                                                            OrekitConfiguration.getCacheSlotsNumber(),
  1130.                                                            Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  1131.                 frame = new FactoryManagedFrame(tod, gtodInterpolating, false, factoryKey);
  1132.                 FRAMES.put(factoryKey, frame);
  1133.             }

  1135.             return frame;

  1137.         }
  1138.     }

  1140.     /** Get the GTOD reference frame.
  1141.      * <p>
  1142.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1143.      * consistency with legacy software that don't handle EOP correction parameters.
  1144.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1145.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  1146.      * </p>
  1147.      * @param applyEOPCorr if true, EOP corrections are applied (here, lod)
  1148.      * @return the selected reference frame singleton.
  1149.      * @exception OrekitException if data embedded in the library cannot be read
  1150.      * @deprecated as of 6.0, replaced by {@link #getGTOD(IERSConventions, boolean)}
  1151.      */
  1152.     @Deprecated
  1153.     public static FactoryManagedFrame getPEF(final boolean applyEOPCorr) throws OrekitException {
  1154.         return getGTOD(applyEOPCorr);
  1155.     }

  1157.     /** Get the TOD reference frame.
  1158.      * <p>
  1159.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1160.      * consistency with legacy software that don't handle EOP correction parameters.
  1161.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1162.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1163.      * For this reason, setting this parameter to false is restricted to {@link
  1164.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  1165.      * IERSConventions IERS conventions} cannot be freely chosen here.
  1166.      * </p>
  1167.      * @param applyEOPCorr if true, EOP corrections are applied (here, nutation)
  1168.      * @return the selected reference frame singleton.
  1169.      * @exception OrekitException if data embedded in the library cannot be read
  1170.      */
  1171.     public static FactoryManagedFrame getTOD(final boolean applyEOPCorr)
  1172.         throws OrekitException {
  1173.         return getTOD(IERSConventions.IERS_1996, applyEOPCorr, false);
  1174.     }

  1176.     /** Get the TOD reference frame.
  1177.      * @param conventions IERS conventions to apply
  1178.      * @return the selected reference frame singleton.
  1179.      * @exception OrekitException if data embedded in the library cannot be read
  1180.      * @deprecated as of 6.1, replaced with {@link #getTOD(IERSConventions, boolean)}
  1181.      */
  1182.     public static FactoryManagedFrame getTOD(final IERSConventions conventions)
  1183.         throws OrekitException {
  1184.         return getTOD(conventions, true, true);
  1185.     }

  1187.     /** Get the TOD reference frame.
  1188.      * @param conventions IERS conventions to apply
  1189.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1190.      * @return the selected reference frame singleton.
  1191.      * @exception OrekitException if data embedded in the library cannot be read
  1192.      */
  1193.     public static FactoryManagedFrame getTOD(final IERSConventions conventions,
  1194.                                              final boolean simpleEOP)
  1195.         throws OrekitException {
  1196.         return getTOD(conventions, true, simpleEOP);
  1197.     }

  1199.     /** Get the TOD reference frame.
  1200.      * <p>
  1201.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1202.      * consistency with legacy software that don't handle EOP correction parameters.
  1203.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1204.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1205.      * For this reason, setting this parameter to false is restricted to {@link
  1206.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence this method is private.
  1207.      * </p>
  1208.      * @param conventions IERS conventions to apply
  1209.      * @param applyEOPCorr if true, EOP corrections are applied (here, nutation)
  1210.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1211.      * @return the selected reference frame singleton.
  1212.      * @exception OrekitException if data embedded in the library cannot be read
  1213.      */
  1214.     private static FactoryManagedFrame getTOD(final IERSConventions conventions,
  1215.                                               final boolean applyEOPCorr,
  1216.                                               final boolean simpleEOP)
  1217.         throws OrekitException {

  1219.         if (conventions != IERSConventions.IERS_1996 && !applyEOPCorr) {
  1220.             // this should never happen as this method is private and called
  1221.             // only above with controlled input
  1222.             throw OrekitException.createInternalError(null);
  1223.         }

  1225.         synchronized (FramesFactory.class) {

  1227.             // try to find an already built frame
  1228.             final Predefined factoryKey;
  1229.             switch (conventions) {
  1230.             case IERS_1996 :
  1231.                 factoryKey = applyEOPCorr ?
  1232.                              (simpleEOP ? Predefined.TOD_CONVENTIONS_1996_SIMPLE_EOP : Predefined.TOD_CONVENTIONS_1996_ACCURATE_EOP) :
  1233.                              Predefined.TOD_WITHOUT_EOP_CORRECTIONS;
  1234.                 break;
  1235.             case IERS_2003 :
  1236.                 factoryKey = simpleEOP ?
  1237.                              Predefined.TOD_CONVENTIONS_2003_SIMPLE_EOP :
  1238.                              Predefined.TOD_CONVENTIONS_2003_ACCURATE_EOP;
  1239.                 break;
  1240.             case IERS_2010 :
  1241.                 factoryKey = simpleEOP ?
  1242.                              Predefined.TOD_CONVENTIONS_2010_SIMPLE_EOP :
  1243.                              Predefined.TOD_CONVENTIONS_2010_ACCURATE_EOP;
  1244.                 break;
  1245.             default :
  1246.                 // this should never happen
  1247.                 throw OrekitException.createInternalError(null);
  1248.             }
  1249.             final int interpolationPoints;
  1250.             final int pointsPerDay;
  1251.             if (applyEOPCorr) {
  1252.                 interpolationPoints = 6;
  1253.                 pointsPerDay        = 24;
  1254.             } else {
  1255.                 interpolationPoints = 6;
  1256.                 pointsPerDay        = 8;
  1257.             }
  1258.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1260.             if (frame == null) {
  1261.                 // it's the first time we need this frame, build it and store it
  1262.                 final EOPHistory eopHistory = applyEOPCorr ? getEOPHistory(conventions, simpleEOP) : null;
  1263.                 final TransformProvider interpolating =
  1264.                         new InterpolatingTransformProvider(new TODProvider(conventions, eopHistory),
  1265.                                                            true, false,
  1266.                                                            AbsoluteDate.PAST_INFINITY, AbsoluteDate.FUTURE_INFINITY,
  1267.                                                            interpolationPoints, Constants.JULIAN_DAY / pointsPerDay,
  1268.                                                            OrekitConfiguration.getCacheSlotsNumber(),
  1269.                                                            Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  1270.                 frame = new FactoryManagedFrame(getMOD(conventions, applyEOPCorr), interpolating, true, factoryKey);
  1271.                 FRAMES.put(factoryKey, frame);
  1272.             }

  1274.             return frame;

  1276.         }
  1277.     }

  1279.     /** Get the MOD reference frame.
  1280.      * <p>
  1281.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1282.      * consistency with legacy software that don't handle EOP correction parameters.
  1283.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1284.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1285.      * For this reason, setting this parameter to false is restricted to {@link
  1286.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  1287.      * IERSConventions IERS conventions} cannot be freely chosen here.
  1288.      * </p>
  1289.      * @param applyEOPCorr if true, EOP corrections are applied (EME2000/GCRF bias compensation)
  1290.      * @return the selected reference frame singleton.
  1291.      * @exception OrekitException if data embedded in the library cannot be read
  1292.      */
  1293.     public static FactoryManagedFrame getMOD(final boolean applyEOPCorr)
  1294.         throws OrekitException {
  1295.         return getMOD(IERSConventions.IERS_1996, applyEOPCorr);
  1296.     }

  1298.     /** Get the MOD reference frame.
  1299.      * @param conventions IERS conventions to apply
  1300.      * @return the selected reference frame singleton.
  1301.      * @exception OrekitException if data embedded in the library cannot be read
  1302.      */
  1303.     public static FactoryManagedFrame getMOD(final IERSConventions conventions)
  1304.         throws OrekitException {
  1305.         return getMOD(conventions, true);
  1306.     }

  1308.     /** Get the MOD reference frame.
  1309.      * <p>
  1310.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1311.      * consistency with legacy software that don't handle EOP correction parameters.
  1312.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1313.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1314.      * For this reason, setting this parameter to false is restricted to {@link
  1315.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence this method is private.
  1316.      * </p>
  1317.      * @param conventions IERS conventions to apply
  1318.      * @param applyEOPCorr if true, EOP corrections are applied (EME2000/GCRF bias compensation)
  1319.      * @return the selected reference frame singleton.
  1320.      * @exception OrekitException if data embedded in the library cannot be read
  1321.      */
  1322.     private static FactoryManagedFrame getMOD(final IERSConventions conventions, final boolean applyEOPCorr)
  1323.         throws OrekitException {

  1325.         if (conventions != IERSConventions.IERS_1996 && !applyEOPCorr) {
  1326.             // this should never happen as this method is private and called
  1327.             // only above with controlled input
  1328.             throw OrekitException.createInternalError(null);
  1329.         }

  1331.         synchronized (FramesFactory.class) {

  1333.             final Predefined factoryKey;
  1334.             final Frame parent;
  1335.             switch (conventions) {
  1336.             case IERS_1996 :
  1337.                 factoryKey = applyEOPCorr ? Predefined.MOD_CONVENTIONS_1996 : Predefined.MOD_WITHOUT_EOP_CORRECTIONS;
  1338.                 parent     = applyEOPCorr ? FramesFactory.getGCRF() : FramesFactory.getEME2000();
  1339.                 break;
  1340.             case IERS_2003 :
  1341.                 factoryKey = Predefined.MOD_CONVENTIONS_2003;
  1342.                 // in IERS conventions 2003, the precession angles zetaA, thetaA and zA
  1343.                 // from equation 33 are computed from EME2000, not from GCRF
  1344.                 parent     = FramesFactory.getEME2000();
  1345.                 break;
  1346.             case IERS_2010 :
  1347.                 factoryKey = Predefined.MOD_CONVENTIONS_2010;
  1348.                 // precession angles epsilon0, psiA, omegaA and chiA
  1349.                 // from equations 5.39 and 5.40 are computed from EME2000
  1350.                 parent     = FramesFactory.getEME2000();
  1351.                 break;
  1352.             default :
  1353.                 // this should never happen
  1354.                 throw OrekitException.createInternalError(null);
  1355.             }

  1357.             // try to find an already built frame
  1358.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1360.             if (frame == null) {
  1361.                 // it's the first time we need this frame, build it and store it
  1362.                 frame = new FactoryManagedFrame(parent, new MODProvider(conventions), true, factoryKey);
  1363.                 FRAMES.put(factoryKey, frame);
  1364.             }

  1366.             return frame;

  1368.         }
  1369.     }

  1371.     /** Get the MOD reference frame.
  1372.      * <p>
  1373.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1374.      * consistency with legacy software that don't handle EOP correction parameters.
  1375.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1376.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1377.      * </p>
  1378.      * @param applyEOPCorr if true, EOP corrections are applied (EME2000/GCRF bias compensation)
  1379.      * @return the selected reference frame singleton.
  1380.      * @exception OrekitException if data embedded in the library cannot be read
  1381.      * @deprecated as of 6.0, replaced by {@link #getMOD(IERSConventions)}
  1382.      */
  1383.     @Deprecated
  1384.     public static FactoryManagedFrame getMEME(final boolean applyEOPCorr) throws OrekitException {
  1385.         return getMOD(IERSConventions.IERS_1996, applyEOPCorr);
  1386.     }

  1388.     /** Get the TEME reference frame.
  1389.      * <p>
  1390.      * The TEME frame is used for the SGP4 model in TLE propagation. This frame has <em>no</em>
  1391.      * official definition and there are some ambiguities about whether it should be used
  1392.      * as "of date" or "of epoch". This frame should therefore be used <em>only</em> for
  1393.      * TLE propagation and not for anything else, as recommended by the CCSDS Orbit Data Message
  1394.      * blue book.
  1395.      * </p>
  1396.      * @return the selected reference frame singleton.
  1397.      * @exception OrekitException if data embedded in the library cannot be read
  1398.      */
  1399.     public static FactoryManagedFrame getTEME() throws OrekitException {
  1400.         synchronized (FramesFactory.class) {

  1402.             // try to find an already built frame
  1403.             final Predefined factoryKey = Predefined.TEME;
  1404.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1406.             if (frame == null) {
  1407.                 // it's the first time we need this frame, build it and store it
  1408.                 final Frame tod = getTOD(IERSConventions.IERS_1996, false, true);
  1409.                 final InterpolatingTransformProvider todInterpolating =
  1410.                         (InterpolatingTransformProvider) tod.getTransformProvider();
  1411.                 final TEMEProvider temeRaw = new TEMEProvider(IERSConventions.IERS_1996, null);
  1412.                 final TransformProvider temeInterpolating =
  1413.                         new InterpolatingTransformProvider(temeRaw, true, false,
  1414.                                                            AbsoluteDate.PAST_INFINITY, AbsoluteDate.FUTURE_INFINITY,
  1415.                                                            todInterpolating.getGridPoints(), todInterpolating.getStep(),
  1416.                                                            OrekitConfiguration.getCacheSlotsNumber(),
  1417.                                                            Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);

  1419.                 frame = new FactoryManagedFrame(tod, temeInterpolating, true, factoryKey);
  1420.                 FRAMES.put(factoryKey, frame);
  1421.             }

  1423.             return frame;

  1425.         }
  1426.     }

  1428.     /** Get the transform between two frames, suppressing all interpolation.
  1429.      * <p>
  1430.      * This method is similar to {@link Frame#getTransformTo(Frame, AbsoluteDate)}
  1431.      * except it removes the performance enhancing interpolation features that are
  1432.      * added by the {@link FramesFactory factory} to some frames, in order to focus
  1433.      * on accuracy. The interpolation features are intended to save processing time
  1434.      * by avoiding doing some lengthy computation like nutation evaluation at each
  1435.      * time step and caching some results. This method can be used to avoid this,
  1436.      * when very high accuracy is desired, or for testing purposes. It should be
  1437.      * used with care, as doing the full computation is <em>really</em> costly for
  1438.      * some frames.
  1439.      * </p>
  1440.      * @param from frame from which transformation starts
  1441.      * @param to frame to which transformation ends
  1442.      * @param date date of the transform
  1443.      * @return transform between the two frames, avoiding interpolation
  1444.      * @throws OrekitException if transform cannot be computed at this date
  1445.      */
  1446.     public static Transform getNonInterpolatingTransform(final Frame from, final Frame to,
  1447.                                                          final AbsoluteDate date)
  1448.         throws OrekitException {

  1450.         // common ancestor to both frames in the frames tree
  1451.         Frame currentF = from.getDepth() > to.getDepth() ? from.getAncestor(from.getDepth() - to.getDepth()) : from;
  1452.         Frame currentT = from.getDepth() > to.getDepth() ? to : to.getAncestor(to.getDepth() - from.getDepth());
  1453.         while (currentF != currentT) {
  1454.             currentF = currentF.getParent();
  1455.             currentT = currentT.getParent();
  1456.         }
  1457.         final Frame common = currentF;

  1459.         // transform from common to instance
  1460.         Transform commonToInstance = Transform.IDENTITY;
  1461.         for (Frame frame = from; frame != common; frame = frame.getParent()) {
  1462.             TransformProvider provider = frame.getTransformProvider();
  1463.             while (provider instanceof InterpolatingTransformProvider) {
  1464.                 provider = ((InterpolatingTransformProvider) provider).getRawProvider();
  1465.             }
  1466.             commonToInstance =
  1467.                     new Transform(date, provider.getTransform(date), commonToInstance);
  1468.         }

  1470.         // transform from destination up to common
  1471.         Transform commonToDestination = Transform.IDENTITY;
  1472.         for (Frame frame = to; frame != common; frame = frame.getParent()) {
  1473.             commonToDestination =
  1474.                     new Transform(date, frame.getTransformProvider().getTransform(date), commonToDestination);
  1475.         }

  1477.         // transform from instance to destination via common
  1478.         return new Transform(date, commonToInstance.getInverse(), commonToDestination);

  1480.     }

  1482. }
Created with JaCoCo 0.6.3.201306030806