AEMFile.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.ccsds;

  19. import java.util.ArrayList;
  20. import java.util.Collections;
  21. import java.util.HashMap;
  22. import java.util.List;
  23. import java.util.Map;
  24. import java.util.Map.Entry;

  26. import org.hipparchus.geometry.euclidean.threed.RotationOrder;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.errors.OrekitMessages;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.TimeScale;
  31. import org.orekit.utils.TimeStampedAngularCoordinates;

  33. /**
  34.  * This class stocks all the information of the Attitude Ephemeris Message (AEM) File parsed
  35.  * by AEMParser. It contains the header and a list of Attitude Ephemerides Blocks each
  36.  * containing metadata and a list of attitude ephemerides data lines.
  37.  * @author Bryan Cazabonne
  38.  * @since 10.2
  39.  */
  40. public class AEMFile extends ADMFile {

  42.     /** List of ephemeris blocks. */
  43.     private List<AttitudeEphemeridesBlock> attitudeBlocks;

  45.     /**
  46.      * AEMFile constructor.
  47.      */
  48.     public AEMFile() {
  49.         attitudeBlocks = new ArrayList<AttitudeEphemeridesBlock>();
  50.     }

  52.     /**
  53.      * Add a block to the list of ephemeris blocks.
  54.      */
  55.     public void addAttitudeBlock() {
  56.         attitudeBlocks.add(new AttitudeEphemeridesBlock());
  57.     }

  59.     /**
  60.      * Get the list of attitude ephemerides blocks as an unmodifiable list.
  61.      * @return the list of attitude ephemerides blocks
  62.      */
  63.     public List<AttitudeEphemeridesBlock> getAttitudeBlocks() {
  64.         return Collections.unmodifiableList(attitudeBlocks);
  65.     }

  67.     /**
  68.      * Check that, according to the CCSDS standard, every AEMBlock has the same time system.
  69.      */
  70.     public void checkTimeSystems() {
  71.         final CcsdsTimeScale timeSystem = getAttitudeBlocks().get(0).getMetaData().getTimeSystem();
  72.         for (final AttitudeEphemeridesBlock block : attitudeBlocks) {
  73.             if (!timeSystem.equals(block.getMetaData().getTimeSystem())) {
  74.                 throw new OrekitException(OrekitMessages.CCSDS_AEM_INCONSISTENT_TIME_SYSTEMS,
  75.                                           timeSystem, block.getMetaData().getTimeSystem());
  76.             }
  77.         }
  78.     }


  81.     /**
  82.      * Get the attitude loaded ephemeris for each satellite in the file.
  83.      * @return a map from the satellite's ID to the information about that satellite
  84.      * contained in the file.
  85.      */
  86.     public Map<String, AemSatelliteEphemeris> getSatellites() {
  87.         final Map<String, List<AttitudeEphemeridesBlock>> satellites = new HashMap<>();
  88.         for (final AttitudeEphemeridesBlock ephemeridesBlock : attitudeBlocks) {
  89.             final String id = ephemeridesBlock.getMetaData().getObjectID();
  90.             satellites.putIfAbsent(id, new ArrayList<>());
  91.             satellites.get(id).add(ephemeridesBlock);
  92.         }
  93.         final Map<String, AemSatelliteEphemeris> ret = new HashMap<>();
  94.         for (final Entry<String, List<AttitudeEphemeridesBlock>> entry : satellites.entrySet()) {
  95.             final String id = entry.getKey();
  96.             ret.put(id, new AemSatelliteEphemeris(entry.getValue()));
  97.         }
  98.         return ret;
  99.     }

  101.     /**
  102.      * The Attitude Ephemerides Blocks class contain metadata
  103.      * and the list of attitude data lines.
  104.      */
  105.     public class AttitudeEphemeridesBlock {

  107.         /** Meta-data for the block. */
  108.         private ADMMetaData metaData;

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

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

  116.         /** Rotation direction of the attitude. */
  117.         private String attitudeDir;

  119.         /** Start of total time span covered by attitude data. */
  120.         private AbsoluteDate startTime;

  122.         /** End of total time span covered by attitude data. */
  123.         private AbsoluteDate stopTime;

  125.         /** Start of useable time span covered by attitude data. */
  126.         private AbsoluteDate useableStartTime;

  128.         /** End of useable time span covered by attitude data. */
  129.         private AbsoluteDate useableStopTime;

  131.         /** The format of the data lines in the message. */
  132.         private String attitudeType;

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

  137.         /**
  138.          * The rotation sequence of the Euler angles.
  139.          * (e.g., 312, where X=1, Y=2, Z=3)
  140.          */
  141.         private String eulerRotSeq;

  143.         /** The rate frame specifier, as it appeared in the file. */
  144.         private String rateFrameString;

  146.         /** The interpolation method to be used. */
  147.         private String interpolationMethod;

  149.         /** The interpolation degree. */
  150.         private int interpolationDegree;

  152.         /** The rotation order. */
  153.         private RotationOrder rotationOrder;

  155.         /** List of data lines. */
  156.         private List<TimeStampedAngularCoordinates> attitudeDataLines;

  158.         /** Data Lines comments. The list contains a string for each line of comment. */
  159.         private List<String> attitudeDataLinesComment;

  161.         /**
  162.          * Constructor.
  163.          */
  164.         public AttitudeEphemeridesBlock() {
  165.             attitudeDataLines = new ArrayList<>();
  166.             metaData          = new ADMMetaData(AEMFile.this);
  167.         }

  169.         /**
  170.          * Get the list of attitude data lines.
  171.          * @return a list of data
  172.          */
  173.         public List<TimeStampedAngularCoordinates> getAttitudeDataLines() {
  174.             return attitudeDataLines;
  175.         }

  177.         /**
  178.          * Get an unmodifiable list of attitude data lines.
  179.          * @return a list of attitude data
  180.          */
  181.         public List<TimeStampedAngularCoordinates> getAngularCoordinates() {
  182.             return Collections.unmodifiableList(this.attitudeDataLines);
  183.         }

  185.         /**
  186.          * Get the meta-data for the block.
  187.          * @return meta-data for the block
  188.          */
  189.         public ADMMetaData getMetaData() {
  190.             return metaData;
  191.         }

  193.         /**
  194.          * Get the name of the center of the coordinate system the ephemeris is provided in.
  195.          * This may be a natural origin, such as the center of the Earth, another satellite, etc.
  196.          * @return the name of the frame center
  197.          */
  198.         public String getFrameCenterString() {
  199.             return this.getMetaData().getCenterName();
  200.         }


  203.         /**
  204.          * Get the reference frame A specifier as it appeared in the file.
  205.          * @return the frame name as it appeared in the file (A).
  206.          */
  207.         public String getRefFrameAString() {
  208.             return refFrameAString;
  209.         }

  211.         /**
  212.          * Set the reference frame A name.
  213.          * @param frame specifier as it appeared in the file.
  214.          */
  215.         public void setRefFrameAString(final String frame) {
  216.             this.refFrameAString = frame;
  217.         }

  219.         /**
  220.          * Get the reference frame B specifier as it appeared in the file.
  221.          * @return the frame name as it appeared in the file (B).
  222.          */
  223.         public String getRefFrameBString() {
  224.             return this.refFrameBString;
  225.         }

  227.         /**
  228.          * Set the reference frame B name.
  229.          * @param frame specifier as it appeared in the file.
  230.          */
  231.         public void setRefFrameBString(final String frame) {
  232.             this.refFrameBString = frame;
  233.         }

  235.         /**
  236.          * Get the rate frame specifier as it appeared in the file.
  237.          * @return the rate frame name.
  238.          */
  239.         public String getRateFrameString() {
  240.             return rateFrameString;
  241.         }

  243.         /**
  244.          * Set the rate frame name.
  245.          * @param frame specifier as it appeared in the file.
  246.          */
  247.         public void setRateFrameString(final String frame) {
  248.             this.rateFrameString = frame;
  249.         }

  251.         /**
  252.          * Get the rotation direction of the attitude.
  253.          * @return the rotation direction of the attitude
  254.          */
  255.         public String getAttitudeDirection() {
  256.             return attitudeDir;
  257.         }

  259.         /**
  260.          * Set the rotation direction of the attitude.
  261.          * @param direction rotation direction to be set
  262.          */
  263.         public void setAttitudeDirection(final String direction) {
  264.             this.attitudeDir = direction;
  265.         }

  267.         /**
  268.          * Get the format of the data lines in the message.
  269.          * @return the format of the data lines in the message
  270.          */
  271.         public String getAttitudeType() {
  272.             return attitudeType;
  273.         }

  275.         /**
  276.          * Set the format of the data lines in the message.
  277.          * @param type format to be set
  278.          */
  279.         public void setAttitudeType(final String type) {
  280.             this.attitudeType = type;
  281.         }

  283.         /**
  284.          * Get the flag for the placement of the quaternion QC in the attitude data.
  285.          * @return true if QC is the first element in the attitude data
  286.          */
  287.         public boolean isFirst() {
  288.             return isFirst;
  289.         }

  291.         /**
  292.          * Set the flag for the placement of the quaternion QC in the attitude data.
  293.          * @param isFirst true if QC is the first element in the attitude data
  294.          */
  295.         public void setIsFirst(final boolean isFirst) {
  296.             this.isFirst = isFirst;
  297.         }

  299.         /**
  300.          * Get the rotation sequence of the Euler angles (e.g., 312, where X=1, Y=2, Z=3).
  301.          * @return the rotation sequence of the Euler angles
  302.          */
  303.         public String getEulerRotSeq() {
  304.             return eulerRotSeq;
  305.         }

  307.         /**
  308.          * Set the rotation sequence of the Euler angles (e.g., 312, where X=1, Y=2, Z=3).
  309.          * @param eulerRotSeq rotation sequence to be set
  310.          */
  311.         public void setEulerRotSeq(final String eulerRotSeq) {
  312.             this.eulerRotSeq = eulerRotSeq;
  313.         }

  315.         /**
  316.          * Get the time scale for this data segment.
  317.          * @return the time scale identifier, as specified in the file, or
  318.          * {@code null} if the data file does not specify a time scale.
  319.          */
  320.         public String getTimeScaleString() {
  321.             return metaData.getTimeSystem().toString();
  322.         }

  324.         /**
  325.          * Get the time scale for this data segment.
  326.          * @return the time scale for this data. Never {@code null}.
  327.          */
  328.         public TimeScale getTimeScale() {
  329.             return metaData.getTimeScale();
  330.         }

  332.         /**
  333.          * Get start of total time span covered by attitude data.
  334.          * @return the start time
  335.          */
  336.         public AbsoluteDate getStartTime() {
  337.             return startTime;
  338.         }

  340.         /**
  341.          * Set start of total time span covered by attitude data.
  342.          * @param startTime the time to be set
  343.          */
  344.         public void setStartTime(final AbsoluteDate startTime) {
  345.             this.startTime = startTime;
  346.         }

  348.         /**
  349.          * Get end of total time span covered by attitude data.
  350.          * @return the stop time
  351.          */
  352.         public AbsoluteDate getStopTime() {
  353.             return stopTime;
  354.         }

  356.         /**
  357.          * Set end of total time span covered by attitude data.
  358.          * @param stopTime the time to be set
  359.          */
  360.         public void setStopTime(final AbsoluteDate stopTime) {
  361.             this.stopTime = stopTime;
  362.         }

  364.         /**
  365.          * Get start of useable time span covered by attitude data.
  366.          * @return the useable start time
  367.          */
  368.         public AbsoluteDate getUseableStartTime() {
  369.             return useableStartTime;
  370.         }

  372.         /**
  373.          * Set start of useable time span covered by attitude data.
  374.          * @param useableStartTime the time to be set
  375.          */
  376.         public void setUseableStartTime(final AbsoluteDate useableStartTime) {
  377.             this.useableStartTime = useableStartTime;
  378.         }

  380.         /**
  381.          * Get end of useable time span covered by ephemerides data.
  382.          * @return the useable stop time
  383.          */
  384.         public AbsoluteDate getUseableStopTime() {
  385.             return useableStopTime;
  386.         }

  388.         /**
  389.          * Set end of useable time span covered by ephemerides data.
  390.          * @param useableStopTime the time to be set
  391.          */
  392.         public void setUseableStopTime(final AbsoluteDate useableStopTime) {
  393.             this.useableStopTime = useableStopTime;
  394.         }

  396.         /**
  397.          * Get the start date of this attitude data segment.
  398.          * @return attitude data segment start date.
  399.          */
  400.         public AbsoluteDate getStart() {
  401.             // usable start time overrides start time if it is set
  402.             final AbsoluteDate start = this.getUseableStartTime();
  403.             if (start != null) {
  404.                 return start;
  405.             } else {
  406.                 return this.getStartTime();
  407.             }
  408.         }

  410.         /**
  411.          * Get the end date of this attitude data segment.
  412.          * @return attitude data segment end date.
  413.          */
  414.         public AbsoluteDate getStop() {
  415.             // useable stop time overrides stop time if it is set
  416.             final AbsoluteDate stop = this.getUseableStopTime();
  417.             if (stop != null) {
  418.                 return stop;
  419.             } else {
  420.                 return this.getStopTime();
  421.             }
  422.         }

  424.         /**
  425.          * Get the interpolation method to be used.
  426.          * @return the interpolation method
  427.          */
  428.         public String getInterpolationMethod() {
  429.             return interpolationMethod;
  430.         }

  432.         /**
  433.          * Set the interpolation method to be used.
  434.          * @param interpolationMethod the interpolation method to be set
  435.          */
  436.         public void setInterpolationMethod(final String interpolationMethod) {
  437.             this.interpolationMethod = interpolationMethod;
  438.         }

  440.         /**
  441.          * Get the interpolation degree.
  442.          * @return the interpolation degree
  443.          */
  444.         public int getInterpolationDegree() {
  445.             return interpolationDegree;
  446.         }

  448.         /**
  449.          * Set the interpolation degree.
  450.          * @param interpolationDegree the interpolation degree to be set
  451.          */
  452.         public void setInterpolationDegree(final int interpolationDegree) {
  453.             this.interpolationDegree = interpolationDegree;
  454.         }

  456.         /** Get the attitude data lines comment.
  457.          * @return the comment
  458.          */
  459.         public List<String> getAttitudeDataLinesComment() {
  460.             return attitudeDataLinesComment;
  461.         }

  463.         /** Set the attitude data lines comment.
  464.          * @param ephemeridesDataLinesComment the comment to be set
  465.          */
  466.         public void setAttitudeDataLinesComment(final List<String> ephemeridesDataLinesComment) {
  467.             this.attitudeDataLinesComment = new ArrayList<String>(ephemeridesDataLinesComment);
  468.         }

  470.         /**
  471.          * Get the rotation order for Euler angles.
  472.          * @return rotation order
  473.          */
  474.         public RotationOrder getRotationOrder() {
  475.             return rotationOrder;
  476.         }

  478.         /**
  479.          * Set the rotation order for Euler angles.
  480.          * @param order the rotation order to be set
  481.          */
  482.         public void setRotationOrder(final RotationOrder order) {
  483.             this.rotationOrder = order;
  484.         }

  486.     }

  488.     /** AEM ephemeris blocks for a single satellite. */
  489.     public static class AemSatelliteEphemeris {

  491.         /** The attitude ephemeris data for the satellite. */
  492.         private final List<AttitudeEphemeridesBlock> blocks;

  494.         /**
  495.          * Create a container for the set of ephemeris blocks in the file that pertain to
  496.          * a single satellite.
  497.          * @param blocks containing ephemeris data for the satellite.
  498.          */
  499.         public AemSatelliteEphemeris(final List<AttitudeEphemeridesBlock> blocks) {
  500.             this.blocks = blocks;
  501.         }

  503.         /**
  504.          * Get the segments of the attitude ephemeris.
  505.          * <p> Ephemeris segments are typically used to split an attitude ephemeris around
  506.          * discontinuous events, such as maneuvers.
  507.          * @return the segments contained in the attitude ephemeris file for this satellite.
  508.          */
  509.         public List<AttitudeEphemeridesBlock> getSegments() {
  510.             return Collections.unmodifiableList(blocks);
  511.         }

  513.         /**
  514.          * Get the start date of the attitude ephemeris.
  515.          * @return attitude ephemeris start date.
  516.          */
  517.         public AbsoluteDate getStart() {
  518.             return blocks.get(0).getStart();
  519.         }

  521.         /**
  522.          * Get the end date of the attitude ephemeris.
  523.          * @return attitude ephemeris end date.
  524.          */
  525.         public AbsoluteDate getStop() {
  526.             return blocks.get(blocks.size() - 1).getStop();
  527.         }

  529.     }

  531. }
Created with JaCoCo 0.8.5.201910111838