JPLCelestialBody.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.io.Serializable;

  21. import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
  22. import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
  23. import org.apache.commons.math3.util.Precision;
  24. import org.orekit.bodies.JPLEphemeridesLoader.EphemerisType;
  25. import org.orekit.errors.OrekitException;
  26. import org.orekit.frames.Frame;
  27. import org.orekit.frames.Transform;
  28. import org.orekit.frames.TransformProvider;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.utils.PVCoordinates;

  32. /** Implementation of the {@link CelestialBody} interface using JPL or INPOP ephemerides.
  33.  * @author Luc Maisonobe
  34.  */
  35. class JPLCelestialBody implements CelestialBody {

  37.     /** Serializable UID. */
  38.     private static final long serialVersionUID = 3809787672779740923L;

  40.     /** Name of the body. */
  41.     private final String name;

  43.     /** Regular expression for supported files names. */
  44.     private final String supportedNames;

  46.     /** Ephemeris type to generate. */
  47.     private final JPLEphemeridesLoader.EphemerisType generateType;

  49.     /** Raw position-velocity provider. */
  50.     private final transient JPLEphemeridesLoader.RawPVProvider rawPVProvider;

  52.     /** Attraction coefficient of the body (m<sup>3</sup>/s<sup>2</sup>). */
  53.     private final double gm;

  55.     /** Scaling factor for position-velocity. */
  56.     private final double scale;

  58.     /** IAU pole. */
  59.     private final IAUPole iauPole;

  61.     /** Inertially oriented, body-centered frame. */
  62.     private final Frame inertialFrame;

  64.     /** Body oriented, body-centered frame. */
  65.     private final Frame bodyFrame;

  67.     /** Build an instance and the underlying frame.
  68.      * @param name name of the body
  69.      * @param supportedNames regular expression for supported files names
  70.      * @param generateType ephemeris type to generate
  71.      * @param rawPVProvider raw position-velocity provider
  72.      * @param gm attraction coefficient (in m<sup>3</sup>/s<sup>2</sup>)
  73.      * @param scale scaling factor for position-velocity
  74.      * @param iauPole IAU pole implementation
  75.      * @param definingFrameAlignedWithICRF frame in which celestial body coordinates are defined,
  76.      * this frame <strong>must</strong> be aligned with ICRF
  77.      */
  78.     public JPLCelestialBody(final String name, final String supportedNames,
  79.                             final JPLEphemeridesLoader.EphemerisType generateType,
  80.                             final JPLEphemeridesLoader.RawPVProvider rawPVProvider,
  81.                             final double gm, final double scale,
  82.                             final IAUPole iauPole, final Frame definingFrameAlignedWithICRF) {
  83.         this.name           = name;
  84.         this.gm             = gm;
  85.         this.scale          = scale;
  86.         this.supportedNames = supportedNames;
  87.         this.generateType   = generateType;
  88.         this.rawPVProvider  = rawPVProvider;
  89.         this.iauPole        = iauPole;
  90.         this.inertialFrame  = new InertiallyOriented(definingFrameAlignedWithICRF);
  91.         this.bodyFrame      = new BodyOriented();
  92.     }

  94.     /** {@inheritDoc} */
  95.     public PVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame frame)
  96.         throws OrekitException {

  98.         // get raw position-velocity
  99.         final PVCoordinates pv = rawPVProvider.getRawPV(date);

  101.         // the raw PV are relative to the parent of the body centered inertially oriented frame
  102.         final Transform transform = getInertiallyOrientedFrame().getParent().getTransformTo(frame, date);

  104.         // apply the scale factor
  105.         return new PVCoordinates(scale, transform.transformPVCoordinates(pv));

  107.     }

  109.     /** Replace the instance with a data transfer object for serialization.
  110.      * <p>
  111.      * This intermediate class serializes the files supported names, the ephemeris type
  112.      * and the body name.
  113.      * </p>
  114.      * @return data transfer object that will be serialized
  115.      */
  116.     private Object writeReplace() {
  117.         return new DTOCelestialBody(supportedNames, generateType, name);
  118.     }

  120.     /** {@inheritDoc} */
  121.     public String getName() {
  122.         return name;
  123.     }

  125.     /** {@inheritDoc} */
  126.     public double getGM() {
  127.         return gm;
  128.     }

  130.     /** {@inheritDoc} */
  131.     @Deprecated
  132.     public Frame getFrame() {
  133.         return inertialFrame;
  134.     }

  136.     /** {@inheritDoc} */
  137.     public Frame getInertiallyOrientedFrame() {
  138.         return inertialFrame;
  139.     }

  141.     /** {@inheritDoc} */
  142.     public Frame getBodyOrientedFrame() {
  143.         return bodyFrame;
  144.     }

  146.    /** Inertially oriented body centered frame. */
  147.     private class InertiallyOriented extends Frame {

  149.         /** Serializable UID. */
  150.         private static final long serialVersionUID = -8849993808761896559L;

  152.         /** Suffix for inertial frame name. */
  153.         private static final String INERTIAL_FRAME_SUFFIX = "/inertial";

  155.         /** Simple constructor.
  156.          * @param definingFrame frame in which celestial body coordinates are defined
  157.          */
  158.         public InertiallyOriented(final Frame definingFrame) {
  159.             super(definingFrame, new TransformProvider() {

  161.                 /** Serializable UID. */
  162.                 private static final long serialVersionUID = -8610328386110652400L;

  164.                 /** {@inheritDoc} */
  165.                 public Transform getTransform(final AbsoluteDate date) throws OrekitException {

  167.                     // compute translation from parent frame to self
  168.                     final PVCoordinates pv = getPVCoordinates(date, definingFrame);
  169.                     final Transform translation = new Transform(date, pv.negate());

  171.                     // compute rotation from ICRF frame to self,
  172.                     // as per the "Report of the IAU/IAG Working Group on Cartographic
  173.                     // Coordinates and Rotational Elements of the Planets and Satellites"
  174.                     // These definitions are common for all recent versions of this report
  175.                     // published every three years, the precise values of pole direction
  176.                     // and W angle coefficients may vary from publication year as models are
  177.                     // adjusted. These coefficients are not in this class, they are in the
  178.                     // specialized classes that do implement the getPole and getPrimeMeridianAngle
  179.                     // methods
  180.                     final Vector3D pole  = iauPole.getPole(date);
  181.                     Vector3D qNode = Vector3D.crossProduct(Vector3D.PLUS_K, pole);
  182.                     if (qNode.getNormSq() < Precision.SAFE_MIN) {
  183.                         qNode = Vector3D.PLUS_I;
  184.                     }
  185.                     final Transform rotation =
  186.                             new Transform(date, new Rotation(pole, qNode, Vector3D.PLUS_K, Vector3D.PLUS_I));

  188.                     // update transform from parent to self
  189.                     return new Transform(date, translation, rotation);

  191.                 }

  193.             }, name + INERTIAL_FRAME_SUFFIX, true);
  194.         }

  196.         /** Replace the instance with a data transfer object for serialization.
  197.          * <p>
  198.          * This intermediate class serializes the files supported names, the ephemeris type
  199.          * and the body name.
  200.          * </p>
  201.          * @return data transfer object that will be serialized
  202.          */
  203.         private Object writeReplace() {
  204.             return new DTOInertialFrame(supportedNames, generateType, name);
  205.         }

  207.     }

  209.     /** Body oriented body centered frame. */
  210.     private class BodyOriented extends Frame {

  212.         /** Serializable UID. */
  213.         private static final long serialVersionUID = -2286454820784307274L;

  215.         /** Suffix for body frame name. */
  216.         private static final String BODY_FRAME_SUFFIX = "/rotating";

  218.         /** Simple constructor.
  219.          */
  220.         public BodyOriented() {
  221.             super(inertialFrame, new TransformProvider() {

  223.                 /** Serializable UID. */
  224.                 private static final long serialVersionUID = 5973062576520917181L;

  226.                 /** {@inheritDoc} */
  227.                 public Transform getTransform(final AbsoluteDate date) throws OrekitException {
  228.                     final double dt = 10.0;
  229.                     final double w0 = iauPole.getPrimeMeridianAngle(date);
  230.                     final double w1 = iauPole.getPrimeMeridianAngle(date.shiftedBy(dt));
  231.                     return new Transform(date,
  232.                                          new Rotation(Vector3D.PLUS_K, -w0),
  233.                                          new Vector3D((w1 - w0) / dt, Vector3D.PLUS_K));
  234.                 }

  236.             }, name + BODY_FRAME_SUFFIX, false);
  237.         };

  239.         /** Replace the instance with a data transfer object for serialization.
  240.          * <p>
  241.          * This intermediate class serializes the files supported names, the ephemeris type
  242.          * and the body name.
  243.          * </p>
  244.          * @return data transfer object that will be serialized
  245.          */
  246.         private Object writeReplace() {
  247.             return new DTOBodyFrame(supportedNames, generateType, name);
  248.         }

  250.     }

  252.     /** Internal class used only for serialization. */
  253.     private abstract static class DataTransferObject implements Serializable {

  255.         /** Serializable UID. */
  256.         private static final long serialVersionUID = 674742836536072422L;

  258.         /** Regular expression for supported files names. */
  259.         private final String supportedNames;

  261.         /** Ephemeris type to generate. */
  262.         private final EphemerisType generateType;

  264.         /** Name of the body. */
  265.         private final String name;

  267.         /** Simple constructor.
  268.          * @param supportedNames regular expression for supported files names
  269.          * @param generateType ephemeris type to generate
  270.          * @param name name of the body
  271.          */
  272.         public DataTransferObject(final String supportedNames, final EphemerisType generateType, final String name) {
  273.             this.supportedNames = supportedNames;
  274.             this.generateType   = generateType;
  275.             this.name           = name;
  276.         }

  278.         /** Get the body associated with the serialized data.
  279.          * @return body associated with the serialized data
  280.          */
  281.         protected JPLCelestialBody getBody() {

  283.             try {
  284.                 // first try to use the factory, in order to avoid building a new instance
  285.                 // each time we deserialize and have the object properly cached
  286.                 final CelestialBody factoryProvided = CelestialBodyFactory.getBody(name);
  287.                 if (factoryProvided instanceof JPLCelestialBody) {
  288.                     final JPLCelestialBody jplBody = (JPLCelestialBody) factoryProvided;
  289.                     if (supportedNames.equals(jplBody.supportedNames) && generateType == jplBody.generateType) {
  290.                         // the factory created exactly the object we needed, just return it
  291.                         return jplBody;
  292.                     }
  293.                 }

  295.                 // the factory does not return the object we want
  296.                 // we create a new one from scratch and don't cache it
  297.                 return (JPLCelestialBody) new JPLEphemeridesLoader(supportedNames, generateType).loadCelestialBody(name);

  299.             } catch (OrekitException oe) {
  300.                 throw OrekitException.createInternalError(oe);
  301.             }

  303.         }

  305.     }

  307.     /** Specialization of the data transfer object for complete celestial body serialization. */
  308.     private static class DTOCelestialBody extends DataTransferObject {

  310.         /** Serializable UID. */
  311.         private static final long serialVersionUID = -8287341529741045958L;

  313.         /** Simple constructor.
  314.          * @param supportedNames regular expression for supported files names
  315.          * @param generateType ephemeris type to generate
  316.          * @param name name of the body
  317.          */
  318.         public DTOCelestialBody(final String supportedNames, final EphemerisType generateType, final String name) {
  319.             super(supportedNames, generateType, name);
  320.         }

  322.         /** Replace the deserialized data transfer object with a {@link JPLCelestialBody}.
  323.          * @return replacement {@link JPLCelestialBody}
  324.          */
  325.         private Object readResolve() {
  326.             return getBody();
  327.         }

  329.     }

  331.     /** Specialization of the data transfer object for inertially oriented frame serialization. */
  332.     private static class DTOInertialFrame extends DataTransferObject {

  334.         /** Serializable UID. */
  335.         private static final long serialVersionUID = 7915071664444154948L;

  337.         /** Simple constructor.
  338.          * @param supportedNames regular expression for supported files names
  339.          * @param generateType ephemeris type to generate
  340.          * @param name name of the body
  341.          */
  342.         public DTOInertialFrame(final String supportedNames, final EphemerisType generateType, final String name) {
  343.             super(supportedNames, generateType, name);
  344.         }

  346.         /** Replace the deserialized data transfer object with a {@link Frame}.
  347.          * @return replacement {@link Frame}
  348.          */
  349.         private Object readResolve() {
  350.             return getBody().inertialFrame;
  351.         }

  353.     }

  355.     /** Specialization of the data transfer object for body oriented frame serialization. */
  356.     private static class DTOBodyFrame extends DataTransferObject {

  358.         /** Serializable UID. */
  359.         private static final long serialVersionUID = -3194195019557081000L;

  361.         /** Simple constructor.
  362.          * @param supportedNames regular expression for supported files names
  363.          * @param generateType ephemeris type to generate
  364.          * @param name name of the body
  365.          */
  366.         public DTOBodyFrame(final String supportedNames, final EphemerisType generateType, final String name) {
  367.             super(supportedNames, generateType, name);
  368.         }

  370.         /** Replace the deserialized data transfer object with a {@link Frame}.
  371.          * @return replacement {@link Frame}
  372.          */
  373.         private Object readResolve() {
  374.             return getBody().bodyFrame;
  375.         }

  377.     }

  379. }
Created with JaCoCo 0.6.3.201306030806