FramesFactory.java

  1. /* Copyright 2002-2019 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.      */
  390.     public static EOPHistory getEOPHistory(final IERSConventions conventions, final boolean simpleEOP) {

  392.         synchronized (EOP_HISTORY_LOADERS) {

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

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

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

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

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

  423.         }

  425.     }

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

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

  547.     /** Get the unique ICRF frame.
  548.      * <p>The ICRF frame is centered at solar system barycenter and aligned
  549.      * with GCRF.</p>
  550.      * @return the unique instance of the ICRF frame
  551.      */
  552.     public static Frame getICRF() {
  553.         return CelestialBodyFactory.getSolarSystemBarycenter().getInertiallyOrientedFrame();
  554.     }

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

  569.             final Predefined factoryKey;
  570.             switch (conventions) {
  571.                 case IERS_1996 :
  572.                     factoryKey = Predefined.ECLIPTIC_CONVENTIONS_1996;
  573.                     break;
  574.                 case IERS_2003 :
  575.                     factoryKey = Predefined.ECLIPTIC_CONVENTIONS_2003;
  576.                     break;
  577.                 case IERS_2010 :
  578.                     factoryKey = Predefined.ECLIPTIC_CONVENTIONS_2010;
  579.                     break;
  580.                 default :
  581.                     // this should never happen
  582.                     throw new OrekitInternalError(null);
  583.             }
  584.             final Frame parent = getMOD(conventions);

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

  589.             if (frame == null) {
  590.                 // it's the first time we need this frame, build it and store it
  591.                 frame = new FactoryManagedFrame(parent, new EclipticProvider(conventions),
  592.                                                 true, factoryKey);
  593.                 FRAMES.put(factoryKey, frame);
  594.             }

  596.             return frame;

  598.         }
  599.     }

  601.     /** Get the unique EME2000 frame.
  602.      * <p>The EME2000 frame is also called the J2000 frame.
  603.      * The former denomination is preferred in Orekit.</p>
  604.      * @return the unique instance of the EME2000 frame
  605.      */
  606.     public static FactoryManagedFrame getEME2000() {
  607.         synchronized (FramesFactory.class) {

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

  612.             if (frame == null) {
  613.                 // it's the first time we need this frame, build it and store it
  614.                 frame = new FactoryManagedFrame(getGCRF(), new EME2000Provider(), true, Predefined.EME2000);
  615.                 FRAMES.put(Predefined.EME2000, frame);
  616.             }

  618.             return frame;

  620.         }
  621.     }

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

  648.             // try to find an already built frame
  649.             final Predefined factoryKey;
  650.             switch (conventions) {
  651.                 case IERS_1996 :
  652.                     factoryKey = simpleEOP ?
  653.                                  Predefined.ITRF_CIO_CONV_1996_SIMPLE_EOP :
  654.                                  Predefined.ITRF_CIO_CONV_1996_ACCURATE_EOP;
  655.                     break;
  656.                 case IERS_2003 :
  657.                     factoryKey = simpleEOP ?
  658.                                  Predefined.ITRF_CIO_CONV_2003_SIMPLE_EOP :
  659.                                  Predefined.ITRF_CIO_CONV_2003_ACCURATE_EOP;
  660.                     break;
  661.                 case IERS_2010 :
  662.                     factoryKey = simpleEOP ?
  663.                                  Predefined.ITRF_CIO_CONV_2010_SIMPLE_EOP :
  664.                                  Predefined.ITRF_CIO_CONV_2010_ACCURATE_EOP;
  665.                     break;
  666.                 default :
  667.                     // this should never happen
  668.                     throw new OrekitInternalError(null);
  669.             }
  670.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  672.             if (frame == null) {
  673.                 // it's the first time we need this frame, build it and store it
  674.                 final Frame tirfFrame = getTIRF(conventions, simpleEOP);
  675.                 final TIRFProvider tirfProvider = (TIRFProvider) tirfFrame.getTransformProvider();
  676.                 frame = new FactoryManagedFrame(tirfFrame,
  677.                                                 new ITRFProvider(tirfProvider.getEOPHistory()),
  678.                                                 false, factoryKey);
  679.                 FRAMES.put(factoryKey, frame);
  680.             }

  682.             return frame;

  684.         }
  685.     }

  687.     /** Get the TIRF reference frame, ignoring tidal effects.
  688.      * @param conventions IERS conventions to apply
  689.      * @return the selected reference frame singleton.
  690.           * library cannot be read.
  691.      */
  692.     public static FactoryManagedFrame getTIRF(final IERSConventions conventions) {
  693.         return getTIRF(conventions, true);
  694.     }

  696.     /** Get an specific International Terrestrial Reference Frame.
  697.      * <p>
  698.      * Note that if a specific version of ITRF is required, then {@code simpleEOP}
  699.      * should most probably be set to {@code false}, as ignoring tidal effects
  700.      * has an effect of the same order of magnitude as the differences between
  701.      * the various {@link ITRFVersion ITRF versions}.
  702.      * </p>
  703.      * @param version ITRF version
  704.      * @param conventions IERS conventions to apply
  705.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  706.      * @return the selected reference frame singleton.
  707.           * @since 9.2
  708.      */
  709.     public static VersionedITRF getITRF(final ITRFVersion version,
  710.                                         final IERSConventions conventions,
  711.                                         final boolean simpleEOP) {
  712.         synchronized (FramesFactory.class) {
  713.             // try to find an already built frame
  714.             final ITRFKey key = new ITRFKey(version, conventions, simpleEOP);
  715.             VersionedITRF frame = VERSIONED_ITRF_FRAMES.get(key);

  717.             if (frame == null) {
  718.                 // it's the first time we need this frame, build it and store it
  719.                 final FactoryManagedFrame rawITRF = getITRF(conventions, simpleEOP);
  720.                 frame = new VersionedITRF(rawITRF.getParent(), version,
  721.                                           (ITRFProvider) rawITRF.getTransformProvider(),
  722.                                           version.toString().replace('_', '-') +
  723.                                           "/" +
  724.                                           rawITRF.getName());
  725.                 VERSIONED_ITRF_FRAMES.put(key, frame);
  726.             }

  728.             return frame;

  730.         }
  731.     }

  733.     /** Get the TIRF reference frame.
  734.      * @param conventions IERS conventions to apply
  735.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  736.      * @return the selected reference frame singleton.
  737.      * @since 6.1
  738.      */
  739.     public static FactoryManagedFrame getTIRF(final IERSConventions conventions,
  740.                                               final boolean simpleEOP) {
  741.         synchronized (FramesFactory.class) {

  743.             // try to find an already built frame
  744.             final Predefined factoryKey;
  745.             switch (conventions) {
  746.                 case IERS_1996 :
  747.                     factoryKey = simpleEOP ?
  748.                                  Predefined.TIRF_CONVENTIONS_1996_SIMPLE_EOP :
  749.                                  Predefined.TIRF_CONVENTIONS_1996_ACCURATE_EOP;
  750.                     break;
  751.                 case IERS_2003 :
  752.                     factoryKey = simpleEOP ?
  753.                                  Predefined.TIRF_CONVENTIONS_2003_SIMPLE_EOP :
  754.                                  Predefined.TIRF_CONVENTIONS_2003_ACCURATE_EOP;
  755.                     break;
  756.                 case IERS_2010 :
  757.                     factoryKey = simpleEOP ?
  758.                                  Predefined.TIRF_CONVENTIONS_2010_SIMPLE_EOP :
  759.                                  Predefined.TIRF_CONVENTIONS_2010_ACCURATE_EOP;
  760.                     break;
  761.                 default :
  762.                     // this should never happen
  763.                     throw new OrekitInternalError(null);
  764.             }
  765.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  767.             if (frame == null) {
  768.                 // it's the first time we need this frame, build it and store it
  769.                 final Frame cirf = getCIRF(conventions, simpleEOP);
  770.                 final ShiftingTransformProvider cirfInterpolating =
  771.                         (ShiftingTransformProvider) cirf.getTransformProvider();
  772.                 final CIRFProvider cirfRaw = (CIRFProvider) cirfInterpolating.getRawProvider();
  773.                 final EOPHistory eopHistory = cirfRaw.getEOPHistory();
  774.                 frame = new FactoryManagedFrame(cirf, new TIRFProvider(eopHistory), false, factoryKey);
  775.                 FRAMES.put(factoryKey, frame);
  776.             }

  778.             return frame;

  780.         }
  781.     }

  783.     /** Get the CIRF2000 reference frame.
  784.      * @param conventions IERS conventions to apply
  785.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  786.      * @return the selected reference frame singleton.
  787.      */
  788.     public static FactoryManagedFrame getCIRF(final IERSConventions conventions,
  789.                                               final boolean simpleEOP) {
  790.         synchronized (FramesFactory.class) {

  792.             // try to find an already built frame
  793.             final Predefined factoryKey;
  794.             switch (conventions) {
  795.                 case IERS_1996 :
  796.                     factoryKey = simpleEOP ?
  797.                                  Predefined.CIRF_CONVENTIONS_1996_SIMPLE_EOP :
  798.                                  Predefined.CIRF_CONVENTIONS_1996_ACCURATE_EOP;
  799.                     break;
  800.                 case IERS_2003 :
  801.                     factoryKey = simpleEOP ?
  802.                                  Predefined.CIRF_CONVENTIONS_2003_SIMPLE_EOP :
  803.                                  Predefined.CIRF_CONVENTIONS_2003_ACCURATE_EOP;
  804.                     break;
  805.                 case IERS_2010 :
  806.                     factoryKey = simpleEOP ?
  807.                                  Predefined.CIRF_CONVENTIONS_2010_SIMPLE_EOP :
  808.                                  Predefined.CIRF_CONVENTIONS_2010_ACCURATE_EOP;
  809.                     break;
  810.                 default :
  811.                     // this should never happen
  812.                     throw new OrekitInternalError(null);
  813.             }
  814.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  816.             if (frame == null) {
  817.                 // it's the first time we need this frame, build it and store it
  818.                 final EOPHistory eopHistory = FramesFactory.getEOPHistory(conventions, simpleEOP);
  819.                 final TransformProvider shifting =
  820.                         new ShiftingTransformProvider(new CIRFProvider(eopHistory),
  821.                                                       CartesianDerivativesFilter.USE_PVA,
  822.                                                       AngularDerivativesFilter.USE_R,
  823.                                                       6, Constants.JULIAN_DAY / 24,
  824.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  825.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  826.                 frame = new FactoryManagedFrame(getGCRF(), shifting, true, factoryKey);
  827.                 FRAMES.put(factoryKey, frame);
  828.             }

  830.             return frame;

  832.         }
  833.     }

  835.     /** Get the VEIS 1950 reference frame.
  836.      * <p>Its parent frame is the GTOD frame with IERS 1996 conventions without EOP corrections.<p>
  837.      * @return the selected reference frame singleton.
  838.      */
  839.     public static FactoryManagedFrame getVeis1950() {
  840.         synchronized (FramesFactory.class) {

  842.             // try to find an already built frame
  843.             final Predefined factoryKey = Predefined.VEIS_1950;
  844.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  846.             if (frame == null) {
  847.                 // it's the first time we need this frame, build it and store it
  848.                 frame = new FactoryManagedFrame(FramesFactory.getGTOD(IERSConventions.IERS_1996, false, true),
  849.                                                 new VEISProvider(), true, factoryKey);
  850.                 FRAMES.put(factoryKey, frame);
  851.             }

  853.             return frame;

  855.         }
  856.     }

  858.     /** Get the equinox-based ITRF reference frame.
  859.      * @param conventions IERS conventions to apply
  860.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  861.      * @return the selected reference frame singleton.
  862.           * @since 6.1
  863.      */
  864.     public static FactoryManagedFrame getITRFEquinox(final IERSConventions conventions,
  865.                                                      final boolean simpleEOP) {
  866.         synchronized (FramesFactory.class) {

  868.             // try to find an already built frame
  869.             final Predefined factoryKey;
  870.             switch (conventions) {
  871.                 case IERS_1996 :
  872.                     factoryKey = simpleEOP ?
  873.                                  Predefined.ITRF_EQUINOX_CONV_1996_SIMPLE_EOP :
  874.                                  Predefined.ITRF_EQUINOX_CONV_1996_ACCURATE_EOP;
  875.                     break;
  876.                 case IERS_2003 :
  877.                     factoryKey = simpleEOP ?
  878.                                  Predefined.ITRF_EQUINOX_CONV_2003_SIMPLE_EOP :
  879.                                  Predefined.ITRF_EQUINOX_CONV_2003_ACCURATE_EOP;
  880.                     break;
  881.                 case IERS_2010 :
  882.                     factoryKey = simpleEOP ?
  883.                                  Predefined.ITRF_EQUINOX_CONV_2010_SIMPLE_EOP :
  884.                                  Predefined.ITRF_EQUINOX_CONV_2010_ACCURATE_EOP;
  885.                     break;
  886.                 default :
  887.                     // this should never happen
  888.                     throw new OrekitInternalError(null);
  889.             }
  890.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  892.             if (frame == null) {
  893.                 // it's the first time we need this frame, build it and store it
  894.                 final Frame gtod = getGTOD(conventions, true, simpleEOP);
  895.                 final ShiftingTransformProvider gtodShifting =
  896.                         (ShiftingTransformProvider) gtod.getTransformProvider();
  897.                 final GTODProvider gtodRaw    = (GTODProvider) gtodShifting.getRawProvider();
  898.                 final EOPHistory   eopHistory = gtodRaw.getEOPHistory();
  899.                 frame = new FactoryManagedFrame(gtod, new ITRFProvider(eopHistory), false, factoryKey);
  900.                 FRAMES.put(factoryKey, frame);
  901.             }

  903.             return frame;

  905.         }
  906.     }

  908.     /** Get the GTOD reference frame.
  909.      * <p>
  910.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  911.      * consistency with legacy software that don't handle EOP correction parameters.
  912.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  913.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  914.      * For this reason, setting this parameter to false is restricted to {@link
  915.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  916.      * IERSConventions IERS conventions} cannot be freely chosen here.
  917.      * </p>
  918.      * @param applyEOPCorr if true, EOP corrections are applied (here, dut1 and lod)
  919.      * @return the selected reference frame singleton.
  920.      */
  921.     public static FactoryManagedFrame getGTOD(final boolean applyEOPCorr) {
  922.         return getGTOD(IERSConventions.IERS_1996, applyEOPCorr, true);
  923.     }

  925.     /** Get the GTOD reference frame.
  926.      * @param conventions IERS conventions to apply
  927.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  928.      * @return the selected reference frame singleton.
  929.      */
  930.     public static FactoryManagedFrame getGTOD(final IERSConventions conventions,
  931.                                               final boolean simpleEOP) {
  932.         return getGTOD(conventions, true, simpleEOP);
  933.     }

  935.     /** Get the GTOD reference frame.
  936.      * <p>
  937.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  938.      * consistency with legacy software that don't handle EOP correction parameters.
  939.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  940.      * (order of magnitudes for errors might be above 250m in LEO and 1400m in GEO).
  941.      * For this reason, setting this parameter to false is restricted to {@link
  942.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence this method is private.
  943.      * </p>
  944.      * @param conventions IERS conventions to apply
  945.      * @param applyEOPCorr if true, EOP corrections are applied (here, dut1 and lod)
  946.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  947.      * @return the selected reference frame singleton.
  948.      */
  949.     private static FactoryManagedFrame getGTOD(final IERSConventions conventions,
  950.                                                final boolean applyEOPCorr,
  951.                                                final boolean simpleEOP) {

  953.         synchronized (FramesFactory.class) {

  955.             // try to find an already built frame
  956.             final Predefined factoryKey;
  957.             switch (conventions) {
  958.                 case IERS_1996 :
  959.                     factoryKey = applyEOPCorr ?
  960.                                  (simpleEOP ? Predefined.GTOD_CONVENTIONS_1996_SIMPLE_EOP : Predefined.GTOD_CONVENTIONS_1996_ACCURATE_EOP) :
  961.                                  Predefined.GTOD_WITHOUT_EOP_CORRECTIONS;
  962.                     break;
  963.                 case IERS_2003 :
  964.                     factoryKey = simpleEOP ?
  965.                                  Predefined.GTOD_CONVENTIONS_2003_SIMPLE_EOP :
  966.                                  Predefined.GTOD_CONVENTIONS_2003_ACCURATE_EOP;
  967.                     break;
  968.                 case IERS_2010 :
  969.                     factoryKey = simpleEOP ? Predefined.GTOD_CONVENTIONS_2010_SIMPLE_EOP :
  970.                                              Predefined.GTOD_CONVENTIONS_2010_ACCURATE_EOP;
  971.                     break;
  972.                 default :
  973.                     // this should never happen
  974.                     throw new OrekitInternalError(null);
  975.             }
  976.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  978.             if (frame == null) {
  979.                 // it's the first time we need this frame, build it and store it
  980.                 final Frame tod = getTOD(conventions, applyEOPCorr, simpleEOP);
  981.                 final ShiftingTransformProvider todInterpolating =
  982.                         (ShiftingTransformProvider) tod.getTransformProvider();
  983.                 final TODProvider       todRaw     = (TODProvider) todInterpolating.getRawProvider();
  984.                 final EOPHistory        eopHistory = todRaw.getEOPHistory();
  985.                 final GTODProvider      gtodRaw    = new GTODProvider(conventions, eopHistory);
  986.                 final TransformProvider gtodShifting =
  987.                         new ShiftingTransformProvider(gtodRaw,
  988.                                                       CartesianDerivativesFilter.USE_PVA,
  989.                                                       AngularDerivativesFilter.USE_R,
  990.                                                       todInterpolating.getGridPoints(), todInterpolating.getStep(),
  991.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  992.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  993.                 frame = new FactoryManagedFrame(tod, gtodShifting, false, factoryKey);
  994.                 FRAMES.put(factoryKey, frame);
  995.             }

  997.             return frame;

  999.         }
  1000.     }

  1002.     /** Get the TOD reference frame.
  1003.      * <p>
  1004.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1005.      * consistency with legacy software that don't handle EOP correction parameters.
  1006.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1007.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1008.      * For this reason, setting this parameter to false is restricted to {@link
  1009.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  1010.      * IERSConventions IERS conventions} cannot be freely chosen here.
  1011.      * </p>
  1012.      * @param applyEOPCorr if true, EOP corrections are applied (here, nutation)
  1013.      * @return the selected reference frame singleton.
  1014.      */
  1015.     public static FactoryManagedFrame getTOD(final boolean applyEOPCorr) {
  1016.         return getTOD(IERSConventions.IERS_1996, applyEOPCorr, false);
  1017.     }

  1019.     /** Get the TOD reference frame.
  1020.      * @param conventions IERS conventions to apply
  1021.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1022.      * @return the selected reference frame singleton.
  1023.      */
  1024.     public static FactoryManagedFrame getTOD(final IERSConventions conventions,
  1025.                                              final boolean simpleEOP) {
  1026.         return getTOD(conventions, true, simpleEOP);
  1027.     }

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

  1047.         synchronized (FramesFactory.class) {

  1049.             // try to find an already built frame
  1050.             final Predefined factoryKey;
  1051.             switch (conventions) {
  1052.                 case IERS_1996 :
  1053.                     factoryKey = applyEOPCorr ?
  1054.                                  (simpleEOP ? Predefined.TOD_CONVENTIONS_1996_SIMPLE_EOP : Predefined.TOD_CONVENTIONS_1996_ACCURATE_EOP) :
  1055.                                  Predefined.TOD_WITHOUT_EOP_CORRECTIONS;
  1056.                     break;
  1057.                 case IERS_2003 :
  1058.                     factoryKey = simpleEOP ?
  1059.                                  Predefined.TOD_CONVENTIONS_2003_SIMPLE_EOP :
  1060.                                      Predefined.TOD_CONVENTIONS_2003_ACCURATE_EOP;
  1061.                     break;
  1062.                 case IERS_2010 :
  1063.                     factoryKey = simpleEOP ?
  1064.                                  Predefined.TOD_CONVENTIONS_2010_SIMPLE_EOP :
  1065.                                  Predefined.TOD_CONVENTIONS_2010_ACCURATE_EOP;
  1066.                     break;
  1067.                 default :
  1068.                     // this should never happen
  1069.                     throw new OrekitInternalError(null);
  1070.             }
  1071.             final int interpolationPoints;
  1072.             final int pointsPerDay;
  1073.             if (applyEOPCorr) {
  1074.                 interpolationPoints = 6;
  1075.                 pointsPerDay        = 24;
  1076.             } else {
  1077.                 interpolationPoints = 6;
  1078.                 pointsPerDay        = 8;
  1079.             }
  1080.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1082.             if (frame == null) {
  1083.                 // it's the first time we need this frame, build it and store it
  1084.                 final EOPHistory eopHistory = applyEOPCorr ? getEOPHistory(conventions, simpleEOP) : null;
  1085.                 final TransformProvider shifting =
  1086.                         new ShiftingTransformProvider(new TODProvider(conventions, eopHistory),
  1087.                                                       CartesianDerivativesFilter.USE_PVA,
  1088.                                                       AngularDerivativesFilter.USE_R,
  1089.                                                       interpolationPoints, Constants.JULIAN_DAY / pointsPerDay,
  1090.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  1091.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);
  1092.                 frame = new FactoryManagedFrame(getMOD(conventions, applyEOPCorr), shifting, true, factoryKey);
  1093.                 FRAMES.put(factoryKey, frame);
  1094.             }

  1096.             return frame;

  1098.         }
  1099.     }

  1101.     /** Get the MOD reference frame.
  1102.      * <p>
  1103.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1104.      * consistency with legacy software that don't handle EOP correction parameters.
  1105.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1106.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1107.      * For this reason, setting this parameter to false is restricted to {@link
  1108.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence the {@link
  1109.      * IERSConventions IERS conventions} cannot be freely chosen here.
  1110.      * </p>
  1111.      * @param applyEOPCorr if true, EOP corrections are applied (EME2000/GCRF bias compensation)
  1112.      * @return the selected reference frame singleton.
  1113.      */
  1114.     public static FactoryManagedFrame getMOD(final boolean applyEOPCorr) {
  1115.         return getMOD(IERSConventions.IERS_1996, applyEOPCorr);
  1116.     }

  1118.     /** Get the MOD reference frame.
  1119.      * @param conventions IERS conventions to apply
  1120.      * @return the selected reference frame singleton.
  1121.      */
  1122.     public static FactoryManagedFrame getMOD(final IERSConventions conventions) {
  1123.         return getMOD(conventions, true);
  1124.     }

  1126.     /** Get the MOD reference frame.
  1127.      * <p>
  1128.      * The applyEOPCorr parameter is available mainly for testing purposes or for
  1129.      * consistency with legacy software that don't handle EOP correction parameters.
  1130.      * Beware that setting this parameter to {@code false} leads to crude accuracy
  1131.      * (order of magnitudes for errors might be above 1m in LEO and 10m in GEO).
  1132.      * For this reason, setting this parameter to false is restricted to {@link
  1133.      * IERSConventions#IERS_1996 IERS 1996} conventions, and hence this method is private.
  1134.      * </p>
  1135.      * @param conventions IERS conventions to apply
  1136.      * @param applyEOPCorr if true, EOP corrections are applied (EME2000/GCRF bias compensation)
  1137.      * @return the selected reference frame singleton.
  1138.      */
  1139.     private static FactoryManagedFrame getMOD(final IERSConventions conventions, final boolean applyEOPCorr) {

  1141.         synchronized (FramesFactory.class) {

  1143.             final Predefined factoryKey;
  1144.             final Frame parent;
  1145.             switch (conventions) {
  1146.                 case IERS_1996 :
  1147.                     factoryKey = applyEOPCorr ? Predefined.MOD_CONVENTIONS_1996 : Predefined.MOD_WITHOUT_EOP_CORRECTIONS;
  1148.                     parent     = applyEOPCorr ? FramesFactory.getGCRF() : FramesFactory.getEME2000();
  1149.                     break;
  1150.                 case IERS_2003 :
  1151.                     factoryKey = Predefined.MOD_CONVENTIONS_2003;
  1152.                     // in IERS conventions 2003, the precession angles zetaA, thetaA and zA
  1153.                     // from equation 33 are computed from EME2000, not from GCRF
  1154.                     parent     = FramesFactory.getEME2000();
  1155.                     break;
  1156.                 case IERS_2010 :
  1157.                     factoryKey = Predefined.MOD_CONVENTIONS_2010;
  1158.                     // precession angles epsilon0, psiA, omegaA and chiA
  1159.                     // from equations 5.39 and 5.40 are computed from EME2000
  1160.                     parent     = FramesFactory.getEME2000();
  1161.                     break;
  1162.                 default :
  1163.                     // this should never happen
  1164.                     throw new OrekitInternalError(null);
  1165.             }

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

  1170.             if (frame == null) {
  1171.                 // it's the first time we need this frame, build it and store it
  1172.                 frame = new FactoryManagedFrame(parent, new MODProvider(conventions), true, factoryKey);
  1173.                 FRAMES.put(factoryKey, frame);
  1174.             }

  1176.             return frame;

  1178.         }
  1179.     }

  1181.     /** Get the TEME reference frame.
  1182.      * <p>
  1183.      * The TEME frame is used for the SGP4 model in TLE propagation. This frame has <em>no</em>
  1184.      * official definition and there are some ambiguities about whether it should be used
  1185.      * as "of date" or "of epoch". This frame should therefore be used <em>only</em> for
  1186.      * TLE propagation and not for anything else, as recommended by the CCSDS Orbit Data Message
  1187.      * blue book.
  1188.      * </p>
  1189.      * @return the selected reference frame singleton.
  1190.      */
  1191.     public static FactoryManagedFrame getTEME() {
  1192.         synchronized (FramesFactory.class) {

  1194.             // try to find an already built frame
  1195.             final Predefined factoryKey = Predefined.TEME;
  1196.             FactoryManagedFrame frame = FRAMES.get(factoryKey);

  1198.             if (frame == null) {
  1199.                 // it's the first time we need this frame, build it and store it
  1200.                 final Frame tod = getTOD(IERSConventions.IERS_1996, false, true);
  1201.                 final ShiftingTransformProvider todShifting =
  1202.                         (ShiftingTransformProvider) tod.getTransformProvider();
  1203.                 final TEMEProvider temeRaw = new TEMEProvider(IERSConventions.IERS_1996, null);
  1204.                 final TransformProvider temeShifting =
  1205.                         new ShiftingTransformProvider(temeRaw,
  1206.                                                       CartesianDerivativesFilter.USE_PVA,
  1207.                                                       AngularDerivativesFilter.USE_R,
  1208.                                                       todShifting.getGridPoints(), todShifting.getStep(),
  1209.                                                       OrekitConfiguration.getCacheSlotsNumber(),
  1210.                                                       Constants.JULIAN_YEAR, 30 * Constants.JULIAN_DAY);

  1212.                 frame = new FactoryManagedFrame(tod, temeShifting, true, factoryKey);
  1213.                 FRAMES.put(factoryKey, frame);
  1214.             }

  1216.             return frame;

  1218.         }
  1219.     }

  1221.     /** Get the transform between two frames, suppressing all interpolation.
  1222.      * <p>
  1223.      * This method is similar to {@link Frame#getTransformTo(Frame, AbsoluteDate)}
  1224.      * except it removes the performance enhancing interpolation features that are
  1225.      * added by the {@link FramesFactory factory} to some frames, in order to focus
  1226.      * on accuracy. The interpolation features are intended to save processing time
  1227.      * by avoiding doing some lengthy computation like nutation evaluation at each
  1228.      * time step and caching some results. This method can be used to avoid this,
  1229.      * when very high accuracy is desired, or for testing purposes. It should be
  1230.      * used with care, as doing the full computation is <em>really</em> costly for
  1231.      * some frames.
  1232.      * </p>
  1233.      * @param from frame from which transformation starts
  1234.      * @param to frame to which transformation ends
  1235.      * @param date date of the transform
  1236.      * @return transform between the two frames, avoiding interpolation
  1237.      */
  1238.     public static Transform getNonInterpolatingTransform(final Frame from, final Frame to,
  1239.                                                          final AbsoluteDate date) {

  1241.         // common ancestor to both frames in the frames tree
  1242.         Frame currentF = from.getDepth() > to.getDepth() ? from.getAncestor(from.getDepth() - to.getDepth()) : from;
  1243.         Frame currentT = from.getDepth() > to.getDepth() ? to : to.getAncestor(to.getDepth() - from.getDepth());
  1244.         while (currentF != currentT) {
  1245.             currentF = currentF.getParent();
  1246.             currentT = currentT.getParent();
  1247.         }
  1248.         final Frame common = currentF;

  1250.         // transform from common to origin
  1251.         Transform commonToOrigin = Transform.IDENTITY;
  1252.         for (Frame frame = from; frame != common; frame = frame.getParent()) {
  1253.             commonToOrigin = new Transform(date,
  1254.                                              peel(frame.getTransformProvider()).getTransform(date),
  1255.                                              commonToOrigin);
  1256.         }

  1258.         // transform from destination up to common
  1259.         Transform commonToDestination = Transform.IDENTITY;
  1260.         for (Frame frame = to; frame != common; frame = frame.getParent()) {
  1261.             commonToDestination = new Transform(date,
  1262.                                                 peel(frame.getTransformProvider()).getTransform(date),
  1263.                                                 commonToDestination);
  1264.         }

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

  1269.     }

  1271.     /** Get the transform between two frames, suppressing all interpolation.
  1272.      * <p>
  1273.      * This method is similar to {@link Frame#getTransformTo(Frame, AbsoluteDate)}
  1274.      * except it removes the performance enhancing interpolation features that are
  1275.      * added by the {@link FramesFactory factory} to some frames, in order to focus
  1276.      * on accuracy. The interpolation features are intended to save processing time
  1277.      * by avoiding doing some lengthy computation like nutation evaluation at each
  1278.      * time step and caching some results. This method can be used to avoid this,
  1279.      * when very high accuracy is desired, or for testing purposes. It should be
  1280.      * used with care, as doing the full computation is <em>really</em> costly for
  1281.      * some frames.
  1282.      * </p>
  1283.      * @param from frame from which transformation starts
  1284.      * @param to frame to which transformation ends
  1285.      * @param date date of the transform
  1286.      * @param <T> type of the field elements
  1287.      * @return transform between the two frames, avoiding interpolation
  1288.      * @since 9.0
  1289.      */
  1290.     public static <T extends RealFieldElement<T>> FieldTransform<T> getNonInterpolatingTransform(final Frame from, final Frame to,
  1291.                                                                                                  final FieldAbsoluteDate<T> date) {

  1293.         // common ancestor to both frames in the frames tree
  1294.         Frame currentF = from.getDepth() > to.getDepth() ? from.getAncestor(from.getDepth() - to.getDepth()) : from;
  1295.         Frame currentT = from.getDepth() > to.getDepth() ? to : to.getAncestor(to.getDepth() - from.getDepth());
  1296.         while (currentF != currentT) {
  1297.             currentF = currentF.getParent();
  1298.             currentT = currentT.getParent();
  1299.         }
  1300.         final Frame common = currentF;

  1302.         // transform from common to origin
  1303.         FieldTransform<T> commonToOrigin = FieldTransform.getIdentity(date.getField());
  1304.         for (Frame frame = from; frame != common; frame = frame.getParent()) {
  1305.             commonToOrigin = new FieldTransform<>(date,
  1306.                                                    peel(frame.getTransformProvider()).getTransform(date),
  1307.                                                    commonToOrigin);
  1308.         }

  1310.         // transform from destination up to common
  1311.         FieldTransform<T> commonToDestination = FieldTransform.getIdentity(date.getField());
  1312.         for (Frame frame = to; frame != common; frame = frame.getParent()) {
  1313.             commonToDestination = new FieldTransform<>(date,
  1314.                                                        peel(frame.getTransformProvider()).getTransform(date),
  1315.                                                        commonToDestination);
  1316.         }

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

  1321.     }

  1323.     /** Retrieve EOP from a frame hierarchy.
  1324.      * <p>
  1325.      * The frame hierarchy tree is walked from specified frame up to root
  1326.      * goind though parent frames, and the providers are checked to see if they
  1327.      * reference EOP history.the first EOP history found is returned.
  1328.      * </p>
  1329.      * @param start frame from which to start search, will typically be some
  1330.      * Earth related frame, like a topocentric frame or an ITRF frame
  1331.      * @return EOP history found while walking the frames tree, or null if
  1332.      * no EOP history is found
  1333.      * @since 9.1
  1334.      */
  1335.     public static EOPHistory findEOP(final Frame start) {

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

  1339.             TransformProvider peeled = frame.getTransformProvider();

  1341.             boolean peeling = true;
  1342.             while (peeling) {
  1343.                 if (peeled instanceof InterpolatingTransformProvider) {
  1344.                     peeled = ((InterpolatingTransformProvider) peeled).getRawProvider();
  1345.                 } else if (peeled instanceof ShiftingTransformProvider) {
  1346.                     peeled = ((ShiftingTransformProvider) peeled).getRawProvider();
  1347.                 } else if (peeled instanceof EOPBasedTransformProvider &&
  1348.                            ((EOPBasedTransformProvider) peeled).getEOPHistory() != null) {
  1349.                     return ((EOPBasedTransformProvider) peeled).getEOPHistory();
  1350.                 } else {
  1351.                     peeling = false;
  1352.                 }
  1353.             }

  1355.         }

  1357.         // no history found
  1358.         return null;

  1360.     }

  1362.     /** Peel interpolation and shifting from a transform provider.
  1363.      * @param provider transform provider to peel
  1364.      * @return peeled transform provider
  1365.      */
  1366.     private static TransformProvider peel(final TransformProvider provider) {

  1368.         TransformProvider peeled = provider;

  1370.         boolean peeling = true;
  1371.         while (peeling) {
  1372.             if (peeled instanceof InterpolatingTransformProvider) {
  1373.                 peeled = ((InterpolatingTransformProvider) peeled).getRawProvider();
  1374.             } else if (peeled instanceof ShiftingTransformProvider) {
  1375.                 peeled = ((ShiftingTransformProvider) peeled).getRawProvider();
  1376.             } else if (peeled instanceof EOPBasedTransformProvider &&
  1377.                        ((EOPBasedTransformProvider) peeled).getEOPHistory() != null &&
  1378.                        ((EOPBasedTransformProvider) peeled).getEOPHistory().usesInterpolation()) {
  1379.                 peeled = ((EOPBasedTransformProvider) peeled).getNonInterpolatingProvider();
  1380.             } else {
  1381.                 peeling = false;
  1382.             }
  1383.         }

  1385.         return peeled;

  1387.     }

  1389.     /** Local class for different ITRF versions keys.
  1390.      * @since 9.2
  1391.      */
  1392.     private static class ITRFKey implements Serializable {

  1394.         /** Serialized UID. */
  1395.         private static final long serialVersionUID = 20180412L;

  1397.         /** ITRF version. */
  1398.         private final ITRFVersion version;

  1400.         /** IERS conventions to apply. */
  1401.         private final IERSConventions conventions;

  1403.         /** Tidal effects flag. */
  1404.         private final boolean simpleEOP;

  1406.         /** Simple constructor.
  1407.          * @param version ITRF version
  1408.          * @param conventions IERS conventions to apply
  1409.          * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  1410.          */
  1411.         ITRFKey(final ITRFVersion version, final IERSConventions conventions, final boolean simpleEOP) {
  1412.             this.version     = version;
  1413.             this.conventions = conventions;
  1414.             this.simpleEOP   = simpleEOP;
  1415.         }

  1417.         /** {@inheritDoc} */
  1418.         @Override
  1419.         public int hashCode() {
  1420.             return (version.ordinal()     << 5) +
  1421.                    (conventions.ordinal() << 1) +
  1422.                    (simpleEOP ? 0 : 1);
  1423.         }

  1425.         /** {@inheritDoc} */
  1426.         @Override
  1427.         public boolean equals(final Object other) {

  1429.             if (this == other) {
  1430.                 return true;
  1431.             }

  1433.             if (other instanceof ITRFKey) {
  1434.                 final ITRFKey key = (ITRFKey) other;
  1435.                 return version     == key.version     &&
  1436.                        conventions == key.conventions &&
  1437.                        simpleEOP   == key.simpleEOP;
  1438.             }

  1440.             return false;
  1441.         }

  1443.     }

  1445. }
Created with JaCoCo 0.8.2.201808211720