OrekitAttitudeEphemerisFile.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (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.files.general;

  19. import java.util.ArrayList;
  20. import java.util.Collections;
  21. import java.util.List;
  22. import java.util.Map;
  23. import java.util.concurrent.ConcurrentHashMap;

  25. import org.hipparchus.geometry.euclidean.threed.RotationOrder;
  26. import org.orekit.annotation.DefaultDataContext;
  27. import org.orekit.bodies.CelestialBody;
  28. import org.orekit.data.DataContext;
  29. import org.orekit.errors.OrekitIllegalArgumentException;
  30. import org.orekit.errors.OrekitMessages;
  31. import org.orekit.files.ccsds.AEMAttitudeType;
  32. import org.orekit.frames.Frame;
  33. import org.orekit.propagation.SpacecraftState;
  34. import org.orekit.time.AbsoluteDate;
  35. import org.orekit.time.TimeScale;
  36. import org.orekit.utils.AngularDerivativesFilter;
  37. import org.orekit.utils.TimeStampedAngularCoordinates;

  39. /**
  40.  * A class for encapsulating Orekit propagators within an {@link AttitudeEphemerisFile}
  41.  * complaint object that makes for easy serialization to external ephemeris
  42.  * formats like AEM.
  43.  *
  44.  * @author Raphaël Fermé
  45.  * @since 10.3
  46.  *
  47.  */
  48. public class OrekitAttitudeEphemerisFile implements AttitudeEphemerisFile {

  50.     /** Hashmap of satellite ephemeris. **/
  51.     private final Map<String, OrekitSatelliteAttitudeEphemeris> satellites;

  53.     /**
  54.      * Standard default constructor.
  55.      */
  56.     public OrekitAttitudeEphemerisFile() {
  57.         this.satellites = new ConcurrentHashMap<>();
  58.     }

  60.     /** {@inheritDoc} */
  61.     @Override
  62.     public Map<String, OrekitSatelliteAttitudeEphemeris> getSatellites() {
  63.         return Collections.unmodifiableMap(satellites);
  64.     }

  66.     /**
  67.      * Adds a new satellite to this object.
  68.      *
  69.      * @param id
  70.      *            ID to use for this satellite
  71.      * @return the new satellite object
  72.      */
  73.     public OrekitSatelliteAttitudeEphemeris addSatellite(final String id) {
  74.         final OrekitSatelliteAttitudeEphemeris newSat = new OrekitSatelliteAttitudeEphemeris(id);
  75.         this.satellites.put(id, newSat);
  76.         return newSat;
  77.     }

  79.     /**
  80.      * Inner class of {@link OrekitAttitudeEphemerisFile} that defines the
  81.      * {@link OrekitSatelliteAttitudeEphemeris} corresponding object for this ephemeris type.
  82.      *
  83.      */
  84.     public static class OrekitSatelliteAttitudeEphemeris implements SatelliteAttitudeEphemeris {

  86.         /** Default interpolation sample size if it is not specified. **/
  87.         public static final String DEFAULT_INTERPOLATION_METHOD = "LINEAR";

  89.         /** Default interpolation sample size if it is not specified. **/
  90.         public static final int DEFAULT_INTERPOLATION_SIZE = 2;

  92.         /** Default quaternion order if it is not specified. **/
  93.         public static final String DEFAULT_ATTITUDE_TYPE = "QUATERNION";

  95.         /** Default quaternion order if it is not specified. **/
  96.         public static final boolean DEFAULT_IS_FIRST = false;

  98.         /** Default rotation order if it is not specified. **/
  99.         public static final RotationOrder DEFAULT_ROTATION_ORDER = RotationOrder.ZYX;

  101.         /** Default reference frame A name if it is not specified. **/
  102.         public static final String DEFAULT_REF_FRAME_A = "EME2000";

  104.         /** Default reference frame B name if it is not specified. **/
  105.         public static final String DEFAULT_REF_FRAME_B = "SC_BODY_1";

  107.         /** Default attitude rotation direction if it is not specified. **/
  108.         public static final String DEFAULT_ATTITUDE_DIR = "A2B";

  110.         /** ID of the space object encapsulated here. **/
  111.         private final String id;

  113.         /** Earliest date of this file. **/
  114.         private AbsoluteDate startDate;

  116.         /** Latest date of this file. **/
  117.         private AbsoluteDate stopDate;

  119.         /** List of segments in the file. **/
  120.         private final List<OrekitAttitudeEphemerisSegment> segments;

  122.         /**
  123.          * Standard constructor for building the satellite Ephemeris object.
  124.          *
  125.          * @param id
  126.          *            the ID of the space object for this data
  127.          */
  128.         public OrekitSatelliteAttitudeEphemeris(final String id) {
  129.             this.id = id;
  130.             this.segments = new ArrayList<OrekitAttitudeEphemerisSegment>();
  131.         }

  133.         /** {@inheritDoc} */
  134.         @Override
  135.         public String getId() {
  136.             return id;
  137.         }

  139.         /** {@inheritDoc} */
  140.         @Override
  141.         public List<? extends AttitudeEphemerisSegment> getSegments() {
  142.             return Collections.unmodifiableList(this.segments);
  143.         }

  145.         /** {@inheritDoc} */
  146.         @Override
  147.         public AbsoluteDate getStart() {
  148.             return this.startDate;
  149.         }

  151.         /** {@inheritDoc} */
  152.         @Override
  153.         public AbsoluteDate getStop() {
  154.             return this.stopDate;
  155.         }

  157.         /**
  158.          * Injects pre-computed satellite states into this attitude ephemeris file object,
  159.          * returning the generated {@link OrekitAttitudeEphemerisSegment} that has been stored
  160.          * internally. Defaults the celestial body to earth, time scale to UTC, the interpolation
  161.          * size and method, the attitude type, the reference frames to default values.
  162.          *
  163.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  164.          *
  165.          * @param states
  166.          *            a list of {@link SpacecraftState} that will comprise this
  167.          *            new unit.
  168.          * @return the generated {@link OrekitAttitudeEphemerisSegment}
  169.          */
  170.         @DefaultDataContext
  171.         public OrekitAttitudeEphemerisSegment addNewSegment(final List<SpacecraftState> states) {
  172.             return this.addNewSegment(states, DEFAULT_INTERPOLATION_METHOD, DEFAULT_INTERPOLATION_SIZE);
  173.         }

  175.         /**
  176.          * Injects pre-computed satellite states into this attitude ephemeris file object,
  177.          * returning the generated {@link OrekitAttitudeEphemerisSegment} that has been stored
  178.          * internally. Defaults the celestial body to earth, time scale to UTC, the attitude type,
  179.          * the reference frames to default values.
  180.          *
  181.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  182.          *
  183.          * @param states
  184.          *          a list of {@link SpacecraftState} that will comprise this
  185.          *          new unit
  186.          * @param interpolationMethod
  187.          *          the interpolation method that should be used when processed
  188.          *          by another system
  189.          * @param interpolationSamples
  190.          *          the number of interpolation samples that should be used
  191.          *          when processed by another system
  192.          * @return the generated {@link OrekitAttitudeEphemerisSegment}
  193.          */
  194.         @DefaultDataContext
  195.         public OrekitAttitudeEphemerisSegment addNewSegment(final List<SpacecraftState> states,
  196.                                                 final String interpolationMethod, final int interpolationSamples) {
  197.             return this.addNewSegment(states, interpolationMethod, interpolationSamples, DEFAULT_ATTITUDE_TYPE,
  198.                                       DEFAULT_IS_FIRST, DEFAULT_ROTATION_ORDER);
  199.         }

  201.         /**
  202.          * Injects pre-computed satellite states into this attitude ephemeris file object,
  203.          * returning the generated {@link OrekitAttitudeEphemerisSegment} that has been stored
  204.          * internally. Defaults the celestial body to earth, time scale to UTC, the reference
  205.          * frames to default values.
  206.          *
  207.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  208.          *
  209.          * @param states
  210.          *          a list of {@link SpacecraftState} that will comprise this
  211.          *          new unit
  212.          * @param interpolationMethod
  213.          *          the interpolation method that should be used when processed
  214.          *          by another system
  215.          * @param interpolationSamples
  216.          *          the number of interpolation samples that should be used
  217.          *          when processed by another system
  218.          * @param attitudeType
  219.          *          type of attitude for the attitude ephemeris segment. Must correspond
  220.          *          to the names in {@link AEMAttitudeType} enumerate.
  221.          * @param isFirst
  222.          *          flag for placement of the scalar part of the quaternion
  223.          *          (used if quaternions are chosen in the attitude type)
  224.          * @param rotationOrder
  225.          *          the rotation order for Euler angles (used if Euler angles
  226.          *          are chosen in the attitude type)
  227.          * @return the generated {@link OrekitAttitudeEphemerisSegment}
  228.          */
  229.         @DefaultDataContext
  230.         public OrekitAttitudeEphemerisSegment addNewSegment(final List<SpacecraftState> states, final String interpolationMethod,
  231.                                                             final int interpolationSamples, final String attitudeType,
  232.                                                             final boolean isFirst, final RotationOrder rotationOrder) {
  233.             return this.addNewSegment(states, interpolationMethod, interpolationSamples, attitudeType,
  234.                                       isFirst, rotationOrder, DEFAULT_REF_FRAME_A, DEFAULT_REF_FRAME_B,
  235.                                       DEFAULT_ATTITUDE_DIR);
  236.         }

  238.         /**
  239.          * Injects pre-computed satellite states into this attitude ephemeris file object,
  240.          * returning the generated {@link OrekitAttitudeEphemerisSegment} that has been stored
  241.          * internally. Defaults the celestial body to earth, time scale to UTC.
  242.          *
  243.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  244.          *
  245.          * @param states
  246.          *          a list of {@link SpacecraftState} that will comprise this
  247.          *          new unit
  248.          * @param interpolationMethod
  249.          *          the interpolation method that should be used when processed
  250.          *          by another system
  251.          * @param interpolationSamples
  252.          *          the number of interpolation samples that should be used
  253.          *          when processed by another system
  254.          * @param attitudeType
  255.          *          type of attitude for the attitude ephemeris segment. Must correspond
  256.          *          to the names in {@link AEMAttitudeType} enumerate.
  257.          * @param isFirst
  258.          *          flag for placement of the scalar part of the quaternion
  259.          *          (used if quaternions are chosen in the attitude type)
  260.          * @param rotationOrder
  261.          *          the rotation order for Euler angles (used if Euler angles
  262.          *          are chosen in the attitude type)
  263.          * @param refFrameA
  264.          *          name of reference frame A
  265.          * @param refFrameB
  266.          *          name of reference frame B
  267.          * @param attitudeDir
  268.          *          rotation direction of the attitude: "A2B" or "B2A"
  269.          * @return the generated {@link OrekitAttitudeEphemerisSegment}
  270.          */
  271.         @DefaultDataContext
  272.         public OrekitAttitudeEphemerisSegment addNewSegment(final List<SpacecraftState> states, final String interpolationMethod,
  273.                                                             final int interpolationSamples, final String attitudeType,
  274.                                                             final boolean isFirst, final RotationOrder rotationOrder,
  275.                                                             final String refFrameA, final String refFrameB,
  276.                                                             final String attitudeDir) {
  277.             return this.addNewSegment(states, interpolationMethod, interpolationSamples, attitudeType,
  278.                                       isFirst, rotationOrder, refFrameA, refFrameB,
  279.                                       attitudeDir, DataContext.getDefault().getCelestialBodies().getEarth());
  280.         }

  282.         /**
  283.          * Injects pre-computed satellite states into this attitude ephemeris file object,
  284.          * returning the generated {@link OrekitAttitudeEphemerisSegment} that has been stored
  285.          * internally. Defaults the time scale to UTC.
  286.          *
  287.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  288.          *
  289.          * @param states
  290.          *          a list of {@link SpacecraftState} that will comprise this
  291.          *          new unit
  292.          * @param interpolationMethod
  293.          *          the interpolation method that should be used when processed
  294.          *          by another system
  295.          * @param interpolationSamples
  296.          *          the number of interpolation samples that should be used
  297.          *          when processed by another system
  298.          * @param attitudeType
  299.          *          type of attitude for the attitude ephemeris segment. Must correspond
  300.          *          to the names in {@link AEMAttitudeType} enumerate.
  301.          * @param isFirst
  302.          *          flag for placement of the scalar part of the quaternion
  303.          *          (used if quaternions are chosen in the attitude type)
  304.          * @param rotationOrder
  305.          *          the rotation order for Euler angles (used if Euler angles
  306.          *          are chosen in the attitude type)
  307.          * @param refFrameA
  308.          *          name of reference frame A
  309.          * @param refFrameB
  310.          *          name of reference frame B
  311.          * @param attitudeDir
  312.          *          rotation direction of the attitude: "A2B" or "B2A"
  313.          * @param body
  314.          *          the celestial body from which the frames are defined
  315.          * @return the generated {@link OrekitAttitudeEphemerisSegment}
  316.          */
  317.         @DefaultDataContext
  318.         public OrekitAttitudeEphemerisSegment addNewSegment(final List<SpacecraftState> states, final String interpolationMethod,
  319.                                                             final int interpolationSamples, final String attitudeType,
  320.                                                             final boolean isFirst, final RotationOrder rotationOrder,
  321.                                                             final String refFrameA, final String refFrameB,
  322.                                                             final String attitudeDir, final CelestialBody body) {
  323.             return this.addNewSegment(states, interpolationMethod, interpolationSamples, attitudeType,
  324.                                       isFirst, rotationOrder, refFrameA, refFrameB, attitudeDir, body,
  325.                                       DataContext.getDefault().getTimeScales().getUTC());
  326.         }

  328.         /**
  329.          * Injects pre-computed satellite states into this attitude ephemeris file
  330.          * object, returning the generated {@link OrekitAttitudeEphemerisSegment} that
  331.          * has been stored internally.
  332.          *
  333.          * @param states
  334.          *          a list of {@link SpacecraftState} that will comprise this
  335.          *          new unit
  336.          * @param body
  337.          *          the celestial body from which the frames are defined
  338.          * @param refFrameA
  339.          *          name of reference frame A
  340.          * @param refFrameB
  341.          *          name of reference frame B
  342.          * @param attitudeDir
  343.          *          rotation direction of the attitude: "A2B" or "B2A"
  344.          * @param attitudeType
  345.          *          type of attitude for the attitude ephemeris segment.
  346.          * @param isFirst
  347.          *          flag for placement of the scalar part of the quaternion
  348.          *          (used if quaternions are chosen in the attitude type)
  349.          * @param rotationOrder
  350.          *          the rotation order for Euler angles (used if Euler angles
  351.          *          are chosen in the attitude type)
  352.          * @param timeScale
  353.          *          the time scale used in the new segment.
  354.          * @param interpolationMethod
  355.          *          the interpolation method that should be used when processed
  356.          *          by another system
  357.          * @param interpolationSamples
  358.          *          the number of interpolation samples that should be used
  359.          *          when processed by another system
  360.          * @return the generated {@link OrekitAttitudeEphemerisSegment}
  361.          */
  362.         public OrekitAttitudeEphemerisSegment addNewSegment(final List<SpacecraftState> states, final String interpolationMethod,
  363.                                                             final int interpolationSamples, final String attitudeType,
  364.                                                             final boolean isFirst, final RotationOrder rotationOrder,
  365.                                                             final String refFrameA, final String refFrameB,
  366.                                                             final String attitudeDir, final CelestialBody body,
  367.                                                             final TimeScale timeScale) {
  368.             final int minimumSampleSize = 2;
  369.             if (states == null || states.size() == 0) {
  370.                 throw new OrekitIllegalArgumentException(OrekitMessages.NULL_ARGUMENT, "states");
  371.             }

  373.             if (interpolationSamples < minimumSampleSize) {
  374.                 throw new OrekitIllegalArgumentException(OrekitMessages.NOT_ENOUGH_DATA_FOR_INTERPOLATION,
  375.                         interpolationSamples);
  376.             }

  378.             final AbsoluteDate start = states.get(0).getDate();
  379.             final AbsoluteDate stop = states.get(states.size() - 1).getDate();

  381.             if (this.startDate == null || start.compareTo(this.startDate) < 0) {
  382.                 this.startDate = start;
  383.             }

  385.             if (this.stopDate == null || stop.compareTo(this.stopDate) > 0) {
  386.                 this.stopDate = stop;
  387.             }

  389.             final List<TimeStampedAngularCoordinates> attitudeDataLines = new ArrayList<TimeStampedAngularCoordinates>();
  390.             for (SpacecraftState state : states) {
  391.                 attitudeDataLines.add(state.getAttitude().getOrientation());
  392.             }

  394.             final OrekitAttitudeEphemerisSegment newSeg = new OrekitAttitudeEphemerisSegment(attitudeDataLines, body.getName(), refFrameA,
  395.                                                                         refFrameB, attitudeDir, attitudeType, isFirst, rotationOrder,
  396.                                                                         timeScale, interpolationMethod, interpolationSamples, states.get(0).getFrame());
  397.             this.segments.add(newSeg);
  398.             return newSeg;
  399.         }
  400.     }

  402.     public static class OrekitAttitudeEphemerisSegment implements AttitudeEphemerisSegment {

  404.         /** List of attitude data lines. */
  405.         private List<TimeStampedAngularCoordinates> attitudeDataLines;

  407.         /** The name of the frame center. **/
  408.         private final String frameCenterString;

  410.         /** The reference frame A specifier, as it appeared in the file. */
  411.         private String refFrameAString;

  413.         /** The reference frame B specifier, as it appeared in the file. */
  414.         private String refFrameBString;

  416.         /** Rotation direction of the attitude. */
  417.         private String attitudeDir;

  419.         /** The format of the data lines in the message. */
  420.         private String attitudeType;

  422.         /** The placement of the scalar portion of the quaternion (QC) in the attitude data. */
  423.         private boolean isFirst;

  425.         /** The rotation order. */
  426.         private RotationOrder rotationOrder;

  428.         /** The time scale identifier, as specified in the ephemeris file. **/
  429.         private final String timeScaleString;

  431.         /** The time scale for this segment. **/
  432.         private final TimeScale timeScale;

  434.         /** The interpolation method to be used. */
  435.         private String interpolationMethod;

  437.         /** The number of interpolation samples. */
  438.         private int interpolationSamples;

  440.         /** Enumerate for selecting which derivatives to use in {@link #attitudeDataLines} interpolation. */
  441.         private AngularDerivativesFilter angularDerivativesFilter;

  443.         /** Reference frame from which attitude is defined. */
  444.         private Frame referenceFrame;

  446.         /**
  447.          * Constructor for OrekitAttitudeEphemerisSegment.
  448.          *
  449.          * @param attitudeDataLines
  450.          *          attitude data lines for this segment.
  451.          * @param frameCenterString
  452.          *          the name of celestial body the frame is attached to.
  453.          * @param refFrameAString
  454.          *          the name of the reference frame A.
  455.          * @param refFrameBString
  456.          *          the name of the reference frame B.
  457.          * @param attitudeDir
  458.          *          the rotation direction of the attitude.
  459.          * @param attitudeType
  460.          *          the format of the attitude data.
  461.          * @param isFirst
  462.          *          true if QC is the first element in the attitude data.
  463.          * @param rotationOrder
  464.          *          the rotation order for Euler angles.
  465.          * @param timeScale
  466.          *          the time scale of these ephemerides data.
  467.          * @param interpolationMethod
  468.          *          the interpolation method to use.
  469.          * @param interpolationSamples
  470.          *          the number of samples to use during interpolation.
  471.          * @param referenceFrame
  472.          *          reference frame from which the attitude is defined
  473.          */
  474.         public OrekitAttitudeEphemerisSegment(final List<TimeStampedAngularCoordinates> attitudeDataLines, final String frameCenterString,
  475.                 final String refFrameAString, final String refFrameBString, final String attitudeDir, final String attitudeType,
  476.                 final boolean isFirst, final RotationOrder rotationOrder, final TimeScale timeScale,
  477.                 final String interpolationMethod, final int interpolationSamples,
  478.                 final Frame referenceFrame) {
  479.             this.attitudeDataLines        = attitudeDataLines;
  480.             this.frameCenterString        = frameCenterString;
  481.             this.refFrameAString          = refFrameAString;
  482.             this.refFrameBString          = refFrameBString;
  483.             this.attitudeDir              = attitudeDir;
  484.             this.attitudeType             = attitudeType;
  485.             this.isFirst                  = isFirst;
  486.             this.rotationOrder            = rotationOrder;
  487.             this.timeScaleString          = timeScale.getName();
  488.             this.timeScale                = timeScale;
  489.             this.interpolationMethod      = interpolationMethod;
  490.             this.interpolationSamples     = interpolationSamples;
  491.             this.referenceFrame           = referenceFrame;
  492.             this.angularDerivativesFilter = AEMAttitudeType.getAttitudeType(attitudeType).getAngularDerivativesFilter();
  493.         }

  495.         /** {@inheritDoc} */
  496.         @Override
  497.         public List<TimeStampedAngularCoordinates> getAngularCoordinates() {
  498.             return Collections.unmodifiableList(attitudeDataLines);
  499.         }

  501.         /** {@inheritDoc} */
  502.         @Override
  503.         public String getFrameCenterString() {
  504.             return frameCenterString;
  505.         }

  507.         /** {@inheritDoc} */
  508.         @Override
  509.         public String getRefFrameAString() {
  510.             return refFrameAString;
  511.         }

  513.         /** {@inheritDoc} */
  514.         @Override
  515.         public String getRefFrameBString() {
  516.             return refFrameBString;
  517.         }

  519.         /** {@inheritDoc} */
  520.         @Override
  521.         public Frame getReferenceFrame() {
  522.             return referenceFrame;
  523.         }

  525.         /** {@inheritDoc} */
  526.         @Override
  527.         public String getAttitudeDirection() {
  528.             return attitudeDir;
  529.         }

  531.         /** {@inheritDoc} */
  532.         @Override
  533.         public String getAttitudeType() {
  534.             return attitudeType;
  535.         }

  537.         /** {@inheritDoc} */
  538.         @Override
  539.         public boolean isFirst() {
  540.             return isFirst;
  541.         }

  543.         /** {@inheritDoc} */
  544.         @Override
  545.         public RotationOrder getRotationOrder() {
  546.             return rotationOrder;
  547.         }

  549.         /** {@inheritDoc} */
  550.         @Override
  551.         public String getTimeScaleString() {
  552.             return timeScaleString;
  553.         }

  555.         /** {@inheritDoc} */
  556.         @Override
  557.         public TimeScale getTimeScale() {
  558.             return timeScale;
  559.         }

  561.         /** {@inheritDoc} */
  562.         @Override
  563.         public AbsoluteDate getStart() {
  564.             return attitudeDataLines.get(0).getDate();
  565.         }

  567.         /** {@inheritDoc} */
  568.         @Override
  569.         public AbsoluteDate getStop() {
  570.             return attitudeDataLines.get(attitudeDataLines.size() - 1).getDate();
  571.         }

  573.         /** {@inheritDoc} */
  574.         @Override
  575.         public String getInterpolationMethod() {
  576.             return interpolationMethod;
  577.         }

  579.         /** {@inheritDoc} */
  580.         @Override
  581.         public int getInterpolationSamples() {
  582.             return interpolationSamples;
  583.         }

  585.         /** {@inheritDoc} */
  586.         @Override
  587.         public AngularDerivativesFilter getAvailableDerivatives() {
  588.             return angularDerivativesFilter;
  589.         }

  591.     }

  593. }
Created with JaCoCo 0.8.6.202009150832