AEMParser.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.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.nio.charset.StandardCharsets;
  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;
  28. import java.util.Scanner;
  29. import java.util.regex.Pattern;

  31. import org.hipparchus.exception.DummyLocalizable;
  32. import org.hipparchus.geometry.euclidean.threed.RotationOrder;
  33. import org.orekit.annotation.DefaultDataContext;
  34. import org.orekit.data.DataContext;
  35. import org.orekit.errors.OrekitException;
  36. import org.orekit.errors.OrekitMessages;
  37. import org.orekit.files.general.AttitudeEphemerisFileParser;
  38. import org.orekit.frames.Frame;
  39. import org.orekit.time.AbsoluteDate;
  40. import org.orekit.utils.IERSConventions;
  41. import org.orekit.utils.TimeStampedAngularCoordinates;

  43. /**
  44.  * A parser for the CCSDS AEM (Attitude Ephemeris Message).
  45.  * @author Bryan Cazabonne
  46.  * @since 10.2
  47.  */
  48. public class AEMParser extends ADMParser implements AttitudeEphemerisFileParser {

  50.     /** Pattern for dash. */
  51.     private static final Pattern DASH = Pattern.compile("-");

  53.     /** Maximum number of elements in an attitude data line. */
  54.     private static final int MAX_SIZE = 8;

  56.     /** Default interpolation degree. */
  57.     private int interpolationDegree;

  59.     /** Local Spacecraft Body Reference Frame A. */
  60.     private Frame localScBodyReferenceFrameA;

  62.     /** Local Spacecraft Body Reference Frame B. */
  63.     private Frame localScBodyReferenceFrameB;

  65.     /**
  66.      * Simple constructor.
  67.      * <p>
  68.      * This class is immutable, and hence thread safe. When parts
  69.      * must be changed, such as reference date for Mission Elapsed Time or
  70.      * Mission Relative Time time systems, or the gravitational coefficient or
  71.      * the IERS conventions, the various {@code withXxx} methods must be called,
  72.      * which create a new immutable instance with the new parameters. This
  73.      * is a combination of the
  74.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  75.      * pattern</a> and a
  76.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  77.      * interface</a>.
  78.      * </p>
  79.      * <p>
  80.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  81.      * If such time systems are used, it must be initialized before parsing by calling {@link
  82.      * #withMissionReferenceDate(AbsoluteDate)}.
  83.      * </p>
  84.      * <p>
  85.      * The IERS conventions to use is not set here. If it is needed in order to
  86.      * parse some reference frames or UT1 time scale, it must be initialized before
  87.      * parsing by calling {@link #withConventions(IERSConventions)}.
  88.      * </p>
  89.      * <p>
  90.      * The international designator parameters (launch year, launch number and
  91.      * launch piece) are not set here. If they are needed, they must be initialized before
  92.      * parsing by calling {@link #withInternationalDesignator(int, int, String)}
  93.      * </p>
  94.      * <p>
  95.      * The default interpolation degree is not set here. It is set to one by default. If another value
  96.      * is needed it must be initialized before parsing by calling {@link #withInterpolationDegree(int)}
  97.      * </p>
  98.      *
  99.      * <p>This method uses the {@link DataContext#getDefault() default data context}. See
  100.      * {@link #withDataContext(DataContext)}.
  101.      */
  102.     @DefaultDataContext
  103.     public AEMParser() {
  104.         this(DataContext.getDefault());
  105.     }

  107.     /**
  108.      * Constructor with data context.
  109.      * <p>
  110.      * This class is immutable, and hence thread safe. When parts
  111.      * must be changed, such as reference date for Mission Elapsed Time or
  112.      * Mission Relative Time time systems, or the gravitational coefficient or
  113.      * the IERS conventions, the various {@code withXxx} methods must be called,
  114.      * which create a new immutable instance with the new parameters. This
  115.      * is a combination of the
  116.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  117.      * pattern</a> and a
  118.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  119.      * interface</a>.
  120.      * </p>
  121.      * <p>
  122.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  123.      * If such time systems are used, it must be initialized before parsing by calling {@link
  124.      * #withMissionReferenceDate(AbsoluteDate)}.
  125.      * </p>
  126.      * <p>
  127.      * The IERS conventions to use is not set here. If it is needed in order to
  128.      * parse some reference frames or UT1 time scale, it must be initialized before
  129.      * parsing by calling {@link #withConventions(IERSConventions)}.
  130.      * </p>
  131.      * <p>
  132.      * The international designator parameters (launch year, launch number and
  133.      * launch piece) are not set here. If they are needed, they must be initialized before
  134.      * parsing by calling {@link #withInternationalDesignator(int, int, String)}
  135.      * </p>
  136.      * <p>
  137.      * The default interpolation degree is not set here. It is set to one by default. If another value
  138.      * is needed it must be initialized before parsing by calling {@link #withInterpolationDegree(int)}
  139.      * </p>
  140.      *
  141.      * @param dataContext used by the parser.
  142.      * @see #AEMParser()
  143.      * @see #withDataContext(DataContext)
  144.      */
  145.     public AEMParser(final DataContext dataContext) {
  146.         this(AbsoluteDate.FUTURE_INFINITY, Double.NaN, null, true, 0, 0, "", 1, dataContext);
  147.     }

  149.     /**
  150.      * Complete constructor.
  151.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  152.      * @param mu gravitational coefficient
  153.      * @param conventions IERS Conventions
  154.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  155.      * @param launchYear launch year for TLEs
  156.      * @param launchNumber launch number for TLEs
  157.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  158.      * @param interpolationDegree default interpolation degree
  159.      * @param dataContext used to retrieve frames, time scales, etc.
  160.      */
  161.     private AEMParser(final AbsoluteDate missionReferenceDate, final double mu,
  162.                       final IERSConventions conventions, final boolean simpleEOP,
  163.                       final int launchYear, final int launchNumber,
  164.                       final String launchPiece, final int interpolationDegree,
  165.                       final DataContext dataContext) {
  166.         super(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber,
  167.                 launchPiece, dataContext);
  168.         this.interpolationDegree = interpolationDegree;
  169.     }

  171.     /** {@inheritDoc} */
  172.     public AEMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  173.         return new AEMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  174.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  175.                              getInterpolationDegree(), getDataContext());
  176.     }

  178.     /** {@inheritDoc} */
  179.     public AEMParser withMu(final double newMu) {
  180.         return new AEMParser(getMissionReferenceDate(), newMu, getConventions(), isSimpleEOP(),
  181.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  182.                              getInterpolationDegree(), getDataContext());
  183.     }

  185.     /** {@inheritDoc} */
  186.     public AEMParser withConventions(final IERSConventions newConventions) {
  187.         return new AEMParser(getMissionReferenceDate(), getMu(), newConventions, isSimpleEOP(),
  188.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  189.                              getInterpolationDegree(), getDataContext());
  190.     }

  192.     /** {@inheritDoc} */
  193.     public AEMParser withSimpleEOP(final boolean newSimpleEOP) {
  194.         return new AEMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  195.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  196.                              getInterpolationDegree(), getDataContext());
  197.     }

  199.     /** {@inheritDoc} */
  200.     public AEMParser withInternationalDesignator(final int newLaunchYear,
  201.                                                  final int newLaunchNumber,
  202.                                                  final String newLaunchPiece) {
  203.         return new AEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  204.                              newLaunchYear, newLaunchNumber, newLaunchPiece,
  205.                              getInterpolationDegree(), getDataContext());
  206.     }

  208.     /** {@inheritDoc} */
  209.     @Override
  210.     public AEMParser withDataContext(final DataContext dataContext) {
  211.         return new AEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  212.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  213.                              getInterpolationDegree(), dataContext);
  214.     }

  216.     /** Set default interpolation degree.
  217.      * <p>
  218.      * This method may be used to set a default interpolation degree which will be used
  219.      * when no interpolation degree is parsed in the meta-data of the file. Upon instantiation
  220.      * with {@link #AEMParser(DataContext)} the default interpolation degree is one.
  221.      * </p>
  222.      * @param newInterpolationDegree default interpolation degree to use while parsing
  223.      * @return a new instance, with interpolation degree data replaced
  224.      * @see #getInterpolationDegree()
  225.      * @since 10.3
  226.      */
  227.     public AEMParser withInterpolationDegree(final int newInterpolationDegree) {
  228.         return new AEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  229.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  230.                              newInterpolationDegree, getDataContext());
  231.     }

  233.     /**
  234.      * Set the local spacecraft body reference frame A.
  235.      * <p>
  236.      * This frame corresponds to {@link Keyword#REF_FRAME_A} key in AEM file.
  237.      * This method may be used to set a reference frame "A" which will be used
  238.      * if the frame parsed in the file does not correspond to a default frame available
  239.      * in {@link CCSDSFrame} (e.g. SC_BODY_1, ACTUATOR_1, etc.).
  240.      * According to CCSDS ADM documentation, it is the responsibility of the end user
  241.      * to have an understanding of the location of these frames for their particular object.
  242.      * </p>
  243.      * @param frame the frame to set
  244.      */
  245.     public void setLocalScBodyReferenceFrameA(final Frame frame) {
  246.         this.localScBodyReferenceFrameA = frame;
  247.     }

  249.     /**
  250.      * Set the local spacecraft body reference frame B.
  251.      * <p>
  252.      * This frame corresponds to {@link Keyword#REF_FRAME_B} key in AEM file.
  253.      * This method may be used to set a reference frame "B" which will be used
  254.      * if the frame parsed in the file does not correspond to a default frame available
  255.      * in {@link CCSDSFrame} (e.g. SC_BODY_1, ACTUATOR_1, etc.).
  256.      * According to CCSDS ADM documentation, it is the responsibility of the end user
  257.      * to have an understanding of the location of these frames for their particular object.
  258.      * </p>
  259.      * @param frame the frame to set
  260.      */
  261.     public void setLocalScBodyReferenceFrameB(final Frame frame) {
  262.         this.localScBodyReferenceFrameB = frame;
  263.     }

  265.     /** Get default interpolation degree.
  266.      * @return interpolationDegree default interpolation degree to use while parsing
  267.      * @see #withInterpolationDegree(int)
  268.      * @since 10.3
  269.      */
  270.     public int getInterpolationDegree() {
  271.         return interpolationDegree;
  272.     }

  274.     /** {@inheritDoc} */
  275.     @Override
  276.     public AEMFile parse(final String fileName) {
  277.         return (AEMFile) super.parse(fileName);
  278.     }

  280.     /** {@inheritDoc} */
  281.     @Override
  282.     public AEMFile parse(final InputStream stream) {
  283.         return (AEMFile) super.parse(stream);
  284.     }

  286.     /** {@inheritDoc} */
  287.     @Override
  288.     public AEMFile parse(final InputStream stream, final String fileName) {
  289.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  290.             return parse(reader, fileName);
  291.         } catch (IOException ioe) {
  292.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  293.         }
  294.     }

  296.     /** {@inheritDoc} */
  297.     @Override
  298.     public AEMFile parse(final BufferedReader reader, final String fileName) {

  300.         try {

  302.             // initialize internal data structures
  303.             final ParseInfo pi = new ParseInfo();
  304.             pi.fileName = fileName;
  305.             final AEMFile file = pi.file;

  307.             // set the additional data that has been configured prior the parsing by the user.
  308.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  309.             pi.file.setMu(getMu());
  310.             pi.file.setConventions(getConventions());
  311.             pi.file.setDataContext(getDataContext());

  313.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  314.                 ++pi.lineNumber;
  315.                 if (line.trim().length() == 0) {
  316.                     continue;
  317.                 }
  318.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  319.                 if (pi.keyValue.getKeyword() == null) {
  320.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  321.                 }
  322.                 switch (pi.keyValue.getKeyword()) {
  323.                     case CCSDS_AEM_VERS:
  324.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  325.                         break;

  327.                     case META_START:
  328.                         file.addAttitudeBlock();
  329.                         pi.lastEphemeridesBlock = file.getAttitudeBlocks().get(file.getAttitudeBlocks().size() - 1);
  330.                         pi.lastEphemeridesBlock.getMetaData().setLaunchYear(getLaunchYear());
  331.                         pi.lastEphemeridesBlock.getMetaData().setLaunchNumber(getLaunchNumber());
  332.                         pi.lastEphemeridesBlock.getMetaData().setLaunchPiece(getLaunchPiece());
  333.                         pi.lastEphemeridesBlock.setInterpolationDegree(getInterpolationDegree());
  334.                         break;

  336.                     case REF_FRAME_A:
  337.                         pi.lastEphemeridesBlock.setRefFrameAString(pi.keyValue.getValue());
  338.                         break;

  340.                     case REF_FRAME_B:
  341.                         pi.lastEphemeridesBlock.setRefFrameBString(pi.keyValue.getValue());
  342.                         break;

  344.                     case ATTITUDE_DIR:
  345.                         pi.lastEphemeridesBlock.setAttitudeDirection(pi.keyValue.getValue());
  346.                         break;

  348.                     case START_TIME:
  349.                         pi.lastEphemeridesBlock.setStartTime(parseDate(pi.keyValue.getValue(),
  350.                                                                        pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  351.                         break;

  353.                     case USEABLE_START_TIME:
  354.                         pi.lastEphemeridesBlock.setUseableStartTime(parseDate(pi.keyValue.getValue(),
  355.                                                                               pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  356.                         break;

  358.                     case USEABLE_STOP_TIME:
  359.                         pi.lastEphemeridesBlock.setUseableStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  360.                         break;

  362.                     case STOP_TIME:
  363.                         pi.lastEphemeridesBlock.setStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  364.                         break;

  366.                     case ATTITUDE_TYPE:
  367.                         pi.lastEphemeridesBlock.setAttitudeType(pi.keyValue.getValue());
  368.                         break;

  370.                     case QUATERNION_TYPE:
  371.                         final boolean isFirst = (pi.keyValue.getValue().equals("FIRST")) ? true : false;
  372.                         pi.lastEphemeridesBlock.setIsFirst(isFirst);
  373.                         break;

  375.                     case EULER_ROT_SEQ:
  376.                         pi.lastEphemeridesBlock.setEulerRotSeq(pi.keyValue.getValue());
  377.                         pi.lastEphemeridesBlock.setRotationOrder(AEMRotationOrder.getRotationOrder(pi.keyValue.getValue()));
  378.                         break;

  380.                     case RATE_FRAME:
  381.                         pi.lastEphemeridesBlock.setRateFrameString(pi.keyValue.getValue());
  382.                         break;

  384.                     case INTERPOLATION_METHOD:
  385.                         pi.lastEphemeridesBlock.setInterpolationMethod(pi.keyValue.getValue());
  386.                         break;

  388.                     case INTERPOLATION_DEGREE:
  389.                         pi.lastEphemeridesBlock.setInterpolationDegree(Integer.parseInt(pi.keyValue.getValue()));
  390.                         break;

  392.                     case META_STOP:
  393.                         // Set attitude reference frame
  394.                         parseReferenceFrame(pi);
  395.                         // Read attitude ephemeris data lines
  396.                         parseEphemeridesDataLines(reader, pi);
  397.                         break;

  399.                     default:
  400.                         boolean parsed = false;
  401.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  402.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  403.                         if (pi.lastEphemeridesBlock != null) {
  404.                             parsed = parsed || parseMetaDataEntry(pi.keyValue,
  405.                                                                   pi.lastEphemeridesBlock.getMetaData(), pi.commentTmp);
  406.                         }
  407.                         if (!parsed) {
  408.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  409.                         }
  410.                 }

  412.             }

  414.             file.checkTimeSystems();
  415.             return file;

  417.         } catch (IOException ioe) {
  418.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  419.         }

  421.     }

  423.     /**
  424.      * Parse an attitude ephemeris data line and add its content
  425.      * to the attitude ephemerides block.
  426.      * @param reader the reader
  427.      * @param pi the parser info
  428.      * @exception IOException if an error occurs while reading from the stream
  429.      */
  430.     private void parseEphemeridesDataLines(final BufferedReader reader,  final ParseInfo pi)
  431.         throws IOException {

  433.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {

  435.             ++pi.lineNumber;
  436.             if (line.trim().length() > 0) {
  437.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  438.                 if (pi.keyValue.getKeyword() == null) {
  439.                     try (Scanner sc = new Scanner(line)) {
  440.                         final AbsoluteDate date = parseDate(sc.next(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  441.                         // Create an array with the maximum possible size
  442.                         final double[] attitudeData = new double[MAX_SIZE];
  443.                         int index = 0;
  444.                         while (sc.hasNext()) {
  445.                             attitudeData[index++] = Double.parseDouble(sc.next());
  446.                         }
  447.                         final AEMAttitudeType attType = AEMAttitudeType.getAttitudeType(pi.lastEphemeridesBlock.getAttitudeType());
  448.                         final RotationOrder rotationOrder = pi.lastEphemeridesBlock.getRotationOrder();

  450.                         final TimeStampedAngularCoordinates epDataLine = attType.getAngularCoordinates(date, attitudeData,
  451.                                                                                                        pi.lastEphemeridesBlock.isFirst(),
  452.                                                                                                        rotationOrder);
  453.                         pi.lastEphemeridesBlock.getAttitudeDataLines().add(epDataLine);
  454.                         pi.lastEphemeridesBlock.updateAngularDerivativesFilter(attType.getAngularDerivativesFilter());
  455.                     } catch (NumberFormatException nfe) {
  456.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  457.                                                   pi.lineNumber, pi.fileName, line);
  458.                     }
  459.                 } else {
  460.                     switch (pi.keyValue.getKeyword()) {

  462.                         case DATA_START:
  463.                             // Do nothing
  464.                             break;

  466.                         case DATA_STOP:
  467.                             pi.lastEphemeridesBlock.setAttitudeDataLinesComment(pi.commentTmp);
  468.                             pi.commentTmp.clear();
  469.                             //pi.lineNumber--;
  470.                             reader.reset();
  471.                             reader.readLine();
  472.                             return;

  474.                         case COMMENT:
  475.                             pi.commentTmp.add(pi.keyValue.getValue());
  476.                             break;

  478.                         default :
  479.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  480.                     }
  481.                 }
  482.             }
  483.             reader.mark(300);

  485.         }
  486.     }

  488.     /**
  489.      * Parse the reference attitude frame.
  490.      * @param pi the parser info
  491.      */
  492.     private void parseReferenceFrame(final ParseInfo pi) {

  494.         // Reference frame A
  495.         final String frameAString = DASH.matcher(j2000Check(pi.lastEphemeridesBlock.getRefFrameAString())).replaceAll("");
  496.         final Frame frameA = isDefinedFrame(frameAString) ?
  497.                                     CCSDSFrame.valueOf(frameAString).getFrame(getConventions(), isSimpleEOP(), getDataContext()) :
  498.                                         localScBodyReferenceFrameA;

  500.         // Reference frame B
  501.         final String frameBString = DASH.matcher(j2000Check(pi.lastEphemeridesBlock.getRefFrameBString())).replaceAll("");
  502.         final Frame frameB = isDefinedFrame(frameBString) ?
  503.                                     CCSDSFrame.valueOf(frameBString).getFrame(getConventions(), isSimpleEOP(), getDataContext()) :
  504.                                         localScBodyReferenceFrameB;

  506.         // Set the attitude reference frame
  507.         final String direction = pi.lastEphemeridesBlock.getAttitudeDirection();
  508.         pi.lastEphemeridesBlock.setReferenceFrame("A2B".equals(direction) ? frameA : frameB);

  510.     }

  512.     /**
  513.      * Check if frame name is "J2000".
  514.      * <p>
  515.      * If yes, the name is changed to "EME2000" in order to match
  516.      * predefined CCSDS frame names.
  517.      * </p>
  518.      * @param frameName frame name
  519.      * @return the nex name
  520.      */
  521.     private static String j2000Check(final String frameName) {
  522.         return "J2000".equals(frameName) ? "EME2000" : frameName;
  523.     }

  525.     /**
  526.      * Verify if the given frame is defined in predefined CCSDS frames.
  527.      * @param frameName frame name
  528.      * @return true is the frame is known
  529.      */
  530.     private static boolean isDefinedFrame(final String frameName) {
  531.         // Loop on CCSDS frames
  532.         for (CCSDSFrame ccsdsFrame : CCSDSFrame.values()) {
  533.             // CCSDS frame name is defined in enumerate
  534.             if (ccsdsFrame.name().equals(frameName)) {
  535.                 return true;
  536.             }
  537.         }
  538.         // No match found
  539.         return false;
  540.     }

  542.     /** Private class used to stock AEM parsing info. */
  543.     private static class ParseInfo {

  545.         /** Ephemerides block being parsed. */
  546.         private AEMFile.AttitudeEphemeridesBlock lastEphemeridesBlock;

  548.         /** Name of the file. */
  549.         private String fileName;

  551.         /** Current line number. */
  552.         private int lineNumber;

  554.         /** AEM file being read. */
  555.         private AEMFile file;

  557.         /** Key value of the line being read. */
  558.         private KeyValue keyValue;

  560.         /** Stored comments. */
  561.         private List<String> commentTmp;

  563.         /** Create a new {@link ParseInfo} object. */
  564.         protected ParseInfo() {
  565.             lineNumber = 0;
  566.             file       = new AEMFile();
  567.             commentTmp = new ArrayList<String>();
  568.         }
  569.     }

  571.     /** Util class to convert the Euler rotation sequence to {@link RotationOrder}. */
  572.     public enum AEMRotationOrder {

  574.         /** This ordered set of rotations is around X, then around Y, then around Z. */
  575.         XYZ("123", RotationOrder.XYZ),

  577.         /** This ordered set of rotations is around X, then around Z, then around Y. */
  578.         XZY("132", RotationOrder.XZY),

  580.         /** This ordered set of rotations is around Y, then around X, then around Z. */
  581.         YXZ("213", RotationOrder.YXZ),

  583.         /** This ordered set of rotations is around Y, then around Z, then around X. */
  584.         YZX("231", RotationOrder.YZX),

  586.         /** This ordered set of rotations is around Z, then around X, then around Y. */
  587.         ZXY("312", RotationOrder.ZXY),

  589.         /** This ordered set of rotations is around Z, then around Y, then around X. */
  590.         ZYX("321", RotationOrder.ZYX),

  592.         /** This ordered set of rotations is around X, then around Y, then around X. */
  593.         XYX("121", RotationOrder.XYX),

  595.         /** This ordered set of rotations is around X, then around Z, then around X. */
  596.         XZX("131", RotationOrder.XZX),

  598.         /** This ordered set of rotations is around Y, then around X, then around Y. */
  599.         YXY("212", RotationOrder.YXY),

  601.         /** This ordered set of rotations is around Y, then around Z, then around Y. */
  602.         YZY("232", RotationOrder.YZY),

  604.         /** This ordered set of rotations is around Z, then around X, then around Z. */
  605.         ZXZ("313", RotationOrder.ZXZ),

  607.         /** This ordered set of rotations is around Z, then around Y, then around Z. */
  608.         ZYZ("323", RotationOrder.ZYZ);

  610.         /** Codes map. */
  611.         private static final Map<String, RotationOrder> CODES_MAP = new HashMap<String, RotationOrder>();
  612.         static {
  613.             for (final AEMRotationOrder type : values()) {
  614.                 CODES_MAP.put(type.getName(), type.getRotationOrder());
  615.             }
  616.         }

  618.         /** Rotation order. */
  619.         private final RotationOrder order;

  621.         /** Name. */
  622.         private final String name;

  624.         /**
  625.          * Constructor.
  626.          * @param name name of the rotation
  627.          * @param order rotation order
  628.          */
  629.         AEMRotationOrder(final String name,
  630.                          final RotationOrder order) {
  631.             this.name  = name;
  632.             this.order = order;
  633.         }

  635.         /**
  636.          * Get the name of the AEM rotation order.
  637.          * @return name
  638.          */
  639.         private String getName() {
  640.             return name;
  641.         }

  643.         /**
  644.          * Get the rotation order.
  645.          * @return rotation order
  646.          */
  647.         private RotationOrder getRotationOrder() {
  648.             return order;
  649.         }

  651.         /**
  652.          * Get the rotation order for the given name.
  653.          * @param orderName name of the rotation order (e.g. "123")
  654.          * @return the corresponding rotation order
  655.          */
  656.         public static RotationOrder getRotationOrder(final String orderName) {
  657.             final RotationOrder type = CODES_MAP.get(orderName);
  658.             if (type == null) {
  659.                 // Invalid rotation sequence
  660.                 throw new OrekitException(OrekitMessages.CCSDS_AEM_INVALID_ROTATION_SEQUENCE, orderName);
  661.             }
  662.             return type;
  663.         }

  665.     }

  667. }
Created with JaCoCo 0.8.6.202009150832