APMParser.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.List;

  27. import org.hipparchus.complex.Quaternion;
  28. import org.hipparchus.exception.DummyLocalizable;
  29. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  30. import org.orekit.annotation.DefaultDataContext;
  31. import org.orekit.data.DataContext;
  32. import org.orekit.errors.OrekitException;
  33. import org.orekit.errors.OrekitMessages;
  34. import org.orekit.time.AbsoluteDate;
  35. import org.orekit.utils.IERSConventions;

  37. /**
  38.  * A parser for the CCSDS APM (Attitude Parameter Message).
  39.  * @author Bryan Cazabonne
  40.  * @since 10.2
  41.  */
  42. public class APMParser extends ADMParser {

  44.     /** Simple constructor.
  45.      * <p>
  46.      * This class is immutable, and hence thread safe. When parts
  47.      * must be changed, such as reference date for Mission Elapsed Time or
  48.      * Mission Relative Time time systems, or the gravitational coefficient or
  49.      * the IERS conventions, the various {@code withXxx} methods must be called,
  50.      * which create a new immutable instance with the new parameters. This
  51.      * is a combination of the
  52.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  53.      * pattern</a> and a
  54.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  55.      * interface</a>.
  56.      * </p>
  57.      * <p>
  58.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  59.      * If such time systems are used, it must be initialized before parsing by calling {@link
  60.      * #withMissionReferenceDate(AbsoluteDate)}.
  61.      * </p>
  62.      *
  63.      * <p>This method uses the {@link DataContext#getDefault() default data context}. See
  64.      * {@link #withDataContext(DataContext)}.
  65.      */
  66.     @DefaultDataContext
  67.     public APMParser() {
  68.         this(DataContext.getDefault());
  69.     }

  71.     /** Constructor with data context.
  72.      * <p>
  73.      * This class is immutable, and hence thread safe. When parts
  74.      * must be changed, such as reference date for Mission Elapsed Time or
  75.      * Mission Relative Time time systems, or the gravitational coefficient or
  76.      * the IERS conventions, the various {@code withXxx} methods must be called,
  77.      * which create a new immutable instance with the new parameters. This
  78.      * is a combination of the
  79.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  80.      * pattern</a> and a
  81.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  82.      * interface</a>.
  83.      * </p>
  84.      * <p>
  85.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  86.      * If such time systems are used, it must be initialized before parsing by calling {@link
  87.      * #withMissionReferenceDate(AbsoluteDate)}.
  88.      * </p>
  89.      *
  90.      * @param dataContext used by the parser.
  91.      *
  92.      * @see #APMParser()
  93.      * @see #withDataContext(DataContext)
  94.      */
  95.     public APMParser(final DataContext dataContext) {
  96.         this(AbsoluteDate.FUTURE_INFINITY, Double.NaN, null, true, 0, 0, "", dataContext);
  97.     }

  99.     /** Complete constructor.
  100.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  101.      * @param mu gravitational coefficient
  102.      * @param conventions IERS Conventions
  103.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  104.      * @param launchYear launch year for TLEs
  105.      * @param launchNumber launch number for TLEs
  106.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  107.      * @param dataContext used to retrieve frames, time scales, etc.
  108.      */
  109.     private APMParser(final AbsoluteDate missionReferenceDate, final double mu,
  110.                       final IERSConventions conventions, final boolean simpleEOP,
  111.                       final int launchYear, final int launchNumber,
  112.                       final String launchPiece, final DataContext dataContext) {
  113.         super(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber,
  114.                 launchPiece, dataContext);
  115.     }

  117.     /** {@inheritDoc} */
  118.     public APMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  119.         return new APMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  120.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  121.                              getDataContext());
  122.     }

  124.     /** {@inheritDoc} */
  125.     public APMParser withMu(final double newMu) {
  126.         return new APMParser(getMissionReferenceDate(), newMu, getConventions(), isSimpleEOP(),
  127.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  128.                              getDataContext());
  129.     }

  131.     /** {@inheritDoc} */
  132.     public APMParser withConventions(final IERSConventions newConventions) {
  133.         return new APMParser(getMissionReferenceDate(), getMu(), newConventions, isSimpleEOP(),
  134.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  135.                              getDataContext());
  136.     }

  138.     /** {@inheritDoc} */
  139.     public APMParser withSimpleEOP(final boolean newSimpleEOP) {
  140.         return new APMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  141.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  142.                              getDataContext());
  143.     }

  145.     /** {@inheritDoc} */
  146.     public APMParser withInternationalDesignator(final int newLaunchYear,
  147.                                                  final int newLaunchNumber,
  148.                                                  final String newLaunchPiece) {
  149.         return new APMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  150.                              newLaunchYear, newLaunchNumber, newLaunchPiece,
  151.                              getDataContext());
  152.     }

  154.     /** {@inheritDoc} */
  155.     @Override
  156.     public APMParser withDataContext(final DataContext dataContext) {
  157.         return new APMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  158.                 getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  159.                 dataContext);
  160.     }

  162.     /** {@inheritDoc} */
  163.     @Override
  164.     public APMFile parse(final String fileName) {
  165.         return (APMFile) super.parse(fileName);
  166.     }

  168.     /** {@inheritDoc} */
  169.     @Override
  170.     public APMFile parse(final InputStream stream) {
  171.         return (APMFile) super.parse(stream);
  172.     }

  174.     /** {@inheritDoc} */
  175.     public APMFile parse(final InputStream stream, final String fileName) {
  176.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {

  178.             // initialize internal data structures
  179.             final ParseInfo pi = new ParseInfo();
  180.             pi.fileName = fileName;
  181.             final APMFile file = pi.file;

  183.             // set the additional data that has been configured prior the parsing by the user.
  184.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  185.             pi.file.setMu(getMu());
  186.             pi.file.setConventions(getConventions());
  187.             pi.file.setDataContext(getDataContext());
  188.             pi.file.getMetaData().setLaunchYear(getLaunchYear());
  189.             pi.file.getMetaData().setLaunchNumber(getLaunchNumber());
  190.             pi.file.getMetaData().setLaunchPiece(getLaunchPiece());

  192.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  193.                 ++pi.lineNumber;
  194.                 if (line.trim().length() == 0) {
  195.                     // Blank line
  196.                     continue;
  197.                 }
  198.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  199.                 if (pi.keyValue.getKeyword() == null) {
  200.                     // Unexpected keyword. An exception is thrown.
  201.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  202.                 }

  204.                 switch (pi.keyValue.getKeyword()) {

  206.                     case CCSDS_APM_VERS:
  207.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  208.                         break;

  210.                     case Q_FRAME_A:
  211.                         file.setQuaternionFrameAString(pi.keyValue.getValue());
  212.                         break;

  214.                     case Q_FRAME_B:
  215.                         file.setQuaternionFrameBString(pi.keyValue.getValue());
  216.                         break;

  218.                     case Q_DIR:
  219.                         file.setAttitudeQuaternionDirection(pi.keyValue.getValue());
  220.                         break;

  222.                     case QC:
  223.                         pi.q0 = pi.keyValue.getDoubleValue();
  224.                         break;

  226.                     case Q1:
  227.                         pi.q1 = pi.keyValue.getDoubleValue();
  228.                         break;

  230.                     case Q2:
  231.                         pi.q2 = pi.keyValue.getDoubleValue();
  232.                         break;

  234.                     case Q3:
  235.                         pi.q3 = pi.keyValue.getDoubleValue();
  236.                         break;

  238.                     case MAN_EPOCH_START:
  239.                         if (pi.maneuver != null) {
  240.                             file.addManeuver(pi.maneuver);
  241.                         }
  242.                         pi.maneuver = new APMFile.APMManeuver();
  243.                         pi.maneuver.setEpochStart(parseDate(pi.keyValue.getValue(), file.getMetaData().getTimeSystem()));
  244.                         if (!pi.commentTmp.isEmpty()) {
  245.                             pi.maneuver.setComment(pi.commentTmp);
  246.                             pi.commentTmp.clear();
  247.                         }
  248.                         break;

  250.                     case MAN_DURATION:
  251.                         pi.maneuver.setDuration(pi.keyValue.getDoubleValue());
  252.                         break;

  254.                     case MAN_REF_FRAME:
  255.                         pi.maneuver.setRefFrameString(pi.keyValue.getValue());
  256.                         break;

  258.                     case MAN_TOR_1:
  259.                         pi.maneuver.setTorque(new Vector3D(pi.keyValue.getDoubleValue(),
  260.                                                            pi.maneuver.getTorque().getY(),
  261.                                                            pi.maneuver.getTorque().getZ()));
  262.                         break;

  264.                     case MAN_TOR_2:
  265.                         pi.maneuver.setTorque(new Vector3D(pi.maneuver.getTorque().getX(),
  266.                                                            pi.keyValue.getDoubleValue(),
  267.                                                            pi.maneuver.getTorque().getZ()));
  268.                         break;

  270.                     case MAN_TOR_3:
  271.                         pi.maneuver.setTorque(new Vector3D(pi.maneuver.getTorque().getX(),
  272.                                                            pi.maneuver.getTorque().getY(),
  273.                                                            pi.keyValue.getDoubleValue()));
  274.                         break;

  276.                     default:
  277.                         boolean parsed = false;
  278.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  279.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  280.                         parsed = parsed || parseMetaDataEntry(pi.keyValue, file.getMetaData(), pi.commentTmp);
  281.                         parsed = parsed || parseGeneralStateDataEntry(pi.keyValue, file, pi.commentTmp);
  282.                         if (!parsed) {
  283.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  284.                         }

  286.                 }

  288.             }

  290.             file.setQuaternion(new Quaternion(pi.q0, pi.q1, pi.q2, pi.q3));
  291.             if (pi.maneuver != null) {
  292.                 file.addManeuver(pi.maneuver);
  293.             }
  294.             return file;

  296.         } catch (IOException ioe) {
  297.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  298.         }
  299.     }

  301.     /** Private class used to stock APM parsing info. */
  302.     private static class ParseInfo {

  304.         /** APM file being read. */
  305.         private APMFile file;

  307.         /** Name of the file. */
  308.         private String fileName;

  310.         /** Current line number. */
  311.         private int lineNumber;

  313.         /** Key value of the line being read. */
  314.         private KeyValue keyValue;

  316.         /** Stored comments. */
  317.         private List<String> commentTmp;

  319.         /** Scalar coordinate of the quaternion. */
  320.         private double q0;

  322.         /** First component of the quaternion vector. */
  323.         private double q1;

  325.         /** Second component of the quaternion vector.. */
  326.         private double q2;

  328.         /** Third component of the quaternion vector.. */
  329.         private double q3;

  331.         /** Current maneuver. */
  332.         private APMFile.APMManeuver maneuver;

  334.         /** Create a new {@link ParseInfo} object. */
  335.         protected ParseInfo() {
  336.             file       = new APMFile();
  337.             lineNumber = 0;
  338.             commentTmp = new ArrayList<String>();
  339.             maneuver   = null;
  340.         }
  341.     }

  343. }
Created with JaCoCo 0.8.5.201910111838