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.     public OPMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  138.         return new OPMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  139.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  140.     }

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

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

  154.     /** {@inheritDoc} */
  155.     public OPMParser withSimpleEOP(final boolean newSimpleEOP) {
  156.         return new OPMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  157.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  158.     }

  160.     /** {@inheritDoc} */
  161.     public OPMParser withInternationalDesignator(final int newLaunchYear,
  162.                                                  final int newLaunchNumber,
  163.                                                  final String newLaunchPiece) {
  164.         return new OPMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  165.                              newLaunchYear, newLaunchNumber, newLaunchPiece, getDataContext());
  166.     }

  168.     @Override
  169.     public OPMParser withDataContext(final DataContext newDataContext) {
  170.         return new OPMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  171.                 getLaunchYear(), getLaunchNumber(), getLaunchPiece(), newDataContext);
  172.     }

  174.     /** {@inheritDoc} */
  175.     @Override
  176.     public OPMFile parse(final String fileName) {
  177.         return (OPMFile) super.parse(fileName);
  178.     }

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

  186.     /** {@inheritDoc} */
  187.     public OPMFile parse(final InputStream stream, final String fileName) {

  189.         try {
  190.             final BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8));
  191.             // initialize internal data structures
  192.             final ParseInfo pi = new ParseInfo();
  193.             pi.fileName = fileName;
  194.             final OPMFile file = pi.file;

  196.             // set the additional data that has been configured prior the parsing by the user.
  197.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  198.             pi.file.setMuSet(getMu());
  199.             pi.file.setConventions(getConventions());
  200.             pi.file.setDataContext(getDataContext());
  201.             pi.file.getMetaData().setLaunchYear(getLaunchYear());
  202.             pi.file.getMetaData().setLaunchNumber(getLaunchNumber());
  203.             pi.file.getMetaData().setLaunchPiece(getLaunchPiece());

  205.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  206.                 ++pi.lineNumber;
  207.                 if (line.trim().length() == 0) {
  208.                     continue;
  209.                 }
  210.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  211.                 if (pi.keyValue.getKeyword() == null) {
  212.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  213.                 }
  214.                 switch (pi.keyValue.getKeyword()) {

  216.                     case CCSDS_OPM_VERS:
  217.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  218.                         break;

  220.                     case X:
  221.                         pi.x = pi.keyValue.getDoubleValue() * 1000;
  222.                         break;

  224.                     case Y:
  225.                         pi.y = pi.keyValue.getDoubleValue() * 1000;
  226.                         break;

  228.                     case Z:
  229.                         pi.z = pi.keyValue.getDoubleValue() * 1000;
  230.                         break;

  232.                     case X_DOT:
  233.                         pi.x_dot = pi.keyValue.getDoubleValue() * 1000;
  234.                         break;

  236.                     case Y_DOT:
  237.                         pi.y_dot = pi.keyValue.getDoubleValue() * 1000;
  238.                         break;

  240.                     case Z_DOT:
  241.                         pi.z_dot = pi.keyValue.getDoubleValue() * 1000;
  242.                         break;

  244.                     case MAN_EPOCH_IGNITION:
  245.                         if (pi.maneuver != null) {
  246.                             file.addManeuver(pi.maneuver);
  247.                         }
  248.                         pi.maneuver = new OPMFile.Maneuver();
  249.                         pi.maneuver.setEpochIgnition(parseDate(pi.keyValue.getValue(), file.getMetaData().getTimeSystem()));
  250.                         if (!pi.commentTmp.isEmpty()) {
  251.                             pi.maneuver.setComment(pi.commentTmp);
  252.                             pi.commentTmp.clear();
  253.                         }
  254.                         break;

  256.                     case MAN_DURATION:
  257.                         pi.maneuver.setDuration(pi.keyValue.getDoubleValue());
  258.                         break;

  260.                     case MAN_DELTA_MASS:
  261.                         pi.maneuver.setDeltaMass(pi.keyValue.getDoubleValue());
  262.                         break;

  264.                     case MAN_REF_FRAME:
  265.                         final CCSDSFrame manFrame = parseCCSDSFrame(pi.keyValue.getValue());
  266.                         if (manFrame.isLof()) {
  267.                             pi.maneuver.setRefLofType(manFrame.getLofType());
  268.                         } else {
  269.                             pi.maneuver.setRefFrame(manFrame.getFrame(
  270.                                     getConventions(),
  271.                                     isSimpleEOP(),
  272.                                     getDataContext()));
  273.                         }
  274.                         break;

  276.                     case MAN_DV_1:
  277.                         pi.maneuver.setdV(new Vector3D(pi.keyValue.getDoubleValue() * 1000,
  278.                                                        pi.maneuver.getDV().getY(),
  279.                                                        pi.maneuver.getDV().getZ()));
  280.                         break;

  282.                     case MAN_DV_2:
  283.                         pi.maneuver.setdV(new Vector3D(pi.maneuver.getDV().getX(),
  284.                                                        pi.keyValue.getDoubleValue() * 1000,
  285.                                                        pi.maneuver.getDV().getZ()));
  286.                         break;

  288.                     case MAN_DV_3:
  289.                         pi.maneuver.setdV(new Vector3D(pi.maneuver.getDV().getX(),
  290.                                                        pi.maneuver.getDV().getY(),
  291.                                                        pi.keyValue.getDoubleValue() * 1000));
  292.                         break;

  294.                     default:
  295.                         boolean parsed = false;
  296.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  297.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  298.                         parsed = parsed || parseMetaDataEntry(pi.keyValue, file.getMetaData(), pi.commentTmp);
  299.                         parsed = parsed || parseGeneralStateDataEntry(pi.keyValue, file, pi.commentTmp);
  300.                         if (!parsed) {
  301.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  302.                         }
  303.                 }

  305.             }

  307.             file.setPosition(new Vector3D(pi.x, pi.y, pi.z));
  308.             file.setVelocity(new Vector3D(pi.x_dot, pi.y_dot, pi.z_dot));
  309.             if (pi.maneuver != null) {
  310.                 file.addManeuver(pi.maneuver);
  311.             }
  312.             reader.close();
  313.             return file;
  314.         } catch (IOException ioe) {
  315.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  316.         }
  317.     }

  319.     /** Private class used to stock OPM parsing info.
  320.      * @author sports
  321.      */
  322.     private static class ParseInfo {

  324.         /** OPM file being read. */
  325.         private OPMFile file;

  327.         /** Name of the file. */
  328.         private String fileName;

  330.         /** Current line number. */
  331.         private int lineNumber;

  333.         /** Key value of the line being read. */
  334.         private KeyValue keyValue;

  336.         /** Stored comments. */
  337.         private List<String> commentTmp;

  339.         /** First component of position vector. */
  340.         private double x;

  342.         /** Second component of position vector. */
  343.         private double y;

  345.         /** Third component of position vector. */
  346.         private double z;

  348.         /** First component of velocity vector. */
  349.         private double x_dot;

  351.         /** Second component of velocity vector. */
  352.         private double y_dot;

  354.         /** Third component of velocity vector. */
  355.         private double z_dot;

  357.         /** Current maneuver. */
  358.         private OPMFile.Maneuver maneuver;

  360.         /** Create a new {@link ParseInfo} object. */
  361.         protected ParseInfo() {
  362.             file       = new OPMFile();
  363.             lineNumber = 0;
  364.             commentTmp = new ArrayList<String>();
  365.             maneuver   = null;
  366.         }
  367.     }
  368. }
Created with JaCoCo 0.8.5.201910111838