JPLCelestialBody.java

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

  19. import java.io.Serializable;

  21. import org.hipparchus.RealFieldElement;
  22. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  23. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  24. import org.hipparchus.geometry.euclidean.threed.Rotation;
  25. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  26. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  27. import org.hipparchus.util.Precision;
  28. import org.orekit.bodies.JPLEphemeridesLoader.EphemerisType;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitInternalError;
  31. import org.orekit.frames.FieldTransform;
  32. import org.orekit.frames.Frame;
  33. import org.orekit.frames.Transform;
  34. import org.orekit.frames.TransformProvider;
  35. import org.orekit.time.AbsoluteDate;
  36. import org.orekit.time.FieldAbsoluteDate;
  37. import org.orekit.utils.FieldPVCoordinates;
  38. import org.orekit.utils.PVCoordinates;
  39. import org.orekit.utils.TimeStampedFieldPVCoordinates;
  40. import org.orekit.utils.TimeStampedPVCoordinates;

  42. /** Implementation of the {@link CelestialBody} interface using JPL or INPOP ephemerides.
  43.  * @author Luc Maisonobe
  44.  */
  45. class JPLCelestialBody implements CelestialBody {

  47.     /** Serializable UID. */
  48.     private static final long serialVersionUID = 3809787672779740923L;

  50.     /** Name of the body. */
  51.     private final String name;

  53.     /** Regular expression for supported files names. */
  54.     private final String supportedNames;

  56.     /** Ephemeris type to generate. */
  57.     private final JPLEphemeridesLoader.EphemerisType generateType;

  59.     /** Raw position-velocity provider. */
  60.     private final transient JPLEphemeridesLoader.RawPVProvider rawPVProvider;

  62.     /** Attraction coefficient of the body (m³/s²). */
  63.     private final double gm;

  65.     /** Scaling factor for position-velocity. */
  66.     private final double scale;

  68.     /** IAU pole. */
  69.     private final IAUPole iauPole;

  71.     /** Inertially oriented, body-centered frame. */
  72.     private final Frame inertialFrame;

  74.     /** Body oriented, body-centered frame. */
  75.     private final Frame bodyFrame;

  77.     /** Build an instance and the underlying frame.
  78.      * @param name name of the body
  79.      * @param supportedNames regular expression for supported files names
  80.      * @param generateType ephemeris type to generate
  81.      * @param rawPVProvider raw position-velocity provider
  82.      * @param gm attraction coefficient (in m³/s²)
  83.      * @param scale scaling factor for position-velocity
  84.      * @param iauPole IAU pole implementation
  85.      * @param definingFrameAlignedWithICRF frame in which celestial body coordinates are defined,
  86.      * this frame <strong>must</strong> be aligned with ICRF
  87.      */
  88.     JPLCelestialBody(final String name, final String supportedNames,
  89.                      final JPLEphemeridesLoader.EphemerisType generateType,
  90.                      final JPLEphemeridesLoader.RawPVProvider rawPVProvider,
  91.                      final double gm, final double scale,
  92.                      final IAUPole iauPole, final Frame definingFrameAlignedWithICRF) {
  93.         this.name           = name;
  94.         this.gm             = gm;
  95.         this.scale          = scale;
  96.         this.supportedNames = supportedNames;
  97.         this.generateType   = generateType;
  98.         this.rawPVProvider  = rawPVProvider;
  99.         this.iauPole        = iauPole;
  100.         this.inertialFrame  = new InertiallyOriented(definingFrameAlignedWithICRF);
  101.         this.bodyFrame      = new BodyOriented();
  102.     }

  104.     /** {@inheritDoc} */
  105.     public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame frame)
  106.         throws OrekitException {

  108.         // apply the scale factor to raw position-velocity
  109.         final PVCoordinates rawPV    = rawPVProvider.getRawPV(date);
  110.         final TimeStampedPVCoordinates scaledPV = new TimeStampedPVCoordinates(date, scale, rawPV);

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

  115.         // convert to requested frame
  116.         return transform.transformPVCoordinates(scaledPV);

  118.     }

  120.     /** Get the {@link FieldPVCoordinates} of the body in the selected frame.
  121.      * @param date current date
  122.      * @param frame the frame where to define the position
  123.      * @param <T> type fo the field elements
  124.      * @return time-stamped position/velocity of the body (m and m/s)
  125.      * @exception OrekitException if position cannot be computed in given frame
  126.      */
  127.     public <T extends RealFieldElement<T>> TimeStampedFieldPVCoordinates<T> getPVCoordinates(final FieldAbsoluteDate<T> date,
  128.                                                                                              final Frame frame)
  129.         throws OrekitException {

  131.         // apply the scale factor to raw position-velocity
  132.         final FieldPVCoordinates<T> rawPV    = rawPVProvider.getRawPV(date);
  133.         final TimeStampedFieldPVCoordinates<T> scaledPV = new TimeStampedFieldPVCoordinates<>(date, scale, rawPV);

  135.         // the raw PV are relative to the parent of the body centered inertially oriented frame
  136.         final FieldTransform<T> transform = getInertiallyOrientedFrame().getParent().getTransformTo(frame, date);

  138.         // convert to requested frame
  139.         return transform.transformPVCoordinates(scaledPV);

  141.     }

  143.     /** Replace the instance with a data transfer object for serialization.
  144.      * <p>
  145.      * This intermediate class serializes the files supported names, the ephemeris type
  146.      * and the body name.
  147.      * </p>
  148.      * @return data transfer object that will be serialized
  149.      */
  150.     private Object writeReplace() {
  151.         return new DTOCelestialBody(supportedNames, generateType, name);
  152.     }

  154.     /** {@inheritDoc} */
  155.     public String getName() {
  156.         return name;
  157.     }

  159.     /** {@inheritDoc} */
  160.     public double getGM() {
  161.         return gm;
  162.     }

  164.     /** {@inheritDoc} */
  165.     public Frame getInertiallyOrientedFrame() {
  166.         return inertialFrame;
  167.     }

  169.     /** {@inheritDoc} */
  170.     public Frame getBodyOrientedFrame() {
  171.         return bodyFrame;
  172.     }

  174.    /** Inertially oriented body centered frame. */
  175.     private class InertiallyOriented extends Frame {

  177.         /** Serializable UID. */
  178.         private static final long serialVersionUID = -8849993808761896559L;

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

  183.         /** Simple constructor.
  184.          * @param definingFrame frame in which celestial body coordinates are defined
  185.          */
  186.         InertiallyOriented(final Frame definingFrame) {
  187.             super(definingFrame, new TransformProvider() {

  189.                 /** Serializable UID. */
  190.                 private static final long serialVersionUID = -8610328386110652400L;

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

  195.                     // compute translation from parent frame to self
  196.                     final PVCoordinates pv = getPVCoordinates(date, definingFrame);
  197.                     final Transform translation = new Transform(date, pv.negate());

  199.                     // compute rotation from ICRF frame to self,
  200.                     // as per the "Report of the IAU/IAG Working Group on Cartographic
  201.                     // Coordinates and Rotational Elements of the Planets and Satellites"
  202.                     // These definitions are common for all recent versions of this report
  203.                     // published every three years, the precise values of pole direction
  204.                     // and W angle coefficients may vary from publication year as models are
  205.                     // adjusted. These coefficients are not in this class, they are in the
  206.                     // specialized classes that do implement the getPole and getPrimeMeridianAngle
  207.                     // methods
  208.                     final Vector3D pole  = iauPole.getPole(date);
  209.                     final Vector3D qNode = iauPole.getNode(date);
  210.                     final Transform rotation =
  211.                             new Transform(date, new Rotation(pole, qNode, Vector3D.PLUS_K, Vector3D.PLUS_I));

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

  216.                 }

  218.                 /** {@inheritDoc} */
  219.                 public <T extends RealFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date)
  220.                     throws OrekitException {

  222.                     // compute translation from parent frame to self
  223.                     final FieldPVCoordinates<T> pv = getPVCoordinates(date, definingFrame);
  224.                     final FieldTransform<T> translation = new FieldTransform<>(date, pv.negate());

  226.                     // compute rotation from ICRF frame to self,
  227.                     // as per the "Report of the IAU/IAG Working Group on Cartographic
  228.                     // Coordinates and Rotational Elements of the Planets and Satellites"
  229.                     // These definitions are common for all recent versions of this report
  230.                     // published every three years, the precise values of pole direction
  231.                     // and W angle coefficients may vary from publication year as models are
  232.                     // adjusted. These coefficients are not in this class, they are in the
  233.                     // specialized classes that do implement the getPole and getPrimeMeridianAngle
  234.                     // methods
  235.                     final FieldVector3D<T> pole  = iauPole.getPole(date);
  236.                     FieldVector3D<T> qNode = FieldVector3D.crossProduct(Vector3D.PLUS_K, pole);
  237.                     if (qNode.getNormSq().getReal() < Precision.SAFE_MIN) {
  238.                         qNode = FieldVector3D.getPlusI(date.getField());
  239.                     }
  240.                     final FieldTransform<T> rotation =
  241.                             new FieldTransform<>(date,
  242.                                                  new FieldRotation<>(pole,
  243.                                                                      qNode,
  244.                                                                      FieldVector3D.getPlusK(date.getField()),
  245.                                                                      FieldVector3D.getPlusI(date.getField())));

  247.                     // update transform from parent to self
  248.                     return new FieldTransform<>(date, translation, rotation);

  250.                 }

  252.             }, name + INERTIAL_FRAME_SUFFIX, true);
  253.         }

  255.         /** Replace the instance with a data transfer object for serialization.
  256.          * <p>
  257.          * This intermediate class serializes the files supported names, the ephemeris type
  258.          * and the body name.
  259.          * </p>
  260.          * @return data transfer object that will be serialized
  261.          */
  262.         private Object writeReplace() {
  263.             return new DTOInertialFrame(supportedNames, generateType, name);
  264.         }

  266.     }

  268.     /** Body oriented body centered frame. */
  269.     private class BodyOriented extends Frame {

  271.         /** Serializable UID. */
  272.         private static final long serialVersionUID = 20170109L;

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

  277.         /** Simple constructor.
  278.          */
  279.         BodyOriented() {
  280.             super(inertialFrame, new TransformProvider() {

  282.                 /** Serializable UID. */
  283.                 private static final long serialVersionUID = 20170109L;

  285.                 /** {@inheritDoc} */
  286.                 public Transform getTransform(final AbsoluteDate date) throws OrekitException {
  287.                     final double dt = 10.0;
  288.                     final double w0 = iauPole.getPrimeMeridianAngle(date);
  289.                     final double w1 = iauPole.getPrimeMeridianAngle(date.shiftedBy(dt));
  290.                     return new Transform(date,
  291.                                          new Rotation(Vector3D.PLUS_K, w0, RotationConvention.FRAME_TRANSFORM),
  292.                                          new Vector3D((w1 - w0) / dt, Vector3D.PLUS_K));
  293.                 }

  295.                 /** {@inheritDoc} */
  296.                 public <T extends RealFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date)
  297.                     throws OrekitException {
  298.                     final double dt = 10.0;
  299.                     final T w0 = iauPole.getPrimeMeridianAngle(date);
  300.                     final T w1 = iauPole.getPrimeMeridianAngle(date.shiftedBy(dt));
  301.                     return new FieldTransform<>(date,
  302.                                                 new FieldRotation<>(FieldVector3D.getPlusK(date.getField()), w0,
  303.                                                                     RotationConvention.FRAME_TRANSFORM),
  304.                                                 new FieldVector3D<>(w1.subtract(w0).divide(dt), Vector3D.PLUS_K));
  305.                 }

  307.             }, name + BODY_FRAME_SUFFIX, false);
  308.         }

  310.         /** Replace the instance with a data transfer object for serialization.
  311.          * <p>
  312.          * This intermediate class serializes the files supported names, the ephemeris type
  313.          * and the body name.
  314.          * </p>
  315.          * @return data transfer object that will be serialized
  316.          */
  317.         private Object writeReplace() {
  318.             return new DTOBodyFrame(supportedNames, generateType, name);
  319.         }

  321.     }

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

  326.         /** Serializable UID. */
  327.         private static final long serialVersionUID = 674742836536072422L;

  329.         /** Regular expression for supported files names. */
  330.         private final String supportedNames;

  332.         /** Ephemeris type to generate. */
  333.         private final EphemerisType generateType;

  335.         /** Name of the body. */
  336.         private final String name;

  338.         /** Simple constructor.
  339.          * @param supportedNames regular expression for supported files names
  340.          * @param generateType ephemeris type to generate
  341.          * @param name name of the body
  342.          */
  343.         DataTransferObject(final String supportedNames, final EphemerisType generateType, final String name) {
  344.             this.supportedNames = supportedNames;
  345.             this.generateType   = generateType;
  346.             this.name           = name;
  347.         }

  349.         /** Get the body associated with the serialized data.
  350.          * @return body associated with the serialized data
  351.          */
  352.         protected JPLCelestialBody getBody() {

  354.             try {
  355.                 // first try to use the factory, in order to avoid building a new instance
  356.                 // each time we deserialize and have the object properly cached
  357.                 final CelestialBody factoryProvided = CelestialBodyFactory.getBody(name);
  358.                 if (factoryProvided instanceof JPLCelestialBody) {
  359.                     final JPLCelestialBody jplBody = (JPLCelestialBody) factoryProvided;
  360.                     if (supportedNames.equals(jplBody.supportedNames) && generateType == jplBody.generateType) {
  361.                         // the factory created exactly the object we needed, just return it
  362.                         return jplBody;
  363.                     }
  364.                 }

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

  370.             } catch (OrekitException oe) {
  371.                 throw new OrekitInternalError(oe);
  372.             }

  374.         }

  376.     }

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

  381.         /** Serializable UID. */
  382.         private static final long serialVersionUID = -8287341529741045958L;

  384.         /** Simple constructor.
  385.          * @param supportedNames regular expression for supported files names
  386.          * @param generateType ephemeris type to generate
  387.          * @param name name of the body
  388.          */
  389.         DTOCelestialBody(final String supportedNames, final EphemerisType generateType, final String name) {
  390.             super(supportedNames, generateType, name);
  391.         }

  393.         /** Replace the deserialized data transfer object with a {@link JPLCelestialBody}.
  394.          * @return replacement {@link JPLCelestialBody}
  395.          */
  396.         private Object readResolve() {
  397.             return getBody();
  398.         }

  400.     }

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

  405.         /** Serializable UID. */
  406.         private static final long serialVersionUID = 7915071664444154948L;

  408.         /** Simple constructor.
  409.          * @param supportedNames regular expression for supported files names
  410.          * @param generateType ephemeris type to generate
  411.          * @param name name of the body
  412.          */
  413.         DTOInertialFrame(final String supportedNames, final EphemerisType generateType, final String name) {
  414.             super(supportedNames, generateType, name);
  415.         }

  417.         /** Replace the deserialized data transfer object with a {@link Frame}.
  418.          * @return replacement {@link Frame}
  419.          */
  420.         private Object readResolve() {
  421.             return getBody().inertialFrame;
  422.         }

  424.     }

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

  429.         /** Serializable UID. */
  430.         private static final long serialVersionUID = -3194195019557081000L;

  432.         /** Simple constructor.
  433.          * @param supportedNames regular expression for supported files names
  434.          * @param generateType ephemeris type to generate
  435.          * @param name name of the body
  436.          */
  437.         DTOBodyFrame(final String supportedNames, final EphemerisType generateType, final String name) {
  438.             super(supportedNames, generateType, name);
  439.         }

  441.         /** Replace the deserialized data transfer object with a {@link Frame}.
  442.          * @return replacement {@link Frame}
  443.          */
  444.         private Object readResolve() {
  445.             return getBody().bodyFrame;
  446.         }

  448.     }

  450. }
Created with JaCoCo 0.7.9.201702052155