FramesFactory.java

  1. /* Copyright 2002-2018 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.io.Serializable;
  20. import java.util.ArrayList;
  21. import java.util.HashMap;
  22. import java.util.List;
  23. import java.util.Map;
  24. import java.util.SortedSet;
  25. import java.util.TreeSet;

  27. import org.hipparchus.RealFieldElement;
  28. import org.orekit.bodies.CelestialBodyFactory;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitInternalError;
  31. import org.orekit.time.AbsoluteDate;
  32. import org.orekit.time.ChronologicalComparator;
  33. import org.orekit.time.FieldAbsoluteDate;
  34. import org.orekit.utils.AngularDerivativesFilter;
  35. import org.orekit.utils.CartesianDerivativesFilter;
  36. import org.orekit.utils.Constants;
  37. import org.orekit.utils.IERSConventions;
  38. import org.orekit.utils.OrekitConfiguration;


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

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

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

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

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

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

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

  185.     /** Default regular expression for the EOPC04 files (IAU2000 compatibles). */
  186.     public static final String EOPC04_2000_FILENAME = "^eopc04_\\d\\d_IAU2000\\.(\\d\\d)$";

  188.     /** Default regular expression for the BulletinB files (IAU2000 compatibles). */
  189.     public static final String BULLETINB_2000_FILENAME = "^bulletinb(_IAU2000)?((-\\d\\d\\d\\.txt)|(\\.\\d\\d\\d))$";

  191.     /** Default regular expression for the BulletinA files (IAU1980 and IAU2000 compatibles). */
  192.     public static final String BULLETINA_FILENAME = "^bulletina-[ivxlcdm]+-\\d\\d\\d\\.txt$";

  194.     /** Predefined frames. */
  195.     private static transient Map<Predefined, FactoryManagedFrame> FRAMES =
  196.         new HashMap<Predefined, FactoryManagedFrame>();

  198.     /** Predefined versioned ITRF frames. */
  199.     private static transient Map<ITRFKey, VersionedITRF> VERSIONED_ITRF_FRAMES =
  200.         new HashMap<ITRFKey, VersionedITRF>();

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

  206.     /** Threshold for EOP continuity. */
  207.     private static double EOP_CONTINUITY_THRESHOLD = 5 * Constants.JULIAN_DAY;

  209.     /** Private constructor.
  210.      * <p>This class is a utility class, it should neither have a public
  211.      * nor a default constructor. This private constructor prevents
  212.      * the compiler from generating one automatically.</p>
  213.      */
  214.     private FramesFactory() {
  215.     }

  217.     /** Add the default loaders EOP history (IAU 1980 precession/nutation).
  218.      * <p>
  219.      * The default loaders look for IERS EOP C04 and bulletins B files. They
  220.      * correspond to {@link IERSConventions#IERS_1996 IERS 1996} conventions.
  221.      * </p>
  222.      * @param rapidDataColumnsSupportedNames regular expression for supported
  223.      * rapid data columns EOP files names
  224.      * (may be null if the default IERS file names are used)
  225.      * @param rapidDataXMLSupportedNames regular expression for supported
  226.      * rapid data XML EOP files names
  227.      * (may be null if the default IERS file names are used)
  228.      * @param eopC04SupportedNames regular expression for supported EOP C04 files names
  229.      * (may be null if the default IERS file names are used)
  230.      * @param bulletinBSupportedNames regular expression for supported bulletin B files names
  231.      * (may be null if the default IERS file names are used)
  232.      * @param bulletinASupportedNames regular expression for supported bulletin A files names
  233.      * (may be null if the default IERS file names are used)
  234.      * @see <a href="http://hpiers.obspm.fr/eoppc/eop/eopc04/">IERS EOP C04 files</a>
  235.      * @see #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader)
  236.      * @see #clearEOPHistoryLoaders()
  237.      * @see #addDefaultEOP2000HistoryLoaders(String, String, String, String, String)
  238.      */
  239.     public static void addDefaultEOP1980HistoryLoaders(final String rapidDataColumnsSupportedNames,
  240.                                                        final String rapidDataXMLSupportedNames,
  241.                                                        final String eopC04SupportedNames,
  242.                                                        final String bulletinBSupportedNames,
  243.                                                        final String bulletinASupportedNames) {
  244.         final String rapidColNames =
  245.                 (rapidDataColumnsSupportedNames == null) ?
  246.                 RAPID_DATA_PREDICTION_COLUMNS_1980_FILENAME : rapidDataColumnsSupportedNames;
  247.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  248.                             new RapidDataAndPredictionColumnsLoader(false, rapidColNames));
  249.         final String rapidXmlNames =
  250.                 (rapidDataXMLSupportedNames == null) ?
  251.                 RAPID_DATA_PREDICTION_XML_1980_FILENAME : rapidDataXMLSupportedNames;
  252.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  253.                             new RapidDataAndPredictionXMLLoader(rapidXmlNames));
  254.         final String eopcNames =
  255.                 (eopC04SupportedNames == null) ? EOPC04_1980_FILENAME : eopC04SupportedNames;
  256.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  257.                             new EOPC04FilesLoader(eopcNames));
  258.         final String bulBNames =
  259.                 (bulletinBSupportedNames == null) ? BULLETINB_1980_FILENAME : bulletinBSupportedNames;
  260.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  261.                             new BulletinBFilesLoader(bulBNames));
  262.         final String bulANames =
  263.                     (bulletinASupportedNames == null) ? BULLETINA_FILENAME : bulletinASupportedNames;
  264.         addEOPHistoryLoader(IERSConventions.IERS_1996,
  265.                             new BulletinAFilesLoader(bulANames));
  266.     }

  268.     /** Add the default loaders for EOP history (IAU 2000/2006 precession/nutation).
  269.      * <p>
  270.      * The default loaders look for IERS EOP C04 and bulletins B files. They
  271.      * correspond to both {@link IERSConventions#IERS_2003 IERS 2003} and {@link
  272.      * IERSConventions#IERS_2010 IERS 2010} conventions.
  273.      * </p>
  274.      * @param rapidDataColumnsSupportedNames regular expression for supported
  275.      * rapid data columns EOP files names
  276.      * (may be null if the default IERS file names are used)
  277.      * @param rapidDataXMLSupportedNames regular expression for supported
  278.      * rapid data XML EOP files names
  279.      * (may be null if the default IERS file names are used)
  280.      * @param eopC04SupportedNames regular expression for supported EOP C04 files names
  281.      * (may be null if the default IERS file names are used)
  282.      * @param bulletinBSupportedNames regular expression for supported bulletin B files names
  283.      * (may be null if the default IERS file names are used)
  284.      * @param bulletinASupportedNames regular expression for supported bulletin A files names
  285.      * (may be null if the default IERS file names are used)
  286.      * @see <a href="http://hpiers.obspm.fr/eoppc/eop/eopc04/">IERS EOP C04 files</a>
  287.      * @see #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader)
  288.      * @see #clearEOPHistoryLoaders()
  289.      * @see #addDefaultEOP1980HistoryLoaders(String, String, String, String, String)
  290.      */
  291.     public static void addDefaultEOP2000HistoryLoaders(final String rapidDataColumnsSupportedNames,
  292.                                                        final String rapidDataXMLSupportedNames,
  293.                                                        final String eopC04SupportedNames,
  294.                                                        final String bulletinBSupportedNames,
  295.                                                        final String bulletinASupportedNames) {
  296.         final String rapidColNames =
  297.                 (rapidDataColumnsSupportedNames == null) ?
  298.                 RAPID_DATA_PREDICITON_COLUMNS_2000_FILENAME : rapidDataColumnsSupportedNames;
  299.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  300.                             new RapidDataAndPredictionColumnsLoader(true, rapidColNames));
  301.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  302.                             new RapidDataAndPredictionColumnsLoader(true, rapidColNames));
  303.         final String rapidXmlNames =
  304.             (rapidDataXMLSupportedNames == null) ?
  305.             RAPID_DATA_PREDICITON_XML_2000_FILENAME : rapidDataXMLSupportedNames;
  306.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  307.                             new RapidDataAndPredictionXMLLoader(rapidXmlNames));
  308.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  309.                             new RapidDataAndPredictionXMLLoader(rapidXmlNames));
  310.         final String eopcNames =
  311.             (eopC04SupportedNames == null) ? EOPC04_2000_FILENAME : eopC04SupportedNames;
  312.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  313.                             new EOPC04FilesLoader(eopcNames));
  314.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  315.                             new EOPC04FilesLoader(eopcNames));
  316.         final String bulBNames =
  317.             (bulletinBSupportedNames == null) ? BULLETINB_2000_FILENAME : bulletinBSupportedNames;
  318.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  319.                             new BulletinBFilesLoader(bulBNames));
  320.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  321.                             new BulletinBFilesLoader(bulBNames));
  322.         final String bulANames =
  323.                 (bulletinASupportedNames == null) ? BULLETINA_FILENAME : bulletinASupportedNames;
  324.         addEOPHistoryLoader(IERSConventions.IERS_2003,
  325.                             new BulletinAFilesLoader(bulANames));
  326.         addEOPHistoryLoader(IERSConventions.IERS_2010,
  327.                             new BulletinAFilesLoader(bulANames));
  328.     }

  330.     /** Add a loader for Earth Orientation Parameters history.
  331.      * @param conventions IERS conventions to which EOP history applies
  332.      * @param loader custom loader to add for the EOP history
  333.      * @see #addDefaultEOP1980HistoryLoaders(String, String, String, String, String)
  334.      * @see #clearEOPHistoryLoaders()
  335.      */
  336.     public static void addEOPHistoryLoader(final IERSConventions conventions, final EOPHistoryLoader loader) {
  337.         synchronized (EOP_HISTORY_LOADERS) {
  338.             if (!EOP_HISTORY_LOADERS.containsKey(conventions)) {
  339.                 EOP_HISTORY_LOADERS.put(conventions, new ArrayList<EOPHistoryLoader>());
  340.             }
  341.             EOP_HISTORY_LOADERS.get(conventions).add(loader);
  342.         }
  343.     }

  345.     /** Clear loaders for Earth Orientation Parameters history.
  346.      * @see #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader)
  347.      * @see #addDefaultEOP1980HistoryLoaders(String, String, String, String, String)
  348.      */
  349.     public static void clearEOPHistoryLoaders() {
  350.         synchronized (EOP_HISTORY_LOADERS) {
  351.             EOP_HISTORY_LOADERS.clear();
  352.         }
  353.     }

  355.     /** Set the threshold to check EOP continuity.
  356.      * <p>
  357.      * The default threshold (used if this method is never called)
  358.      * is 5 Julian days. If after loading EOP entries some holes
  359.      * between entries exceed this threshold, an exception will
  360.      * be triggered.
  361.      * </p>
  362.      * <p>
  363.      * One case when calling this method is really useful is for
  364.      * applications that use a single Bulletin A, as these bulletins
  365.      * have a roughly one month wide hole for the first bulletin of
  366.      * each month, which contains older final data in addition to the
  367.      * rapid data and the predicted data.
  368.      * </p>
  369.      * @param threshold threshold to use for checking EOP continuity (in seconds)
  370.      */
  371.     public static void setEOPContinuityThreshold(final double threshold) {
  372.         EOP_CONTINUITY_THRESHOLD = threshold;
  373.     }

  375.     /** Get Earth Orientation Parameters history.
  376.      * <p>
  377.      * If no {@link EOPHistoryLoader} has been added by calling {@link
  378.      * #addEOPHistoryLoader(IERSConventions, EOPHistoryLoader) addEOPHistoryLoader}
  379.      * or if {@link #clearEOPHistoryLoaders() clearEOPHistoryLoaders} has been
  380.      * called afterwards, the {@link #addDefaultEOP1980HistoryLoaders(String, String,
  381.      * String, String, String)} and {@link #addDefaultEOP2000HistoryLoaders(String,
  382.      * String, String, String, String)} methods will be called automatically with
  383.      * supported file names parameters all set to null, in order to get the default
  384.      * loaders configuration.
  385.      * </p>
  386.      * @param conventions conventions for which EOP history is requested
  387.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  388.      * @return Earth Orientation Parameters history
  389.      * @exception OrekitException if the data cannot be loaded
  390.      */
  391.     public static EOPHistory getEOPHistory(final IERSConventions conventions, final boolean simpleEOP)
  392.         throws OrekitException {

  394.         synchronized (EOP_HISTORY_LOADERS) {

  396.             if (EOP_HISTORY_LOADERS.isEmpty()) {
  397.                 // set up using default loaders
  398.                 addDefaultEOP2000HistoryLoaders(null, null, null, null, null);
  399.                 addDefaultEOP1980HistoryLoaders(null, null, null, null, null);
  400.             }

  402.             // TimeStamped based set needed to remove duplicates
  403.             OrekitException pendingException = null;
  404.             final SortedSet<EOPEntry> data = new TreeSet<EOPEntry>(new ChronologicalComparator());

  406.             // try to load canonical data if available
  407.             if (EOP_HISTORY_LOADERS.containsKey(conventions)) {
  408.                 for (final EOPHistoryLoader loader : EOP_HISTORY_LOADERS.get(conventions)) {
  409.                     try {
  410.                         loader.fillHistory(conventions.getNutationCorrectionConverter(), data);
  411.                     } catch (OrekitException oe) {
  412.                         pendingException = oe;
  413.                     }
  414.                 }
  415.             }

  417.             if (data.isEmpty() && pendingException != null) {
  418.                 throw pendingException;
  419.             }

  421.             final EOPHistory history = new EOPHistory(conventions, data, simpleEOP);
  422.             history.checkEOPContinuity(EOP_CONTINUITY_THRESHOLD);
  423.             return history;

  425.         }

  427.     }

  429.     /** Get one of the predefined frames.
  430.      * @param factoryKey key of the frame within the factory
  431.      * @return the predefined frame
  432.      * @exception OrekitException if frame cannot be built due to missing data
  433.      */
  434.     public static Frame getFrame(final Predefined factoryKey)
  435.         throws OrekitException {
  436.         switch (factoryKey) {
  437.             case GCRF :
  438.                 return getGCRF();
  439.             case ICRF :
  440.                 return getICRF();
  441.             case ECLIPTIC_CONVENTIONS_1996 :
  442.                 return getEcliptic(IERSConventions.IERS_1996);
  443.             case ECLIPTIC_CONVENTIONS_2003 :
  444.                 return getEcliptic(IERSConventions.IERS_2003);
  445.             case ECLIPTIC_CONVENTIONS_2010 :
  446.                 return getEcliptic(IERSConventions.IERS_2010);
  447.             case EME2000 :
  448.                 return getEME2000();
  449.             case ITRF_CIO_CONV_2010_SIMPLE_EOP :
  450.                 return getITRF(IERSConventions.IERS_2010, true);
  451.             case ITRF_CIO_CONV_2010_ACCURATE_EOP :
  452.                 return getITRF(IERSConventions.IERS_2010, false);
  453.             case ITRF_CIO_CONV_2003_SIMPLE_EOP :
  454.                 return getITRF(IERSConventions.IERS_2003, true);
  455.             case ITRF_CIO_CONV_2003_ACCURATE_EOP :
  456.                 return getITRF(IERSConventions.IERS_2003, false);
  457.             case ITRF_CIO_CONV_1996_SIMPLE_EOP :
  458.                 return getITRF(IERSConventions.IERS_1996, true);
  459.             case ITRF_CIO_CONV_1996_ACCURATE_EOP :
  460.                 return getITRF(IERSConventions.IERS_1996, false);
  461.             case ITRF_EQUINOX_CONV_2010_SIMPLE_EOP :
  462.                 return getITRFEquinox(IERSConventions.IERS_2010, true);
  463.             case ITRF_EQUINOX_CONV_2010_ACCURATE_EOP :
  464.                 return getITRFEquinox(IERSConventions.IERS_2010, false);
  465.             case ITRF_EQUINOX_CONV_2003_SIMPLE_EOP :
  466.                 return getITRFEquinox(IERSConventions.IERS_2003, true);
  467.             case ITRF_EQUINOX_CONV_2003_ACCURATE_EOP :
  468.                 return getITRFEquinox(IERSConventions.IERS_2003, false);
  469.             case ITRF_EQUINOX_CONV_1996_SIMPLE_EOP :
  470.                 return getITRFEquinox(IERSConventions.IERS_1996, true);
  471.             case ITRF_EQUINOX_CONV_1996_ACCURATE_EOP :
  472.                 return getITRFEquinox(IERSConventions.IERS_1996, false);
  473.             case TIRF_CONVENTIONS_2010_SIMPLE_EOP :
  474.                 return getTIRF(IERSConventions.IERS_2010, true);
  475.             case TIRF_CONVENTIONS_2010_ACCURATE_EOP :
  476.                 return getTIRF(IERSConventions.IERS_2010, false);
  477.             case TIRF_CONVENTIONS_2003_SIMPLE_EOP :
  478.                 return getTIRF(IERSConventions.IERS_2003, true);
  479.             case TIRF_CONVENTIONS_2003_ACCURATE_EOP :
  480.                 return getTIRF(IERSConventions.IERS_2003, false);
  481.             case TIRF_CONVENTIONS_1996_SIMPLE_EOP :
  482.                 return getTIRF(IERSConventions.IERS_1996, true);
  483.             case TIRF_CONVENTIONS_1996_ACCURATE_EOP :
  484.                 return getTIRF(IERSConventions.IERS_1996, false);
  485.             case CIRF_CONVENTIONS_2010_ACCURATE_EOP :
  486.                 return getCIRF(IERSConventions.IERS_2010, false);
  487.             case CIRF_CONVENTIONS_2010_SIMPLE_EOP :
  488.                 return getCIRF(IERSConventions.IERS_2010, true);
  489.             case CIRF_CONVENTIONS_2003_ACCURATE_EOP :
  490.                 return getCIRF(IERSConventions.IERS_2003, false);
  491.             case CIRF_CONVENTIONS_2003_SIMPLE_EOP :
  492.                 return getCIRF(IERSConventions.IERS_2003, true);
  493.             case CIRF_CONVENTIONS_1996_ACCURATE_EOP :
  494.                 return getCIRF(IERSConventions.IERS_1996, false);
  495.             case CIRF_CONVENTIONS_1996_SIMPLE_EOP :
  496.                 return getCIRF(IERSConventions.IERS_1996, true);
  497.             case VEIS_1950 :
  498.                 return getVeis1950();
  499.             case GTOD_WITHOUT_EOP_CORRECTIONS :
  500.                 return getGTOD(IERSConventions.IERS_1996, false, true);
  501.             case GTOD_CONVENTIONS_2010_ACCURATE_EOP :
  502.                 return getGTOD(IERSConventions.IERS_2010, true, false);
  503.             case GTOD_CONVENTIONS_2010_SIMPLE_EOP :
  504.                 return getGTOD(IERSConventions.IERS_2010, true, true);
  505.             case GTOD_CONVENTIONS_2003_ACCURATE_EOP :
  506.                 return getGTOD(IERSConventions.IERS_2003, true, false);
  507.             case GTOD_CONVENTIONS_2003_SIMPLE_EOP :
  508.                 return getGTOD(IERSConventions.IERS_2003, true, true);
  509.             case GTOD_CONVENTIONS_1996_ACCURATE_EOP :
  510.                 return getGTOD(IERSConventions.IERS_1996, true, false);
  511.             case GTOD_CONVENTIONS_1996_SIMPLE_EOP :
  512.                 return getGTOD(IERSConventions.IERS_1996, true, true);
  513.             case TOD_WITHOUT_EOP_CORRECTIONS :
  514.                 return getTOD(IERSConventions.IERS_1996, false, true);
  515.             case TOD_CONVENTIONS_2010_ACCURATE_EOP :
  516.                 return getTOD(IERSConventions.IERS_2010, true, false);
  517.             case TOD_CONVENTIONS_2010_SIMPLE_EOP :
  518.                 return getTOD(IERSConventions.IERS_2010, true, true);
  519.             case TOD_CONVENTIONS_2003_ACCURATE_EOP :
  520.                 return getTOD(IERSConventions.IERS_2003, true, false);
  521.             case TOD_CONVENTIONS_2003_SIMPLE_EOP :
  522.                 return getTOD(IERSConventions.IERS_2003, true, true);
  523.             case TOD_CONVENTIONS_1996_ACCURATE_EOP :
  524.                 return getTOD(IERSConventions.IERS_1996, true, false);
  525.             case TOD_CONVENTIONS_1996_SIMPLE_EOP :
  526.                 return getTOD(IERSConventions.IERS_1996, true, true);
  527.             case MOD_WITHOUT_EOP_CORRECTIONS :
  528.                 return getMOD(IERSConventions.IERS_1996, false);
  529.             case MOD_CONVENTIONS_2010 :
  530.                 return getMOD(IERSConventions.IERS_2010, true);
  531.             case MOD_CONVENTIONS_2003 :
  532.                 return getMOD(IERSConventions.IERS_2003, true);
  533.             case MOD_CONVENTIONS_1996 :
  534.                 return getMOD(IERSConventions.IERS_1996, true);
  535.             case TEME :
  536.                 return getTEME();
  537.             default :
  538.                 // this should never happen
  539.                 throw new OrekitInternalError(null);
  540.         }
  541.     }

  543.     /** Get the unique GCRF frame.
  544.      * <p>The GCRF frame is the root frame in the frame tree.</p>
  545.      * @return the unique instance of the GCRF frame
  546.      */
  547.     public static Frame getGCRF() {
  548.         return Frame.getRoot();
  549.     }

  551.     /** Get the unique ICRF frame.
  552.      * <p>The ICRF frame is centered at solar system barycenter and aligned
  553.      * with GCRF.</p>
  554.      * @return the unique instance of the ICRF frame
  555.      * @exception OrekitException if solar system ephemerides cannot be loaded
  556.      */
  557.     public static Frame getICRF() throws OrekitException {
  558.         return CelestialBodyFactory.getSolarSystemBarycenter().getInertiallyOrientedFrame();
  559.     }

  561.     /** Get the ecliptic frame.
  562.      * The IAU defines the ecliptic as "the plane perpendicular to the mean heliocentric
  563.      * orbital angular momentum vector of the Earth-Moon barycentre in the BCRS (IAU 2006
  564.      * Resolution B1)." The +z axis is aligned with the angular momentum vector, and the +x
  565.      * axis is aligned with +x axis of {@link FramesFactory#getMOD(IERSConventions) MOD}.
  566.      *
  567.      * <p> This implementation agrees with the JPL 406 ephemerides to within 0.5 arc seconds.
  568.      * @param conventions IERS conventions to apply
  569.      * @return the selected reference frame singleton.
  570.      * @exception OrekitException if data embedded in the library cannot be read
  571.      */
  572.     public static Frame getEcliptic(final IERSConventions conventions) throws OrekitException {
  573.         synchronized (FramesFactory.class) {

  575.             final Predefined factoryKey;
  576.             switch (conventions) {
  577.                 case IERS_1996 :
  578.                     factoryKey = Predefined.ECLIPTIC_CONVENTIONS_1996;
  579.                     break;
  580.                 case IERS_2003 :
  581.                     factoryKey = Predefined.ECLIPTIC_CONVENTIONS_2003;
  582.                     break;
  583.                 case IERS_2010 :
  584.                     factoryKey = Predefined.ECLIPTIC_CONVENTIONS_2010;
  585.                     break;
  586.                 default :
  587.                     // this should never happen
  588.                     throw new OrekitInternalError(null);
  589.             }
  590.             final Frame parent = getMOD(conventions);

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

  595.             if (frame == null) {
  596.                 // it's the first time we need this frame, build it and store it
  597.                 frame = new FactoryManagedFrame(parent, new EclipticProvider(conventions),
  598.                                                 true, factoryKey);
  599.                 FRAMES.put(factoryKey, frame);
  600.             }

  602.             return frame;

  604.         }
  605.     }

  607.     /** Get the unique EME2000 frame.
  608.      * <p>The EME2000 frame is also called the J2000 frame.
  609.      * The former denomination is preferred in Orekit.</p>
  610.      * @return the unique instance of the EME2000 frame
  611.      */
  612.     public static FactoryManagedFrame getEME2000() {
  613.         synchronized (FramesFactory.class) {

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

  618.             if (frame == null) {
  619.                 // it's the first time we need this frame, build it and store it
  620.                 frame = new FactoryManagedFrame(getGCRF(), new EME2000Provider(), true, Predefined.EME2000);
  621.                 FRAMES.put(Predefined.EME2000, frame);
  622.             }

  624.             return frame;

  626.         }
  627.     }

  629.     /** Get an unspecified International Terrestrial Reference Frame.
  630.      * <p>
  631.      * The frame returned uses the {@link EOPEntry Earth Orientation Parameters}
  632.      * blindly. So if for example one loads only EOP 14 C04 files to retrieve
  633.      * the parameters, the frame will be an {@link ITRFVersion#ITRF_2014}. However,
  634.      * if parameters are loaded from different files types, or even for file
  635.      * types that changed their reference (like Bulletin A switching from
  636.      * {@link ITRFVersion#ITRF_2008} to {@link ITRFVersion#ITRF_2014} starting
  637.      * with Vol. XXXI No. 013 published on 2018-03-29), then the ITRF returned
  638.      * by this method will jump from one version to another version.
  639.      * </p>
  640.      * <p>
  641.      * IF a specific version of ITRF is needed, then {@link #getITRF(ITRFVersion,
  642.      * IERSConventions, boolean)} should be used instead.
  643.      * </p>
  644.      * @param conventions IERS conventions to apply
  645.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  646.      * @return the selected reference frame singleton.
  647.      * @exception OrekitException if data embedded in the library cannot be read
  648.      * @see #getITRF(ITRFVersion, IERSConventions, boolean)
  649.      * @since 6.1
  650.      */
  651.     public static FactoryManagedFrame getITRF(final IERSConventions conventions,
  652.                                               final boolean simpleEOP)
  653.         throws OrekitException {
  654.         synchronized (FramesFactory.class) {

  656.             // try to find an already built frame
  657.             final Predefined factoryKey;
  658.             switch (conventions) {
  659.                 case IERS_1996 :
  660.                     factoryKey = simpleEOP ?
  661.                                  Predefined.ITRF_CIO_CONV_1996_SIMPLE_EOP :
  662.                                  Predefined.ITRF_CIO_CONV_1996_ACCURATE_EOP;
  663.                     break;
  664.                 case IERS_2003 :
  665.                     factoryKey = simpleEOP ?
  666.                                  Predefined.ITRF_CIO_CONV_2003_SIMPLE_EOP :
  667.                                  Predefined.ITRF_CIO_CONV_2003_ACCURATE_EOP;
  668.                     break;
  669.                 case IERS_2010 :
  670.                     factoryKey = simpleEOP ?
  671.                                  Predefined.ITRF_CIO_CONV_2010_SIMPLE_EOP :
  672.                                  Predefined.ITRF_CIO_CONV_2010_ACCURATE_EOP;
  673.                     break;
  674.                 default :
  675.                     // this should never happen
  676.                     throw new OrekitInternalError(null);
  677.             }
  678.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  680.             if (frame == null) {
  681.                 // it's the first time we need this frame, build it and store it
  682.                 final Frame tirfFrame = getTIRF(conventions, simpleEOP);
  683.                 final TIRFProvider tirfProvider = (TIRFProvider) tirfFrame.getTransformProvider();
  684.                 frame = new FactoryManagedFrame(tirfFrame,
  685.                                                 new ITRFProvider(tirfProvider.getEOPHistory()),
  686.                                                 false, factoryKey);
  687.                 FRAMES.put(factoryKey, frame);
  688.             }

  690.             return frame;

  692.         }
  693.     }

  695.     /** Get the TIRF reference frame, ignoring tidal effects.
  696.      * @param conventions IERS conventions to apply
  697.      * @return the selected reference frame singleton.
  698.      * @exception OrekitException if the precession-nutation model data embedded in the
  699.      * library cannot be read.
  700.      */
  701.     public static FactoryManagedFrame getTIRF(final IERSConventions conventions) throws OrekitException {
  702.         return getTIRF(conventions, true);
  703.     }

  705.     /** Get an specific International Terrestrial Reference Frame.
  706.      * <p>
  707.      * Note that if a specific version of ITRF is required, then {@code simpleEOP}
  708.      * should most probably be set to {@code false}, as ignoring tidal effects
  709.      * has an effect of the same order of magnitude as the differences between
  710.      * the various {@link ITRFVersion ITRF versions}.
  711.      * </p>
  712.      * @param version ITRF version
  713.      * @param conventions IERS conventions to apply
  714.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  715.      * @return the selected reference frame singleton.
  716.      * @exception OrekitException if data embedded in the library cannot be read
  717.      * @since 9.2
  718.      */
  719.     public static VersionedITRF getITRF(final ITRFVersion version,
  720.                                         final IERSConventions conventions,
  721.                                         final boolean simpleEOP)
  722.         throws OrekitException {
  723.         synchronized (FramesFactory.class) {
  724.             // try to find an already built frame
  725.             final ITRFKey key = new ITRFKey(version, conventions, simpleEOP);
  726.             VersionedITRF frame = VERSIONED_ITRF_FRAMES.get(key);

  728.             if (frame == null) {
  729.                 // it's the first time we need this frame, build it and store it
  730.                 final FactoryManagedFrame rawITRF = getITRF(conventions, simpleEOP);
  731.                 frame = new VersionedITRF(rawITRF.getParent(), version,
  732.                                           (ITRFProvider) rawITRF.getTransformProvider(),
  733.                                           version.toString().replace('_', '-') +
  734.                                           "/" +
  735.                                           rawITRF.getName());
  736.                 VERSIONED_ITRF_FRAMES.put(key, frame);
  737.             }

  739.             return frame;

  741.         }
  742.     }

  744.     /** Get the TIRF reference frame.
  745.      * @param conventions IERS conventions to apply
  746.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  747.      * @return the selected reference frame singleton.
  748.      * @exception OrekitException if the precession-nutation model data embedded in the
  749.      * library cannot be read.
  750.      * @since 6.1
  751.      */
  752.     public static FactoryManagedFrame getTIRF(final IERSConventions conventions,
  753.                                               final boolean simpleEOP)
  754.         throws OrekitException {
  755.         synchronized (FramesFactory.class) {

  757.             // try to find an already built frame
  758.             final Predefined factoryKey;
  759.             switch (conventions) {
  760.                 case IERS_1996 :
  761.                     factoryKey = simpleEOP ?
  762.                                  Predefined.TIRF_CONVENTIONS_1996_SIMPLE_EOP :
  763.                                  Predefined.TIRF_CONVENTIONS_1996_ACCURATE_EOP;
  764.                     break;
  765.                 case IERS_2003 :
  766.                     factoryKey = simpleEOP ?
  767.                                  Predefined.TIRF_CONVENTIONS_2003_SIMPLE_EOP :
  768.                                  Predefined.TIRF_CONVENTIONS_2003_ACCURATE_EOP;
  769.                     break;
  770.                 case IERS_2010 :
  771.                     factoryKey = simpleEOP ?
  772.                                  Predefined.TIRF_CONVENTIONS_2010_SIMPLE_EOP :
  773.                                  Predefined.TIRF_CONVENTIONS_2010_ACCURATE_EOP;
  774.                     break;
  775.                 default :
  776.                     // this should never happen
  777.                     throw new OrekitInternalError(null);
  778.             }
  779.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  781.             if (frame == null) {
  782.                 // it's the first time we need this frame, build it and store it
  783.                 final Frame cirf = getCIRF(conventions, simpleEOP);
  784.                 final ShiftingTransformProvider cirfInterpolating =
  785.                         (ShiftingTransformProvider) cirf.getTransformProvider();
  786.                 final CIRFProvider cirfRaw = (CIRFProvider) cirfInterpolating.getRawProvider();
  787.                 final EOPHistory eopHistory = cirfRaw.getEOPHistory();
  788.                 frame = new FactoryManagedFrame(cirf, new TIRFProvider(eopHistory), false, factoryKey);
  789.                 FRAMES.put(factoryKey, frame);
  790.             }

  792.             return frame;

  794.         }
  795.     }

  797.     /** Get the CIRF2000 reference frame.
  798.      * @param conventions IERS conventions to apply
  799.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  800.      * @return the selected reference frame singleton.
  801.      * @exception OrekitException if the precession-nutation model data embedded in the
  802.      * library cannot be read.
  803.      */
  804.     public static FactoryManagedFrame getCIRF(final IERSConventions conventions,
  805.                                               final boolean simpleEOP)
  806.         throws OrekitException {
  807.         synchronized (FramesFactory.class) {

  809.             // try to find an already built frame
  810.             final Predefined factoryKey;
  811.             switch (conventions) {
  812.                 case IERS_1996 :
  813.                     factoryKey = simpleEOP ?
  814.                                  Predefined.CIRF_CONVENTIONS_1996_SIMPLE_EOP :
  815.                                  Predefined.CIRF_CONVENTIONS_1996_ACCURATE_EOP;
  816.                     break;
  817.                 case IERS_2003 :
  818.                     factoryKey = simpleEOP ?
  819.                                  Predefined.CIRF_CONVENTIONS_2003_SIMPLE_EOP :
  820.                                  Predefined.CIRF_CONVENTIONS_2003_ACCURATE_EOP;
  821.                     break;
  822.                 case IERS_2010 :
  823.                     factoryKey = simpleEOP ?
  824.                                  Predefined.CIRF_CONVENTIONS_2010_SIMPLE_EOP :
  825.                                  Predefined.CIRF_CONVENTIONS_2010_ACCURATE_EOP;
  826.                     break;
  827.                 default :
  828.                     // this should never happen
  829.                     throw new OrekitInternalError(null);
  830.             }
  831.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  833.             if (frame == null) {
  834.                 // it's the first time we need this frame, build it and store it
  835.                 final EOPHistory eopHistory = FramesFactory.getEOPHistory(conventions, simpleEOP);
  836.                 final TransformProvider shifting =
  837.                         new ShiftingTransformProvider(new CIRFProvider(eopHistory),
  838.                                                       CartesianDerivativesFilter.USE_PVA,
  839.                                                       AngularDerivativesFilter.USE_R,
  840.                                                       6, Constants.JULIAN_DAY / 24,
  841.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  842.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  843.                 frame = new FactoryManagedFrame(getGCRF(), shifting, true, factoryKey);
  844.                 FRAMES.put(factoryKey, frame);
  845.             }

  847.             return frame;

  849.         }
  850.     }

  852.     /** Get the VEIS 1950 reference frame.
  853.      * <p>Its parent frame is the GTOD frame with IERS 1996 conventions without EOP corrections.<p>
  854.      * @return the selected reference frame singleton.
  855.      * @exception OrekitException if data embedded in the library cannot be read
  856.      */
  857.     public static FactoryManagedFrame getVeis1950() throws OrekitException {
  858.         synchronized (FramesFactory.class) {

  860.             // try to find an already built frame
  861.             final Predefined factoryKey = Predefined.VEIS_1950;
  862.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  864.             if (frame == null) {
  865.                 // it's the first time we need this frame, build it and store it
  866.                 frame = new FactoryManagedFrame(FramesFactory.getGTOD(IERSConventions.IERS_1996, false, true),
  867.                                                 new VEISProvider(), true, factoryKey);
  868.                 FRAMES.put(factoryKey, frame);
  869.             }

  871.             return frame;

  873.         }
  874.     }

  876.     /** Get the equinox-based ITRF reference frame.
  877.      * @param conventions IERS conventions to apply
  878.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  879.      * @return the selected reference frame singleton.
  880.      * @exception OrekitException if data embedded in the library cannot be read
  881.      * @since 6.1
  882.      */
  883.     public static FactoryManagedFrame getITRFEquinox(final IERSConventions conventions,
  884.                                                      final boolean simpleEOP)
  885.         throws OrekitException {
  886.         synchronized (FramesFactory.class) {

  888.             // try to find an already built frame
  889.             final Predefined factoryKey;
  890.             switch (conventions) {
  891.                 case IERS_1996 :
  892.                     factoryKey = simpleEOP ?
  893.                                  Predefined.ITRF_EQUINOX_CONV_1996_SIMPLE_EOP :
  894.                                  Predefined.ITRF_EQUINOX_CONV_1996_ACCURATE_EOP;
  895.                     break;
  896.                 case IERS_2003 :
  897.                     factoryKey = simpleEOP ?
  898.                                  Predefined.ITRF_EQUINOX_CONV_2003_SIMPLE_EOP :
  899.                                  Predefined.ITRF_EQUINOX_CONV_2003_ACCURATE_EOP;
  900.                     break;
  901.                 case IERS_2010 :
  902.                     factoryKey = simpleEOP ?
  903.                                  Predefined.ITRF_EQUINOX_CONV_2010_SIMPLE_EOP :
  904.                                  Predefined.ITRF_EQUINOX_CONV_2010_ACCURATE_EOP;
  905.                     break;
  906.                 default :
  907.                     // this should never happen
  908.                     throw new OrekitInternalError(null);
  909.             }
  910.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  912.             if (frame == null) {
  913.                 // it's the first time we need this frame, build it and store it
  914.                 final Frame gtod = getGTOD(conventions, true, simpleEOP);
  915.                 final ShiftingTransformProvider gtodShifting =
  916.                         (ShiftingTransformProvider) gtod.getTransformProvider();
  917.                 final GTODProvider gtodRaw    = (GTODProvider) gtodShifting.getRawProvider();
  918.                 final EOPHistory   eopHistory = gtodRaw.getEOPHistory();
  919.                 frame = new FactoryManagedFrame(gtod, new ITRFProvider(eopHistory), false, factoryKey);
  920.                 FRAMES.put(factoryKey, frame);
  921.             }

  923.             return frame;

  925.         }
  926.     }

  928.     /** Get the GTOD reference frame.
  929.      * <p>
  930.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  931.      * consistency with legacy software that don't handle EOP correction parameters.
  932.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  933.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  934.      * For this reason, setting this parameter to false is restricted to {@link
  935.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  936.      * IERSConventions IERS conventions} cannot be freely chosen here.
  937.      * </p>
  938.      * @param applyEOPCorr if true, EOP corrections are applied (here, dut1 and lod)
  939.      * @return the selected reference frame singleton.
  940.      * @exception OrekitException if data embedded in the library cannot be read
  941.      */
  942.     public static FactoryManagedFrame getGTOD(final boolean applyEOPCorr) throws OrekitException {
  943.         return getGTOD(IERSConventions.IERS_1996, applyEOPCorr, true);
  944.     }

  946.     /** Get the GTOD reference frame.
  947.      * @param conventions IERS conventions to apply
  948.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  949.      * @return the selected reference frame singleton.
  950.      * @exception OrekitException if data embedded in the library cannot be read
  951.      */
  952.     public static FactoryManagedFrame getGTOD(final IERSConventions conventions,
  953.                                               final boolean simpleEOP)
  954.         throws OrekitException {
  955.         return getGTOD(conventions, true, simpleEOP);
  956.     }

  958.     /** Get the GTOD reference frame.
  959.      * <p>
  960.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  961.      * consistency with legacy software that don't handle EOP correction parameters.
  962.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  963.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  964.      * For this reason, setting this parameter to false is restricted to {@link
  965.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence this method is private.
  966.      * </p>
  967.      * @param conventions IERS conventions to apply
  968.      * @param applyEOPCorr if true, EOP corrections are applied (here, dut1 and lod)
  969.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  970.      * @return the selected reference frame singleton.
  971.      * @exception OrekitException if data embedded in the library cannot be read
  972.      */
  973.     private static FactoryManagedFrame getGTOD(final IERSConventions conventions,
  974.                                                final boolean applyEOPCorr,
  975.                                                final boolean simpleEOP)
  976.         throws OrekitException {

  978.         synchronized (FramesFactory.class) {

  980.             // try to find an already built frame
  981.             final Predefined factoryKey;
  982.             switch (conventions) {
  983.                 case IERS_1996 :
  984.                     factoryKey = applyEOPCorr ?
  985.                                  (simpleEOP ? Predefined.GTOD_CONVENTIONS_1996_SIMPLE_EOP : Predefined.GTOD_CONVENTIONS_1996_ACCURATE_EOP) :
  986.                                  Predefined.GTOD_WITHOUT_EOP_CORRECTIONS;
  987.                     break;
  988.                 case IERS_2003 :
  989.                     factoryKey = simpleEOP ?
  990.                                  Predefined.GTOD_CONVENTIONS_2003_SIMPLE_EOP :
  991.                                  Predefined.GTOD_CONVENTIONS_2003_ACCURATE_EOP;
  992.                     break;
  993.                 case IERS_2010 :
  994.                     factoryKey = simpleEOP ? Predefined.GTOD_CONVENTIONS_2010_SIMPLE_EOP :
  995.                                              Predefined.GTOD_CONVENTIONS_2010_ACCURATE_EOP;
  996.                     break;
  997.                 default :
  998.                     // this should never happen
  999.                     throw new OrekitInternalError(null);
  1000.             }
  1001.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1003.             if (frame == null) {
  1004.                 // it's the first time we need this frame, build it and store it
  1005.                 final Frame tod = getTOD(conventions, applyEOPCorr, simpleEOP);
  1006.                 final ShiftingTransformProvider todInterpolating =
  1007.                         (ShiftingTransformProvider) tod.getTransformProvider();
  1008.                 final TODProvider       todRaw     = (TODProvider) todInterpolating.getRawProvider();
  1009.                 final EOPHistory        eopHistory = todRaw.getEOPHistory();
  1010.                 final GTODProvider      gtodRaw    = new GTODProvider(conventions, eopHistory);
  1011.                 final TransformProvider gtodShifting =
  1012.                         new ShiftingTransformProvider(gtodRaw,
  1013.                                                       CartesianDerivativesFilter.USE_PVA,
  1014.                                                       AngularDerivativesFilter.USE_R,
  1015.                                                       todInterpolating.getGridPoints(), todInterpolating.getStep(),
  1016.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  1017.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  1018.                 frame = new FactoryManagedFrame(tod, gtodShifting, false, factoryKey);
  1019.                 FRAMES.put(factoryKey, frame);
  1020.             }

  1022.             return frame;

  1024.         }
  1025.     }

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

  1046.     /** Get the TOD reference frame.
  1047.      * @param conventions IERS conventions to apply
  1048.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1049.      * @return the selected reference frame singleton.
  1050.      * @exception OrekitException if data embedded in the library cannot be read
  1051.      */
  1052.     public static FactoryManagedFrame getTOD(final IERSConventions conventions,
  1053.                                              final boolean simpleEOP)
  1054.         throws OrekitException {
  1055.         return getTOD(conventions, true, simpleEOP);
  1056.     }

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

  1078.         synchronized (FramesFactory.class) {

  1080.             // try to find an already built frame
  1081.             final Predefined factoryKey;
  1082.             switch (conventions) {
  1083.                 case IERS_1996 :
  1084.                     factoryKey = applyEOPCorr ?
  1085.                                  (simpleEOP ? Predefined.TOD_CONVENTIONS_1996_SIMPLE_EOP : Predefined.TOD_CONVENTIONS_1996_ACCURATE_EOP) :
  1086.                                  Predefined.TOD_WITHOUT_EOP_CORRECTIONS;
  1087.                     break;
  1088.                 case IERS_2003 :
  1089.                     factoryKey = simpleEOP ?
  1090.                                  Predefined.TOD_CONVENTIONS_2003_SIMPLE_EOP :
  1091.                                      Predefined.TOD_CONVENTIONS_2003_ACCURATE_EOP;
  1092.                     break;
  1093.                 case IERS_2010 :
  1094.                     factoryKey = simpleEOP ?
  1095.                                  Predefined.TOD_CONVENTIONS_2010_SIMPLE_EOP :
  1096.                                  Predefined.TOD_CONVENTIONS_2010_ACCURATE_EOP;
  1097.                     break;
  1098.                 default :
  1099.                     // this should never happen
  1100.                     throw new OrekitInternalError(null);
  1101.             }
  1102.             final int interpolationPoints;
  1103.             final int pointsPerDay;
  1104.             if (applyEOPCorr) {
  1105.                 interpolationPoints = 6;
  1106.                 pointsPerDay        = 24;
  1107.             } else {
  1108.                 interpolationPoints = 6;
  1109.                 pointsPerDay        = 8;
  1110.             }
  1111.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1113.             if (frame == null) {
  1114.                 // it's the first time we need this frame, build it and store it
  1115.                 final EOPHistory eopHistory = applyEOPCorr ? getEOPHistory(conventions, simpleEOP) : null;
  1116.                 final TransformProvider shifting =
  1117.                         new ShiftingTransformProvider(new TODProvider(conventions, eopHistory),
  1118.                                                       CartesianDerivativesFilter.USE_PVA,
  1119.                                                       AngularDerivativesFilter.USE_R,
  1120.                                                       interpolationPoints, Constants.JULIAN_DAY / pointsPerDay,
  1121.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  1122.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  1123.                 frame = new FactoryManagedFrame(getMOD(conventions, applyEOPCorr), shifting, true, factoryKey);
  1124.                 FRAMES.put(factoryKey, frame);
  1125.             }

  1127.             return frame;

  1129.         }
  1130.     }

  1132.     /** Get the MOD reference frame.
  1133.      * <p>
  1134.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1135.      * consistency with legacy software that don't handle EOP correction parameters.
  1136.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1137.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1138.      * For this reason, setting this parameter to false is restricted to {@link
  1139.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  1140.      * IERSConventions IERS conventions} cannot be freely chosen here.
  1141.      * </p>
  1142.      * @param applyEOPCorr if true, EOP corrections are applied (EME2000/GCRF bias compensation)
  1143.      * @return the selected reference frame singleton.
  1144.      * @exception OrekitException if data embedded in the library cannot be read
  1145.      */
  1146.     public static FactoryManagedFrame getMOD(final boolean applyEOPCorr)
  1147.         throws OrekitException {
  1148.         return getMOD(IERSConventions.IERS_1996, applyEOPCorr);
  1149.     }

  1151.     /** Get the MOD reference frame.
  1152.      * @param conventions IERS conventions to apply
  1153.      * @return the selected reference frame singleton.
  1154.      * @exception OrekitException if data embedded in the library cannot be read
  1155.      */
  1156.     public static FactoryManagedFrame getMOD(final IERSConventions conventions)
  1157.         throws OrekitException {
  1158.         return getMOD(conventions, true);
  1159.     }

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

  1178.         synchronized (FramesFactory.class) {

  1180.             final Predefined factoryKey;
  1181.             final Frame parent;
  1182.             switch (conventions) {
  1183.                 case IERS_1996 :
  1184.                     factoryKey = applyEOPCorr ? Predefined.MOD_CONVENTIONS_1996 : Predefined.MOD_WITHOUT_EOP_CORRECTIONS;
  1185.                     parent     = applyEOPCorr ? FramesFactory.getGCRF() : FramesFactory.getEME2000();
  1186.                     break;
  1187.                 case IERS_2003 :
  1188.                     factoryKey = Predefined.MOD_CONVENTIONS_2003;
  1189.                     // in IERS conventions 2003, the precession angles zetaA, thetaA and zA
  1190.                     // from equation 33 are computed from EME2000, not from GCRF
  1191.                     parent     = FramesFactory.getEME2000();
  1192.                     break;
  1193.                 case IERS_2010 :
  1194.                     factoryKey = Predefined.MOD_CONVENTIONS_2010;
  1195.                     // precession angles epsilon0, psiA, omegaA and chiA
  1196.                     // from equations 5.39 and 5.40 are computed from EME2000
  1197.                     parent     = FramesFactory.getEME2000();
  1198.                     break;
  1199.                 default :
  1200.                     // this should never happen
  1201.                     throw new OrekitInternalError(null);
  1202.             }

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

  1207.             if (frame == null) {
  1208.                 // it's the first time we need this frame, build it and store it
  1209.                 frame = new FactoryManagedFrame(parent, new MODProvider(conventions), true, factoryKey);
  1210.                 FRAMES.put(factoryKey, frame);
  1211.             }

  1213.             return frame;

  1215.         }
  1216.     }

  1218.     /** Get the TEME reference frame.
  1219.      * <p>
  1220.      * The TEME frame is used for the SGP4 model in TLE propagation. This frame has <em>no</em>
  1221.      * official definition and there are some ambiguities about whether it should be used
  1222.      * as "of date" or "of epoch". This frame should therefore be used <em>only</em> for
  1223.      * TLE propagation and not for anything else, as recommended by the CCSDS Orbit Data Message
  1224.      * blue book.
  1225.      * </p>
  1226.      * @return the selected reference frame singleton.
  1227.      * @exception OrekitException if data embedded in the library cannot be read
  1228.      */
  1229.     public static FactoryManagedFrame getTEME() throws OrekitException {
  1230.         synchronized (FramesFactory.class) {

  1232.             // try to find an already built frame
  1233.             final Predefined factoryKey = Predefined.TEME;
  1234.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1236.             if (frame == null) {
  1237.                 // it's the first time we need this frame, build it and store it
  1238.                 final Frame tod = getTOD(IERSConventions.IERS_1996, false, true);
  1239.                 final ShiftingTransformProvider todShifting =
  1240.                         (ShiftingTransformProvider) tod.getTransformProvider();
  1241.                 final TEMEProvider temeRaw = new TEMEProvider(IERSConventions.IERS_1996, null);
  1242.                 final TransformProvider temeShifting =
  1243.                         new ShiftingTransformProvider(temeRaw,
  1244.                                                       CartesianDerivativesFilter.USE_PVA,
  1245.                                                       AngularDerivativesFilter.USE_R,
  1246.                                                       todShifting.getGridPoints(), todShifting.getStep(),
  1247.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  1248.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);

  1250.                 frame = new FactoryManagedFrame(tod, temeShifting, true, factoryKey);
  1251.                 FRAMES.put(factoryKey, frame);
  1252.             }

  1254.             return frame;

  1256.         }
  1257.     }

  1259.     /** Get the transform between two frames, suppressing all interpolation.
  1260.      * <p>
  1261.      * This method is similar to {@link Frame#getTransformTo(Frame, AbsoluteDate)}
  1262.      * except it removes the performance enhancing interpolation features that are
  1263.      * added by the {@link FramesFactory factory} to some frames, in order to focus
  1264.      * on accuracy. The interpolation features are intended to save processing time
  1265.      * by avoiding doing some lengthy computation like nutation evaluation at each
  1266.      * time step and caching some results. This method can be used to avoid this,
  1267.      * when very high accuracy is desired, or for testing purposes. It should be
  1268.      * used with care, as doing the full computation is <em>really</em> costly for
  1269.      * some frames.
  1270.      * </p>
  1271.      * @param from frame from which transformation starts
  1272.      * @param to frame to which transformation ends
  1273.      * @param date date of the transform
  1274.      * @return transform between the two frames, avoiding interpolation
  1275.      * @throws OrekitException if transform cannot be computed at this date
  1276.      */
  1277.     public static Transform getNonInterpolatingTransform(final Frame from, final Frame to,
  1278.                                                          final AbsoluteDate date)
  1279.         throws OrekitException {

  1281.         // common ancestor to both frames in the frames tree
  1282.         Frame currentF = from.getDepth() > to.getDepth() ? from.getAncestor(from.getDepth() - to.getDepth()) : from;
  1283.         Frame currentT = from.getDepth() > to.getDepth() ? to : to.getAncestor(to.getDepth() - from.getDepth());
  1284.         while (currentF != currentT) {
  1285.             currentF = currentF.getParent();
  1286.             currentT = currentT.getParent();
  1287.         }
  1288.         final Frame common = currentF;

  1290.         // transform from common to origin
  1291.         Transform commonToOrigin = Transform.IDENTITY;
  1292.         for (Frame frame = from; frame != common; frame = frame.getParent()) {
  1293.             commonToOrigin = new Transform(date,
  1294.                                              peel(frame.getTransformProvider()).getTransform(date),
  1295.                                              commonToOrigin);
  1296.         }

  1298.         // transform from destination up to common
  1299.         Transform commonToDestination = Transform.IDENTITY;
  1300.         for (Frame frame = to; frame != common; frame = frame.getParent()) {
  1301.             commonToDestination = new Transform(date,
  1302.                                                 peel(frame.getTransformProvider()).getTransform(date),
  1303.                                                 commonToDestination);
  1304.         }

  1306.         // transform from origin to destination via common
  1307.         return new Transform(date, commonToOrigin.getInverse(), commonToDestination);

  1309.     }

  1311.     /** Get the transform between two frames, suppressing all interpolation.
  1312.      * <p>
  1313.      * This method is similar to {@link Frame#getTransformTo(Frame, AbsoluteDate)}
  1314.      * except it removes the performance enhancing interpolation features that are
  1315.      * added by the {@link FramesFactory factory} to some frames, in order to focus
  1316.      * on accuracy. The interpolation features are intended to save processing time
  1317.      * by avoiding doing some lengthy computation like nutation evaluation at each
  1318.      * time step and caching some results. This method can be used to avoid this,
  1319.      * when very high accuracy is desired, or for testing purposes. It should be
  1320.      * used with care, as doing the full computation is <em>really</em> costly for
  1321.      * some frames.
  1322.      * </p>
  1323.      * @param from frame from which transformation starts
  1324.      * @param to frame to which transformation ends
  1325.      * @param date date of the transform
  1326.      * @param <T> type of the field elements
  1327.      * @return transform between the two frames, avoiding interpolation
  1328.      * @throws OrekitException if transform cannot be computed at this date
  1329.      * @since 9.0
  1330.      */
  1331.     public static <T extends RealFieldElement<T>> FieldTransform<T> getNonInterpolatingTransform(final Frame from, final Frame to,
  1332.                                                                                                  final FieldAbsoluteDate<T> date)
  1333.         throws OrekitException {

  1335.         // common ancestor to both frames in the frames tree
  1336.         Frame currentF = from.getDepth() > to.getDepth() ? from.getAncestor(from.getDepth() - to.getDepth()) : from;
  1337.         Frame currentT = from.getDepth() > to.getDepth() ? to : to.getAncestor(to.getDepth() - from.getDepth());
  1338.         while (currentF != currentT) {
  1339.             currentF = currentF.getParent();
  1340.             currentT = currentT.getParent();
  1341.         }
  1342.         final Frame common = currentF;

  1344.         // transform from common to origin
  1345.         FieldTransform<T> commonToOrigin = FieldTransform.getIdentity(date.getField());
  1346.         for (Frame frame = from; frame != common; frame = frame.getParent()) {
  1347.             commonToOrigin = new FieldTransform<>(date,
  1348.                                                    peel(frame.getTransformProvider()).getTransform(date),
  1349.                                                    commonToOrigin);
  1350.         }

  1352.         // transform from destination up to common
  1353.         FieldTransform<T> commonToDestination = FieldTransform.getIdentity(date.getField());
  1354.         for (Frame frame = to; frame != common; frame = frame.getParent()) {
  1355.             commonToDestination = new FieldTransform<>(date,
  1356.                                                        peel(frame.getTransformProvider()).getTransform(date),
  1357.                                                        commonToDestination);
  1358.         }

  1360.         // transform from origin to destination via common
  1361.         return new FieldTransform<>(date, commonToOrigin.getInverse(), commonToDestination);

  1363.     }

  1365.     /** Retrieve EOP from a frame hierarchy.
  1366.      * <p>
  1367.      * The frame hierarchy tree is walked from specified frame up to root
  1368.      * goind though parent frames, and the providers are checked to see if they
  1369.      * reference EOP history.the first EOP history found is returned.
  1370.      * </p>
  1371.      * @param start frame from which to start search, will typically be some
  1372.      * Earth related frame, like a topocentric frame or an ITRF frame
  1373.      * @return EOP history found while walking the frames tree, or null if
  1374.      * no EOP history is found
  1375.      * @since 9.1
  1376.      */
  1377.     public static EOPHistory findEOP(final Frame start) {

  1379.         for (Frame frame = start; frame != null; frame = frame.getParent()) {

  1381.             TransformProvider peeled = frame.getTransformProvider();

  1383.             boolean peeling = true;
  1384.             while (peeling) {
  1385.                 if (peeled instanceof InterpolatingTransformProvider) {
  1386.                     peeled = ((InterpolatingTransformProvider) peeled).getRawProvider();
  1387.                 } else if (peeled instanceof ShiftingTransformProvider) {
  1388.                     peeled = ((ShiftingTransformProvider) peeled).getRawProvider();
  1389.                 } else if (peeled instanceof EOPBasedTransformProvider &&
  1390.                            ((EOPBasedTransformProvider) peeled).getEOPHistory() != null) {
  1391.                     return ((EOPBasedTransformProvider) peeled).getEOPHistory();
  1392.                 } else {
  1393.                     peeling = false;
  1394.                 }
  1395.             }

  1397.         }

  1399.         // no history found
  1400.         return null;

  1402.     }

  1404.     /** Peel interpolation and shifting from a transform provider.
  1405.      * @param provider transform provider to peel
  1406.      * @return peeled transform provider
  1407.      * @exception OrekitException if EOP cannot be retrieved
  1408.      */
  1409.     private static TransformProvider peel(final TransformProvider provider)
  1410.         throws OrekitException {

  1412.         TransformProvider peeled = provider;

  1414.         boolean peeling = true;
  1415.         while (peeling) {
  1416.             if (peeled instanceof InterpolatingTransformProvider) {
  1417.                 peeled = ((InterpolatingTransformProvider) peeled).getRawProvider();
  1418.             } else if (peeled instanceof ShiftingTransformProvider) {
  1419.                 peeled = ((ShiftingTransformProvider) peeled).getRawProvider();
  1420.             } else if (peeled instanceof EOPBasedTransformProvider &&
  1421.                        ((EOPBasedTransformProvider) peeled).getEOPHistory() != null &&
  1422.                        ((EOPBasedTransformProvider) peeled).getEOPHistory().usesInterpolation()) {
  1423.                 peeled = ((EOPBasedTransformProvider) peeled).getNonInterpolatingProvider();
  1424.             } else {
  1425.                 peeling = false;
  1426.             }
  1427.         }

  1429.         return peeled;

  1431.     }

  1433.     /** Local class for different ITRF versions keys.
  1434.      * @since 9.2
  1435.      */
  1436.     private static class ITRFKey implements Serializable {

  1438.         /** Serialized UID. */
  1439.         private static final long serialVersionUID = 20180412L;

  1441.         /** ITRF version. */
  1442.         private final ITRFVersion version;

  1444.         /** IERS conventions to apply. */
  1445.         private final IERSConventions conventions;

  1447.         /** Tidal effects flag. */
  1448.         private final boolean simpleEOP;

  1450.         /** Simple constructor.
  1451.          * @param version ITRF version
  1452.          * @param conventions IERS conventions to apply
  1453.          * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1454.          */
  1455.         ITRFKey(final ITRFVersion version, final IERSConventions conventions, final boolean simpleEOP) {
  1456.             this.version     = version;
  1457.             this.conventions = conventions;
  1458.             this.simpleEOP   = simpleEOP;
  1459.         }

  1461.         /** {@inheritDoc} */
  1462.         @Override
  1463.         public int hashCode() {
  1464.             return (version.ordinal()     << 5) +
  1465.                    (conventions.ordinal() << 1) +
  1466.                    (simpleEOP ? 0 : 1);
  1467.         }

  1469.         /** {@inheritDoc} */
  1470.         @Override
  1471.         public boolean equals(final Object other) {

  1473.             if (this == other) {
  1474.                 return true;
  1475.             }

  1477.             if (other instanceof ITRFKey) {
  1478.                 final ITRFKey key = (ITRFKey) other;
  1479.                 return version     == key.version     &&
  1480.                        conventions == key.conventions &&
  1481.                        simpleEOP   == key.simpleEOP;
  1482.             }

  1484.             return false;
  1485.         }

  1487.     }

  1489. }
Created with JaCoCo 0.7.9.201702052155