OMMParser.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.util.FastMath;
  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 OMM (Orbiter Mean-Elements Message).
  37.  * @author sports
  38.  * @since 6.1
  39.  */
  40. public class OMMParser 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.      * <p>
  71.      * The international designator parameters (launch year, launch number and
  72.      * launch piece) are not set here. If they are needed, they must be initialized before
  73.      * parsing by calling {@link #withInternationalDesignator(int, int, String)}
  74.      * </p>
  75.      *
  76.      * <p>This method uses the {@link DataContext#getDefault() default data context}. See
  77.      * {@link #withDataContext(DataContext)}.
  78.      */
  79.     @DefaultDataContext
  80.     public OMMParser() {
  81.         this(DataContext.getDefault());
  82.     }

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

  128.     /** Complete constructor.
  129.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  130.      * @param mu gravitational coefficient
  131.      * @param conventions IERS Conventions
  132.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  133.      * @param launchYear launch year for TLEs
  134.      * @param launchNumber launch number for TLEs
  135.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  136.      * @param dataContext used to retrieve frames, time scales, etc.
  137.      */
  138.     private OMMParser(final AbsoluteDate missionReferenceDate, final double mu,
  139.                       final IERSConventions conventions, final boolean simpleEOP,
  140.                       final int launchYear, final int launchNumber,
  141.                       final String launchPiece, final DataContext dataContext) {
  142.         super(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber,
  143.                 launchPiece, dataContext);
  144.     }

  146.     /** {@inheritDoc} */
  147.     @Override
  148.     public OMMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  149.         return new OMMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  150.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  151.     }

  153.     /** {@inheritDoc} */
  154.     @Override
  155.     public OMMParser withMu(final double newMu) {
  156.         return new OMMParser(getMissionReferenceDate(), newMu, getConventions(), isSimpleEOP(),
  157.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  158.     }

  160.     /** {@inheritDoc} */
  161.     @Override
  162.     public OMMParser withConventions(final IERSConventions newConventions) {
  163.         return new OMMParser(getMissionReferenceDate(), getMu(), newConventions, isSimpleEOP(),
  164.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  165.     }

  167.     /** {@inheritDoc} */
  168.     @Override
  169.     public OMMParser withSimpleEOP(final boolean newSimpleEOP) {
  170.         return new OMMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  171.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(), getDataContext());
  172.     }

  174.     /** {@inheritDoc} */
  175.     @Override
  176.     public OMMParser withInternationalDesignator(final int newLaunchYear,
  177.                                                  final int newLaunchNumber,
  178.                                                  final String newLaunchPiece) {
  179.         return new OMMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  180.                              newLaunchYear, newLaunchNumber, newLaunchPiece, getDataContext());
  181.     }

  183.     /** {@inheritDoc} */
  184.     @Override
  185.     public OMMParser withDataContext(final DataContext newDataContext) {
  186.         return new OMMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  187.                 getLaunchYear(), getLaunchNumber(), getLaunchPiece(), newDataContext);
  188.     }

  190.     /** {@inheritDoc} */
  191.     @Override
  192.     public OMMFile parse(final String fileName) {
  193.         return (OMMFile) super.parse(fileName);
  194.     }

  196.     /** {@inheritDoc} */
  197.     @Override
  198.     public OMMFile parse(final InputStream stream) {
  199.         return (OMMFile) super.parse(stream);
  200.     }

  202.     /** {@inheritDoc} */
  203.     @Override
  204.     public OMMFile parse(final InputStream stream, final String fileName) {

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

  208.             // initialize internal data structures
  209.             final ParseInfo pi = new ParseInfo();
  210.             pi.fileName = fileName;
  211.             final OMMFile file = pi.file;

  213.             // set the additional data that has been configured prior the parsing by the user.
  214.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  215.             pi.file.setMuSet(getMu());
  216.             pi.file.setConventions(getConventions());
  217.             pi.file.setDataContext(getDataContext());
  218.             pi.file.getMetaData().setLaunchYear(getLaunchYear());
  219.             pi.file.getMetaData().setLaunchNumber(getLaunchNumber());
  220.             pi.file.getMetaData().setLaunchPiece(getLaunchPiece());

  222.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  223.                 ++pi.lineNumber;
  224.                 if (line.trim().length() == 0) {
  225.                     continue;
  226.                 }
  227.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  228.                 if (pi.keyValue.getKeyword() == null) {
  229.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  230.                 }
  231.                 switch (pi.keyValue.getKeyword()) {
  232.                     case CCSDS_OMM_VERS:
  233.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  234.                         break;

  236.                     case MEAN_ELEMENT_THEORY:
  237.                         file.getMetaData().setMeanElementTheory(pi.keyValue.getValue());
  238.                         break;

  240.                     case MEAN_MOTION:
  241.                         file.setMeanMotion(pi.keyValue.getDoubleValue() * FastMath.PI / 43200.0);
  242.                         break;

  244.                     case EPHEMERIS_TYPE:
  245.                         file.setTLERelatedParametersComment(pi.commentTmp);
  246.                         pi.commentTmp.clear();
  247.                         file.setEphemerisType(Integer.parseInt(pi.keyValue.getValue()));
  248.                         break;

  250.                     case CLASSIFICATION_TYPE:
  251.                         file.setClassificationType(pi.keyValue.getValue().charAt(0));
  252.                         break;

  254.                     case NORAD_CAT_ID:
  255.                         file.setNoradID(Integer.parseInt(pi.keyValue.getValue()));
  256.                         break;

  258.                     case ELEMENT_SET_NO:
  259.                         file.setElementSetNo(pi.keyValue.getValue());
  260.                         break;

  262.                     case REV_AT_EPOCH:
  263.                         file.setRevAtEpoch(Integer.parseInt(pi.keyValue.getValue()));
  264.                         break;

  266.                     case BSTAR:
  267.                         file.setbStar(pi.keyValue.getDoubleValue());
  268.                         break;

  270.                     case MEAN_MOTION_DOT:
  271.                         file.setMeanMotionDot(pi.keyValue.getDoubleValue() * FastMath.PI / 1.86624e9);
  272.                         break;

  274.                     case MEAN_MOTION_DDOT:
  275.                         file.setMeanMotionDotDot(pi.keyValue.getDoubleValue() *
  276.                                                  FastMath.PI / 5.3747712e13);
  277.                         break;

  279.                     default:
  280.                         boolean parsed = false;
  281.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  282.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  283.                         parsed = parsed || parseMetaDataEntry(pi.keyValue, file.getMetaData(), pi.commentTmp);
  284.                         parsed = parsed || parseGeneralStateDataEntry(pi.keyValue, file, pi.commentTmp);
  285.                         if (!parsed) {
  286.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  287.                         }
  288.                 }
  289.             }
  290.             return file;
  291.         } catch (IOException ioe) {
  292.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  293.         }
  294.     }

  296.     /** Private class used to stock OMM parsing info.
  297.      * @author sports
  298.      */
  299.     private static class ParseInfo {

  301.         /** OMM file being read. */
  302.         private OMMFile file;

  304.         /** Name of the file. */
  305.         private String fileName;

  307.         /** Current line number. */
  308.         private int lineNumber;

  310.         /** Key value of the line being read. */
  311.         private KeyValue keyValue;

  313.         /** Stored comments. */
  314.         private List<String> commentTmp;

  316.         /** Create a new {@link ParseInfo} object. */
  317.         protected ParseInfo() {
  318.             lineNumber = 0;
  319.             file = new OMMFile();
  320.             commentTmp = new ArrayList<String>();
  321.         }
  322.     }
  323. }
Created with JaCoCo 0.8.6.202009150832