TimeScalesFactory.java

  1. /* Copyright 2002-2013 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.time;

  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.SortedMap;
  25. import java.util.TreeMap;

  27. import org.orekit.data.DataProvidersManager;
  28. import org.orekit.errors.OrekitException;
  29. import org.orekit.errors.OrekitMessages;
  30. import org.orekit.frames.EOPHistory;
  31. import org.orekit.frames.FramesFactory;
  32. import org.orekit.utils.IERSConventions;

  34. /** Factory for predefined time scales.
  35.  * <p>
  36.  * This is a utility class, so its constructor is private.
  37.  * </p>
  38.  * @author Luc Maisonobe
  39.  */
  40. public class TimeScalesFactory implements Serializable {

  42.     /** Serializable UID. */
  43.     private static final long serialVersionUID = 20130807L;

  45.     /** International Atomic Time scale. */
  46.     private static TAIScale tai = null;

  48.     /** Universal Time Coordinate scale. */
  49.     private static UTCScale utc = null;

  51.     /** Universal Time 1 scale (tidal effects ignored). */
  52.     private static Map<IERSConventions, UT1Scale> ut1MapSimpleEOP = new HashMap<IERSConventions, UT1Scale>();

  54.     /** Universal Time 1 scale (tidal effects considered). */
  55.     private static Map<IERSConventions, UT1Scale> ut1MapCompleteEOP = new HashMap<IERSConventions, UT1Scale>();

  57.     /** Terrestrial Time scale. */
  58.     private static TTScale tt = null;

  60.     /** Galileo System Time scale. */
  61.     private static GalileoScale gst = null;

  63.     /** Global Positioning System scale. */
  64.     private static GPSScale gps = null;

  66.     /** Geocentric Coordinate Time scale. */
  67.     private static TCGScale tcg = null;

  69.     /** Barycentric Dynamic Time scale. */
  70.     private static TDBScale tdb = null;

  72.     /** Barycentric Coordinate Time scale. */
  73.     private static TCBScale tcb = null;

  75.     /** Greenwich Mean Sidereal Time scale. */
  76.     private static GMSTScale gmst = null;

  78.     /** UTCTAI offsets loaders. */
  79.     private static List<UTCTAILoader> loaders = new ArrayList<UTCTAILoader>();

  81.     /** Private constructor.
  82.      * <p>This class is a utility class, it should neither have a public
  83.      * nor a default constructor. This private constructor prevents
  84.      * the compiler from generating one automatically.</p>
  85.      */
  86.     private TimeScalesFactory() {
  87.     }

  89.     /** Add a loader for UTC-TAI offsets history files.
  90.      * @param loader custom loader to add
  91.      * @see #getUTC()
  92.      * @see #clearUTCTAILoaders()
  93.      */
  94.     public static void addUTCTAILoader(final UTCTAILoader loader) {
  95.         loaders.add(loader);
  96.     }

  98.     /** Add the default loader for UTC-TAI offsets history files.
  99.      * <p>
  100.      * The default loader looks for a file named {@code UTC-TAI.history}
  101.      * that must be in the IERS format.
  102.      * </p>
  103.      * @see <a href="http://hpiers.obspm.fr/eoppc/bul/bulc/UTC-TAI.history">IERS UTC-TAI.history file</a>
  104.      * @see #getUTC()
  105.      * @see #clearUTCTAILoaders()
  106.      */
  107.     public static void addDefaultUTCTAILoader() {
  108.         addUTCTAILoader(new UTCTAIHistoryFilesLoader());
  109.     }

  111.     /** Clear loaders for UTC-TAI offsets history files.
  112.      * @see #getUTC()
  113.      * @see #addUTCTAILoader(UTCTAILoader)
  114.      * @see #addDefaultUTCTAILoader()
  115.      */
  116.     public static void clearUTCTAILoaders() {
  117.         loaders.clear();
  118.     }

  120.     /** Get the International Atomic Time scale.
  121.      * @return International Atomic Time scale
  122.      */
  123.     public static TAIScale getTAI() {
  124.         synchronized (TimeScalesFactory.class) {

  126.             if (tai == null) {
  127.                 tai = new TAIScale();
  128.             }

  130.             return tai;

  132.         }
  133.     }

  135.     /** Get the Universal Time Coordinate scale.
  136.      * <p>
  137.      * If no {@link UTCTAILoader} has been added by calling {@link
  138.      * #addUTCTAILoader(UTCTAILoader) addUTCTAILoader} or if {@link
  139.      * #clearUTCTAILoaders() clearUTCTAILoaders} has been called afterwards,
  140.      * the {@link #addDefaultUTCTAILoader() addDefaultUTCTAILoader} method
  141.      * will be called automatically.
  142.      * </p>
  143.      * @return Universal Time Coordinate scale
  144.      * @exception OrekitException if some data can't be read or some
  145.      * file content is corrupted
  146.      * @see #addUTCTAILoader(UTCTAILoader)
  147.      * @see #clearUTCTAILoaders()
  148.      * @see #addDefaultUTCTAILoader()
  149.      */
  150.     public static UTCScale getUTC() throws OrekitException {
  151.         synchronized (TimeScalesFactory.class) {

  153.             if (utc == null) {
  154.                 SortedMap<DateComponents, Integer> entries =
  155.                     new TreeMap<DateComponents, Integer>();
  156.                 boolean loaded = false;
  157.                 if (loaders.isEmpty()) {
  158.                     addDefaultUTCTAILoader();
  159.                 }
  160.                 for (UTCTAILoader loader : loaders) {
  161.                     DataProvidersManager.getInstance().feed(loader.getSupportedNames(), loader);
  162.                     if (!loader.stillAcceptsData()) {
  163.                         entries = loader.loadTimeSteps();
  164.                         loaded = true;
  165.                     }
  166.                 }
  167.                 if (!loaded) {
  168.                     throw new OrekitException(OrekitMessages.NO_IERS_UTC_TAI_HISTORY_DATA_LOADED);
  169.                 }
  170.                 utc = new UTCScale(entries);
  171.             }

  173.             return utc;
  174.         }
  175.     }

  177.     /** Get the Universal Time 1 scale.
  178.      * @return Universal Time 1 scale
  179.      * @exception OrekitException if some data can't be read or some
  180.      * file content is corrupted
  181.      * @see #getUTC()
  182.      * @see FramesFactory#getEOPHistory(IERSConventions, boolean)
  183.      * @deprecated as of 6.1 replaced with {@link #getUT1(IERSConventions, boolean)}
  184.      */
  185.     @Deprecated
  186.     public static UT1Scale getUT1() throws OrekitException {
  187.         return getUT1(IERSConventions.IERS_2010, true);
  188.     }

  190.     /** Get the Universal Time 1 scale.
  191.      * <p>
  192.      * UT1 scale depends on both UTC scale and Earth Orientation Parameters,
  193.      * so this method loads these data sets. See the {@link #getUTC()
  194.      * TimeScalesFactory.getUTC()} and {@link
  195.      * FramesFactory#getEOPHistory(IERSConventions, boolean)} methods
  196.      * for an explanation of how the corresponding data loaders can be configured.
  197.      * </p>
  198.      * @param conventions IERS conventions for which EOP parameters will provide dUT1
  199.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  200.      * @return Universal Time 1 scale
  201.      * @exception OrekitException if some data can't be read or some
  202.      * file content is corrupted
  203.      * @see #getUTC()
  204.      * @see FramesFactory#getEOPHistory(IERSConventions, boolean)
  205.      */
  206.     public static UT1Scale getUT1(final IERSConventions conventions, final boolean simpleEOP)
  207.         throws OrekitException {
  208.         synchronized (TimeScalesFactory.class) {

  210.             final Map<IERSConventions, UT1Scale> map =
  211.                     simpleEOP ? ut1MapSimpleEOP : ut1MapCompleteEOP;
  212.             UT1Scale ut1 = map.get(conventions);
  213.             if (ut1 == null) {
  214.                 ut1 = getUT1(FramesFactory.getEOPHistory(conventions, simpleEOP));
  215.                 map.put(conventions, ut1);
  216.             }
  217.             return ut1;
  218.         }
  219.     }

  221.     /** Get the Universal Time 1 scale.
  222.      * <p>
  223.      * As this method allow associating any history with the time scale,
  224.      * it may involve large data sets. So this method does <em>not</em>
  225.      * cache the resulting {@link UT1Scale UT1Scale} instance, a new
  226.      * instance will be returned each time. In order to avoid wasting
  227.      * memory, calling {@link #getUT1(IERSConventions, boolean)}
  228.      * with the single enumerate corresponding to the conventions may be
  229.      * a better solution. This method is made available only for expert use.
  230.      * </p>
  231.      * @param history EOP parameters providing dUT1
  232.      * (may be null if no correction is desired)
  233.      * @return Universal Time 1 scale
  234.      * @exception OrekitException if some data can't be read or some
  235.      * file content is corrupted
  236.      * @see #getUT1(IERSConventions, boolean)
  237.      */
  238.     public static UT1Scale getUT1(final EOPHistory history) throws OrekitException {
  239.         return new UT1Scale(history, getUTC());
  240.     }

  242.     /** Get the Terrestrial Time scale.
  243.      * @return Terrestrial Time scale
  244.      */
  245.     public static TTScale getTT() {
  246.         synchronized (TimeScalesFactory.class) {

  248.             if (tt == null) {
  249.                 tt = new TTScale();
  250.             }

  252.             return tt;

  254.         }
  255.     }

  257.     /** Get the Galileo System Time scale.
  258.      * @return Galileo System Time scale
  259.      */
  260.     public static GalileoScale getGST() {
  261.         synchronized (TimeScalesFactory.class) {

  263.             if (gst == null) {
  264.                 gst = new GalileoScale();
  265.             }

  267.             return gst;

  269.         }
  270.     }

  272.     /** Get the Global Positioning System scale.
  273.      * @return Global Positioning System scale
  274.      */
  275.     public static GPSScale getGPS() {
  276.         synchronized (TimeScalesFactory.class) {

  278.             if (gps == null) {
  279.                 gps = new GPSScale();
  280.             }

  282.             return gps;

  284.         }
  285.     }

  287.     /** Get the Geocentric Coordinate Time scale.
  288.      * @return Geocentric Coordinate Time scale
  289.      */
  290.     public static TCGScale getTCG() {
  291.         synchronized (TimeScalesFactory.class) {

  293.             if (tcg == null) {
  294.                 tcg = new TCGScale();
  295.             }

  297.             return tcg;

  299.         }
  300.     }

  302.     /** Get the Barycentric Dynamic Time scale.
  303.      * @return Barycentric Dynamic Time scale
  304.      */
  305.     public static TDBScale getTDB() {
  306.         synchronized (TimeScalesFactory.class) {

  308.             if (tdb == null) {
  309.                 tdb = new TDBScale();
  310.             }

  312.             return tdb;

  314.         }
  315.     }

  317.     /** Get the Barycentric Coordinate Time scale.
  318.      * @return Barycentric Coordinate Time scale
  319.      */
  320.     public static TCBScale getTCB() {
  321.         synchronized (TimeScalesFactory.class) {

  323.             if (tcb == null) {
  324.                 tcb = new TCBScale(getTDB());
  325.             }

  327.             return tcb;

  329.         }
  330.     }

  332.     /** Get the Greenwich Mean Sidereal Time scale.
  333.      * @return Greenwich Mean Sidereal Time scale
  334.      * @exception OrekitException if some data can't be read or some
  335.      * file content is corrupted
  336.      */
  337.     public static GMSTScale getGMST() throws OrekitException {
  338.         synchronized (TimeScalesFactory.class) {

  340.             if (gmst == null) {
  341.                 gmst = new GMSTScale(getUT1());
  342.             }

  344.             return gmst;

  346.         }
  347.     }

  349. }
Created with JaCoCo 0.6.3.201306030806