OPMParser.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.exception.DummyLocalizable;
  28. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  29. import org.orekit.annotation.DefaultDataContext;
  30. import org.orekit.data.DataContext;
  31. import org.orekit.errors.OrekitException;
  32. import org.orekit.errors.OrekitMessages;
  33. import org.orekit.time.AbsoluteDate;
  34. import org.orekit.utils.IERSConventions;

  36. /** A parser for the CCSDS OPM (Orbit Parameter Message).
  37.  * @author sports
  38.  * @since 6.1
  39.  */
  40. public class OPMParser extends ODMParser {

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

  79.     /** Constructor with data context.
  80.      * <p>
  81.      * This class is immutable, and hence thread safe. When parts
  82.      * must be changed, such as reference date for Mission Elapsed Time or
  83.      * Mission Relative Time time systems, or the gravitational coefficient or
  84.      * the IERS conventions, the various {@code withXxx} methods must be called,
  85.      * which create a new immutable instance with the new parameters. This
  86.      * is a combination of the
  87.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  88.      * pattern</a> and a
  89.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  90.      * interface</a>.
  91.      * </p>
  92.      * <p>
  93.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  94.      * If such time systems are used, it must be initialized before parsing by calling {@link
  95.      * #withMissionReferenceDate(AbsoluteDate)}.
  96.      * </p>
  97.      * <p>
  98.      * The gravitational coefficient is not set here. If it is needed in order
  99.      * to parse Cartesian orbits where the value is not set in the CCSDS file, it must
  100.      * be initialized before parsing by calling {@link #withMu(double)}.
  101.      * </p>
  102.      * <p>
  103.      * The IERS conventions to use is not set here. If it is needed in order to
  104.      * parse some reference frames or UT1 time scale, it must be initialized before
  105.      * parsing by calling {@link #withConventions(IERSConventions)}.
  106.      * </p>
  107.      *
  108.      * @param dataContext used by the parser.
  109.      *
  110.      * @see #OPMParser()
  111.      * @see #withDataContext(DataContext)
  112.      * @since 10.1
  113.      */
  114.     public OPMParser(final DataContext dataContext) {
  115.         this(AbsoluteDate.FUTURE_INFINITY, Double.NaN, null, true, 0, 0, "", dataContext);
  116.     }

  118.     /** Complete constructor.
  119.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  120.      * @param mu gravitational coefficient
  121.      * @param conventions IERS Conventions
  122.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  123.      * @param launchYear launch year for TLEs
  124.      * @param launchNumber launch number for TLEs
  125.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  126.      * @param dataContext used to retrieve frames, time scales, etc.
  127.      */
  128.     private OPMParser(final AbsoluteDate missionReferenceDate, final double mu,
  129.                       final IERSConventions conventions, final boolean simpleEOP,
  130.                       final int launchYear, final int launchNumber,
  131.                       final String launchPiece, final DataContext dataContext) {
  132.         super(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber,
  133.                 launchPiece, dataContext);
  134.     }

  136.     /** {@inheritDoc} */
  137.     @Override
  138.     public OPMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  139.         return new OPMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  140.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  141.     }

  143.     /** {@inheritDoc} */
  144.     @Override
  145.     public OPMParser withMu(final double newMu) {
  146.         return new OPMParser(getMissionReferenceDate(), newMu, getConventions(), isSimpleEOP(),
  147.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  148.     }

  150.     /** {@inheritDoc} */
  151.     @Override
  152.     public OPMParser withConventions(final IERSConventions newConventions) {
  153.         return new OPMParser(getMissionReferenceDate(), getMu(), newConventions, isSimpleEOP(),
  154.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  155.     }

  157.     /** {@inheritDoc} */
  158.     @Override
  159.     public OPMParser withSimpleEOP(final boolean newSimpleEOP) {
  160.         return new OPMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  161.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  162.     }

  164.     /** {@inheritDoc} */
  165.     @Override
  166.     public OPMParser withInternationalDesignator(final int newLaunchYear,
  167.                                                  final int newLaunchNumber,
  168.                                                  final String newLaunchPiece) {
  169.         return new OPMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  170.                              newLaunchYear, newLaunchNumber, newLaunchPiece, getDataContext());
  171.     }

  173.     /** {@inheritDoc} */
  174.     @Override
  175.     public OPMParser withDataContext(final DataContext newDataContext) {
  176.         return new OPMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  177.                 getLaunchYear(), getLaunchNumber(), getLaunchPiece(), newDataContext);
  178.     }

  180.     /** {@inheritDoc} */
  181.     @Override
  182.     public OPMFile parse(final String fileName) {
  183.         return (OPMFile) super.parse(fileName);
  184.     }

  186.     /** {@inheritDoc} */
  187.     @Override
  188.     public OPMFile parse(final InputStream stream) {
  189.         return (OPMFile) super.parse(stream);
  190.     }

  192.     /** {@inheritDoc} */
  193.     @Override
  194.     public OPMFile parse(final InputStream stream, final String fileName) {

  196.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {

  198.             // initialize internal data structures
  199.             final ParseInfo pi = new ParseInfo();
  200.             pi.fileName = fileName;
  201.             final OPMFile file = pi.file;

  203.             // set the additional data that has been configured prior the parsing by the user.
  204.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  205.             pi.file.setMuSet(getMu());
  206.             pi.file.setConventions(getConventions());
  207.             pi.file.setDataContext(getDataContext());
  208.             pi.file.getMetaData().setLaunchYear(getLaunchYear());
  209.             pi.file.getMetaData().setLaunchNumber(getLaunchNumber());
  210.             pi.file.getMetaData().setLaunchPiece(getLaunchPiece());

  212.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  213.                 ++pi.lineNumber;
  214.                 if (line.trim().length() == 0) {
  215.                     continue;
  216.                 }
  217.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  218.                 if (pi.keyValue.getKeyword() == null) {
  219.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  220.                 }
  221.                 switch (pi.keyValue.getKeyword()) {

  223.                     case CCSDS_OPM_VERS:
  224.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  225.                         break;

  227.                     case X:
  228.                         pi.x = pi.keyValue.getDoubleValue() * 1000;
  229.                         break;

  231.                     case Y:
  232.                         pi.y = pi.keyValue.getDoubleValue() * 1000;
  233.                         break;

  235.                     case Z:
  236.                         pi.z = pi.keyValue.getDoubleValue() * 1000;
  237.                         break;

  239.                     case X_DOT:
  240.                         pi.x_dot = pi.keyValue.getDoubleValue() * 1000;
  241.                         break;

  243.                     case Y_DOT:
  244.                         pi.y_dot = pi.keyValue.getDoubleValue() * 1000;
  245.                         break;

  247.                     case Z_DOT:
  248.                         pi.z_dot = pi.keyValue.getDoubleValue() * 1000;
  249.                         break;

  251.                     case MAN_EPOCH_IGNITION:
  252.                         if (pi.maneuver != null) {
  253.                             file.addManeuver(pi.maneuver);
  254.                         }
  255.                         pi.maneuver = new OPMFile.Maneuver();
  256.                         pi.maneuver.setEpochIgnition(parseDate(pi.keyValue.getValue(), file.getMetaData().getTimeSystem()));
  257.                         if (!pi.commentTmp.isEmpty()) {
  258.                             pi.maneuver.setComment(pi.commentTmp);
  259.                             pi.commentTmp.clear();
  260.                         }
  261.                         break;

  263.                     case MAN_DURATION:
  264.                         pi.maneuver.setDuration(pi.keyValue.getDoubleValue());
  265.                         break;

  267.                     case MAN_DELTA_MASS:
  268.                         pi.maneuver.setDeltaMass(pi.keyValue.getDoubleValue());
  269.                         break;

  271.                     case MAN_REF_FRAME:
  272.                         final CCSDSFrame manFrame = parseCCSDSFrame(pi.keyValue.getValue());
  273.                         if (manFrame.isLof()) {
  274.                             pi.maneuver.setRefLofType(manFrame.getLofType());
  275.                         } else {
  276.                             pi.maneuver.setRefFrame(manFrame.getFrame(
  277.                                     getConventions(),
  278.                                     isSimpleEOP(),
  279.                                     getDataContext()));
  280.                         }
  281.                         break;

  283.                     case MAN_DV_1:
  284.                         pi.maneuver.setdV(new Vector3D(pi.keyValue.getDoubleValue() * 1000,
  285.                                                        pi.maneuver.getDV().getY(),
  286.                                                        pi.maneuver.getDV().getZ()));
  287.                         break;

  289.                     case MAN_DV_2:
  290.                         pi.maneuver.setdV(new Vector3D(pi.maneuver.getDV().getX(),
  291.                                                        pi.keyValue.getDoubleValue() * 1000,
  292.                                                        pi.maneuver.getDV().getZ()));
  293.                         break;

  295.                     case MAN_DV_3:
  296.                         pi.maneuver.setdV(new Vector3D(pi.maneuver.getDV().getX(),
  297.                                                        pi.maneuver.getDV().getY(),
  298.                                                        pi.keyValue.getDoubleValue() * 1000));
  299.                         break;

  301.                     default:
  302.                         boolean parsed = false;
  303.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  304.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  305.                         parsed = parsed || parseMetaDataEntry(pi.keyValue, file.getMetaData(), pi.commentTmp);
  306.                         parsed = parsed || parseGeneralStateDataEntry(pi.keyValue, file, pi.commentTmp);
  307.                         if (!parsed) {
  308.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  309.                         }
  310.                 }

  312.             }

  314.             file.setPosition(new Vector3D(pi.x, pi.y, pi.z));
  315.             file.setVelocity(new Vector3D(pi.x_dot, pi.y_dot, pi.z_dot));
  316.             if (pi.maneuver != null) {
  317.                 file.addManeuver(pi.maneuver);
  318.             }
  319.             return file;
  320.         } catch (IOException ioe) {
  321.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  322.         }
  323.     }

  325.     /** Private class used to stock OPM parsing info.
  326.      * @author sports
  327.      */
  328.     private static class ParseInfo {

  330.         /** OPM file being read. */
  331.         private OPMFile file;

  333.         /** Name of the file. */
  334.         private String fileName;

  336.         /** Current line number. */
  337.         private int lineNumber;

  339.         /** Key value of the line being read. */
  340.         private KeyValue keyValue;

  342.         /** Stored comments. */
  343.         private List<String> commentTmp;

  345.         /** First component of position vector. */
  346.         private double x;

  348.         /** Second component of position vector. */
  349.         private double y;

  351.         /** Third component of position vector. */
  352.         private double z;

  354.         /** First component of velocity vector. */
  355.         private double x_dot;

  357.         /** Second component of velocity vector. */
  358.         private double y_dot;

  360.         /** Third component of velocity vector. */
  361.         private double z_dot;

  363.         /** Current maneuver. */
  364.         private OPMFile.Maneuver maneuver;

  366.         /** Create a new {@link ParseInfo} object. */
  367.         protected ParseInfo() {
  368.             file       = new OPMFile();
  369.             lineNumber = 0;
  370.             commentTmp = new ArrayList<String>();
  371.             maneuver   = null;
  372.         }
  373.     }
  374. }
Created with JaCoCo 0.8.6.202009150832