CelestialBodyFactory.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.bodies;

  19. import java.util.ArrayList;
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;

  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.errors.OrekitMessages;

  27. /** Factory class for bodies of the solar system.
  28.  * <p>The {@link #getSun() Sun}, the {@link #getMoon() Moon} and the planets
  29.  * (including the Pluto dwarf planet) are provided by this factory. In addition,
  30.  * two important points are provided for convenience: the {@link
  31.  * #getSolarSystemBarycenter() solar system barycenter} and the {@link
  32.  * #getEarthMoonBarycenter() Earth-Moon barycenter}.</p>
  33.  * <p>The underlying body-centered frames are either direct children of {@link
  34.  * org.orekit.frames.FramesFactory#getEME2000() EME2000} (for {@link #getMoon() Moon}
  35.  * and {@link #getEarthMoonBarycenter() Earth-Moon barycenter}) or children from other
  36.  * body-centered frames. For example, the path from EME2000 to
  37.  * Jupiter-centered frame is: EME2000, Earth-Moon barycenter centered,
  38.  * solar system barycenter centered, Jupiter-centered. The defining transforms
  39.  * of these frames are combinations of simple linear {@link
  40.  * org.orekit.frames.Transform#Transform(org.orekit.time.AbsoluteDate,
  41.  * org.apache.commons.math3.geometry.euclidean.threed.Vector3D,
  42.  * org.apache.commons.math3.geometry.euclidean.threed.Vector3D) translation/velocity} transforms
  43.  * without any rotation. The frame axes are therefore always parallel to
  44.  * {@link org.orekit.frames.FramesFactory#getEME2000() EME2000} frame axes.</p>
  45.  * <p>The position of the bodies provided by this class are interpolated using
  46.  * the JPL DE 405/DE 406 ephemerides.</p>
  47.  * @author Luc Maisonobe
  48.  */
  49. public class CelestialBodyFactory {

  51.     /** Predefined name for solar system barycenter.
  52.      * @see #getBody(String)
  53.      */
  54.     public static final String SOLAR_SYSTEM_BARYCENTER = "solar system barycenter";

  56.     /** Predefined name for Sun.
  57.      * @see #getBody(String)
  58.      */
  59.     public static final String SUN = "Sun";

  61.     /** Predefined name for Mercury.
  62.      * @see #getBody(String)
  63.      */
  64.     public static final String MERCURY = "Mercury";

  66.     /** Predefined name for Venus.
  67.      * @see #getBody(String)
  68.      */
  69.     public static final String VENUS = "Venus";

  71.     /** Predefined name for Earth-Moon barycenter.
  72.      * @see #getBody(String)
  73.      */
  74.     public static final String EARTH_MOON = "Earth-Moon barycenter";

  76.     /** Predefined name for Earth.
  77.      * @see #getBody(String)
  78.      */
  79.     public static final String EARTH = "Earth";

  81.     /** Predefined name for Moon.
  82.      * @see #getBody(String)
  83.      */
  84.     public static final String MOON = "Moon";

  86.     /** Predefined name for Mars.
  87.      * @see #getBody(String)
  88.      */
  89.     public static final String MARS = "Mars";

  91.     /** Predefined name for Jupiter.
  92.      * @see #getBody(String)
  93.      */
  94.     public static final String JUPITER = "Jupiter";

  96.     /** Predefined name for Saturn.
  97.      * @see #getBody(String)
  98.      */
  99.     public static final String SATURN = "Saturn";

  101.     /** Predefined name for Uranus.
  102.      * @see #getBody(String)
  103.      */
  104.     public static final String URANUS = "Uranus";

  106.     /** Predefined name for Neptune.
  107.      * @see #getBody(String)
  108.      */
  109.     public static final String NEPTUNE = "Neptune";

  111.     /** Predefined name for Pluto.
  112.      * @see #getBody(String)
  113.      */
  114.     public static final String PLUTO = "Pluto";

  116.     /** Celestial body loaders map. */
  117.     private static final Map<String, List<CelestialBodyLoader>> LOADERS_MAP =
  118.         new HashMap<String, List<CelestialBodyLoader>>();

  120.     /** Celestial body map. */
  121.     private static final Map<String, CelestialBody> CELESTIAL_BODIES_MAP =
  122.         new HashMap<String, CelestialBody>();

  124.     /** Private constructor.
  125.      * <p>This class is a utility class, it should neither have a public
  126.      * nor a default constructor. This private constructor prevents
  127.      * the compiler from generating one automatically.</p>
  128.      */
  129.     private CelestialBodyFactory() {
  130.     }

  132.     /** Add a loader for celestial bodies.
  133.      * @param name name of the body (may be one of the predefined names or a user-defined name)
  134.      * @param loader custom loader to add for the body
  135.      * @see #addDefaultCelestialBodyLoader(String)
  136.      * @see #clearCelestialBodyLoaders(String)
  137.      * @see #clearCelestialBodyLoaders()
  138.      */
  139.     public static void addCelestialBodyLoader(final String name, final CelestialBodyLoader loader) {
  140.         synchronized (LOADERS_MAP) {
  141.             List<CelestialBodyLoader> loaders = LOADERS_MAP.get(name);
  142.             if (loaders == null) {
  143.                 loaders = new ArrayList<CelestialBodyLoader>();
  144.                 LOADERS_MAP.put(name, loaders);
  145.             }
  146.             loaders.add(loader);
  147.         }
  148.     }

  150.     /** Add the default loaders for all predefined celestial bodies.
  151.      * @param supportedNames regular expression for supported files names
  152.      * (may be null if the default JPL file names are used)
  153.      * <p>
  154.      * The default loaders look for DE405 or DE406 JPL ephemerides.
  155.      * </p>
  156.      * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/unix/de405">DE405 JPL ephemerides</a>
  157.      * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/unix/de406">DE406 JPL ephemerides</a>
  158.      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
  159.      * @see #addDefaultCelestialBodyLoader(String)
  160.      * @see #clearCelestialBodyLoaders(String)
  161.      * @see #clearCelestialBodyLoaders()
  162.      * @exception OrekitException if the header constants cannot be read
  163.      */
  164.     public static void addDefaultCelestialBodyLoader(final String supportedNames)
  165.         throws OrekitException {
  166.         addDefaultCelestialBodyLoader(SOLAR_SYSTEM_BARYCENTER, supportedNames);
  167.         addDefaultCelestialBodyLoader(SUN,                     supportedNames);
  168.         addDefaultCelestialBodyLoader(MERCURY,                 supportedNames);
  169.         addDefaultCelestialBodyLoader(VENUS,                   supportedNames);
  170.         addDefaultCelestialBodyLoader(EARTH_MOON,              supportedNames);
  171.         addDefaultCelestialBodyLoader(EARTH,                   supportedNames);
  172.         addDefaultCelestialBodyLoader(MOON,                    supportedNames);
  173.         addDefaultCelestialBodyLoader(MARS,                    supportedNames);
  174.         addDefaultCelestialBodyLoader(JUPITER,                 supportedNames);
  175.         addDefaultCelestialBodyLoader(SATURN,                  supportedNames);
  176.         addDefaultCelestialBodyLoader(URANUS,                  supportedNames);
  177.         addDefaultCelestialBodyLoader(NEPTUNE,                 supportedNames);
  178.         addDefaultCelestialBodyLoader(PLUTO,                   supportedNames);
  179.     }

  181.     /** Add the default loaders for celestial bodies.
  182.      * @param name name of the body (if not one of the predefined names, the method does nothing)
  183.      * @param supportedNames regular expression for supported files names
  184.      * (may be null if the default JPL file names are used)
  185.      * <p>
  186.      * The default loaders look for DE405 or DE406 JPL ephemerides.
  187.      * </p>
  188.      * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/unix/de405">DE405 JPL ephemerides</a>
  189.      * @see <a href="ftp://ssd.jpl.nasa.gov/pub/eph/planets/unix/de406">DE406 JPL ephemerides</a>
  190.      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
  191.      * @see #addDefaultCelestialBodyLoader(String)
  192.      * @see #clearCelestialBodyLoaders(String)
  193.      * @see #clearCelestialBodyLoaders()
  194.      * @exception OrekitException if the header constants cannot be read
  195.      */
  196.     public static void addDefaultCelestialBodyLoader(final String name, final String supportedNames)
  197.         throws OrekitException {

  199.         CelestialBodyLoader loader = null;
  200.         if (name.equals(SOLAR_SYSTEM_BARYCENTER)) {
  201.             loader =
  202.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.SOLAR_SYSTEM_BARYCENTER);
  203.         } else if (name.equals(SUN)) {
  204.             loader =
  205.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.SUN);
  206.         } else if (name.equals(MERCURY)) {
  207.             loader =
  208.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.MERCURY);
  209.         } else if (name.equals(VENUS)) {
  210.             loader =
  211.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.VENUS);
  212.         } else if (name.equals(EARTH_MOON)) {
  213.             loader =
  214.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.EARTH_MOON);
  215.         } else if (name.equals(EARTH)) {
  216.             loader =
  217.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.EARTH);
  218.         } else if (name.equals(MOON)) {
  219.             loader =
  220.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.MOON);
  221.         } else if (name.equals(MARS)) {
  222.             loader =
  223.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.MARS);
  224.         } else if (name.equals(JUPITER)) {
  225.             loader =
  226.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.JUPITER);
  227.         } else if (name.equals(SATURN)) {
  228.             loader =
  229.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.SATURN);
  230.         } else if (name.equals(URANUS)) {
  231.             loader =
  232.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.URANUS);
  233.         } else if (name.equals(NEPTUNE)) {
  234.             loader =
  235.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.NEPTUNE);
  236.         } else if (name.equals(PLUTO)) {
  237.             loader =
  238.                 new JPLEphemeridesLoader(supportedNames, JPLEphemeridesLoader.EphemerisType.PLUTO);
  239.         }

  241.         if (loader != null) {
  242.             addCelestialBodyLoader(name, loader);
  243.         }

  245.     }

  247.     /** Clear loaders for one celestial body.
  248.      * <p>
  249.      * Calling this method also clears the celestial body that
  250.      * has been loaded via this {@link CelestialBodyLoader}.
  251.      * </p>
  252.      * @param name name of the body
  253.      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
  254.      * @see #clearCelestialBodyLoaders()
  255.      * @see #clearCelestialBodyCache(String)
  256.      */
  257.     public static void clearCelestialBodyLoaders(final String name) {
  258.         // use same synchronization order as in getBody to prevent deadlocks
  259.         synchronized (CELESTIAL_BODIES_MAP) {
  260.             // take advantage of reentrent synchronization as
  261.             // clearCelestialBodyCache uses the same lock inside
  262.             clearCelestialBodyCache(name);

  264.             synchronized (LOADERS_MAP) {
  265.                 LOADERS_MAP.remove(name);
  266.             }
  267.         }
  268.     }

  270.     /** Clear loaders for all celestial bodies.
  271.      * <p>
  272.      * Calling this method also clears all loaded celestial bodies.
  273.      * </p>
  274.      * @see #addCelestialBodyLoader(String, CelestialBodyLoader)
  275.      * @see #clearCelestialBodyLoaders(String)
  276.      * @see #clearCelestialBodyCache()
  277.      */
  278.     public static void clearCelestialBodyLoaders() {
  279.         synchronized (CELESTIAL_BODIES_MAP) {
  280.             clearCelestialBodyCache();

  282.             synchronized (LOADERS_MAP) {
  283.                 LOADERS_MAP.clear();
  284.             }
  285.         }
  286.     }

  288.     /** Clear the specified celestial body from the internal cache.
  289.      * @param name name of the body
  290.      */
  291.     public static void clearCelestialBodyCache(final String name) {
  292.         synchronized (CELESTIAL_BODIES_MAP) {
  293.             CELESTIAL_BODIES_MAP.remove(name);
  294.         }
  295.     }

  297.     /** Clear all loaded celestial bodies.
  298.      * <p>
  299.      * Calling this method will remove all loaded bodies from the internal
  300.      * cache. Subsequent calls to {@link #getBody(String)} or similar methods
  301.      * will result in a reload of the requested body from the configured loader(s).
  302.      * </p>
  303.      */
  304.     public static void clearCelestialBodyCache() {
  305.         synchronized (CELESTIAL_BODIES_MAP) {
  306.             CELESTIAL_BODIES_MAP.clear();
  307.         }
  308.     }

  310.     /** Get the solar system barycenter aggregated body.
  311.      * @return solar system barycenter aggregated body
  312.      * @exception OrekitException if the celestial body cannot be built
  313.      */
  314.     public static CelestialBody getSolarSystemBarycenter() throws OrekitException {
  315.         return getBody(SOLAR_SYSTEM_BARYCENTER);
  316.     }

  318.     /** Get the Sun singleton body.
  319.      * @return Sun body
  320.      * @exception OrekitException if the celestial body cannot be built
  321.      */
  322.     public static CelestialBody getSun() throws OrekitException {
  323.         return getBody(SUN);
  324.     }

  326.     /** Get the Mercury singleton body.
  327.      * @return Sun body
  328.      * @exception OrekitException if the celestial body cannot be built
  329.      */
  330.     public static CelestialBody getMercury() throws OrekitException {
  331.         return getBody(MERCURY);
  332.     }

  334.     /** Get the Venus singleton body.
  335.      * @return Venus body
  336.      * @exception OrekitException if the celestial body cannot be built
  337.      */
  338.     public static CelestialBody getVenus() throws OrekitException {
  339.         return getBody(VENUS);
  340.     }

  342.     /** Get the Earth-Moon barycenter singleton bodies pair.
  343.      * @return Earth-Moon barycenter bodies pair
  344.      * @exception OrekitException if the celestial body cannot be built
  345.      */
  346.     public static CelestialBody getEarthMoonBarycenter() throws OrekitException {
  347.         return getBody(EARTH_MOON);
  348.     }

  350.     /** Get the Earth singleton body.
  351.      * @return Earth body
  352.      * @exception OrekitException if the celestial body cannot be built
  353.      */
  354.     public static CelestialBody getEarth() throws OrekitException {
  355.         return getBody(EARTH);
  356.     }

  358.     /** Get the Moon singleton body.
  359.      * @return Moon body
  360.      * @exception OrekitException if the celestial body cannot be built
  361.      */
  362.     public static CelestialBody getMoon() throws OrekitException {
  363.         return getBody(MOON);
  364.     }

  366.     /** Get the Mars singleton body.
  367.      * @return Mars body
  368.      * @exception OrekitException if the celestial body cannot be built
  369.      */
  370.     public static CelestialBody getMars() throws OrekitException {
  371.         return getBody(MARS);
  372.     }

  374.     /** Get the Jupiter singleton body.
  375.      * @return Jupiter body
  376.      * @exception OrekitException if the celestial body cannot be built
  377.      */
  378.     public static CelestialBody getJupiter() throws OrekitException {
  379.         return getBody(JUPITER);
  380.     }

  382.     /** Get the Saturn singleton body.
  383.      * @return Saturn body
  384.      * @exception OrekitException if the celestial body cannot be built
  385.      */
  386.     public static CelestialBody getSaturn() throws OrekitException {
  387.         return getBody(SATURN);
  388.     }

  390.     /** Get the Uranus singleton body.
  391.      * @return Uranus body
  392.      * @exception OrekitException if the celestial body cannot be built
  393.      */
  394.     public static CelestialBody getUranus() throws OrekitException {
  395.         return getBody(URANUS);
  396.     }

  398.     /** Get the Neptune singleton body.
  399.      * @return Neptune body
  400.      * @exception OrekitException if the celestial body cannot be built
  401.      */
  402.     public static CelestialBody getNeptune() throws OrekitException {
  403.         return getBody(NEPTUNE);
  404.     }

  406.     /** Get the Pluto singleton body.
  407.      * @return Pluto body
  408.      * @exception OrekitException if the celestial body cannot be built
  409.      */
  410.     public static CelestialBody getPluto() throws OrekitException {
  411.         return getBody(PLUTO);
  412.     }

  414.     /** Get a celestial body.
  415.      * <p>
  416.      * If no {@link CelestialBodyLoader} has been added by calling {@link
  417.      * #addCelestialBodyLoader(String, CelestialBodyLoader)
  418.      * addCelestialBodyLoader} or if {@link #clearCelestialBodyLoaders(String)
  419.      * clearCelestialBodyLoaders} has been called afterwards,
  420.      * the {@link #addDefaultCelestialBodyLoader(String, String)
  421.      * addDefaultCelestialBodyLoader} method will be called automatically,
  422.      * once with the default name for JPL DE ephemerides and once with the
  423.      * default name for IMCCE INPOP files.
  424.      * </p>
  425.      * @param name name of the celestial body
  426.      * @return celestial body
  427.      * @exception OrekitException if the celestial body cannot be built
  428.      */
  429.     public static CelestialBody getBody(final String name)
  430.         throws OrekitException {
  431.         synchronized (CELESTIAL_BODIES_MAP) {
  432.             CelestialBody body = CELESTIAL_BODIES_MAP.get(name);
  433.             if (body == null) {
  434.                 synchronized (LOADERS_MAP) {
  435.                     List<CelestialBodyLoader> loaders = LOADERS_MAP.get(name);
  436.                     if ((loaders == null) || loaders.isEmpty()) {
  437.                         addDefaultCelestialBodyLoader(name, JPLEphemeridesLoader.DEFAULT_DE_SUPPORTED_NAMES);
  438.                         addDefaultCelestialBodyLoader(name, JPLEphemeridesLoader.DEFAULT_INPOP_SUPPORTED_NAMES);
  439.                         loaders = LOADERS_MAP.get(name);
  440.                     }
  441.                     OrekitException delayedException = null;
  442.                     for (CelestialBodyLoader loader : loaders) {
  443.                         try {
  444.                             body = loader.loadCelestialBody(name);
  445.                             if (body != null) {
  446.                                 break;
  447.                             }
  448.                         } catch (OrekitException oe) {
  449.                             delayedException = oe;
  450.                         }
  451.                     }
  452.                     if (body == null) {
  453.                         throw (delayedException != null) ?
  454.                               delayedException :
  455.                               new OrekitException(OrekitMessages.NO_DATA_LOADED_FOR_CELESTIAL_BODY, name);
  456.                     }

  458.                 }

  460.                 // save the body
  461.                 CELESTIAL_BODIES_MAP.put(name, body);

  463.             }

  465.             return body;

  467.         }
  468.     }

  470. }
Created with JaCoCo 0.6.3.201306030806