OEMParser.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;
  26. import java.util.Scanner;

  28. import org.hipparchus.exception.DummyLocalizable;
  29. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  30. import org.hipparchus.linear.MatrixUtils;
  31. import org.hipparchus.linear.RealMatrix;
  32. import org.orekit.annotation.DefaultDataContext;
  33. import org.orekit.data.DataContext;
  34. import org.orekit.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;
  36. import org.orekit.files.general.EphemerisFileParser;
  37. import org.orekit.frames.Frame;
  38. import org.orekit.frames.LOFType;
  39. import org.orekit.time.AbsoluteDate;
  40. import org.orekit.utils.IERSConventions;
  41. import org.orekit.utils.TimeStampedPVCoordinates;

  43. /**
  44.  * A parser for the CCSDS OEM (Orbit Ephemeris Message).
  45.  * @author sports
  46.  * @since 6.1
  47.  */
  48. public class OEMParser extends ODMParser implements EphemerisFileParser {

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

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

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

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

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

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

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

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

  181.     @Override
  182.     public OEMParser withDataContext(final DataContext dataContext) {
  183.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  184.                 getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  185.                 dataContext);
  186.     }

  188.     /** {@inheritDoc} */
  189.     @Override
  190.     public OEMFile parse(final String fileName) {
  191.         return (OEMFile) super.parse(fileName);
  192.     }

  194.     /** {@inheritDoc} */
  195.     @Override
  196.     public OEMFile parse(final InputStream stream) {
  197.         return (OEMFile) super.parse(stream);
  198.     }

  200.     /** {@inheritDoc} */
  201.     public OEMFile parse(final InputStream stream, final String fileName) {
  202.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  203.             return parse(reader, fileName);
  204.         } catch (IOException ioe) {
  205.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  206.         }
  207.     }

  209.     @Override
  210.     public OEMFile parse(final BufferedReader reader, final String fileName) {

  212.         try {

  214.             // initialize internal data structures
  215.             final ParseInfo pi = new ParseInfo();
  216.             pi.fileName = fileName;
  217.             final OEMFile file = pi.file;

  219.             // set the additional data that has been configured prior the parsing by the user.
  220.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  221.             pi.file.setMuSet(getMu());
  222.             pi.file.setConventions(getConventions());
  223.             pi.file.setDataContext(getDataContext());

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

  239.                     case META_START:
  240.                         file.addEphemeridesBlock();
  241.                         pi.lastEphemeridesBlock = file.getEphemeridesBlocks().get(file.getEphemeridesBlocks().size() - 1);
  242.                         pi.lastEphemeridesBlock.getMetaData().setLaunchYear(getLaunchYear());
  243.                         pi.lastEphemeridesBlock.getMetaData().setLaunchNumber(getLaunchNumber());
  244.                         pi.lastEphemeridesBlock.getMetaData().setLaunchPiece(getLaunchPiece());
  245.                         break;

  247.                     case START_TIME:
  248.                         pi.lastEphemeridesBlock.setStartTime(parseDate(pi.keyValue.getValue(),
  249.                                                                        pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  250.                         break;

  252.                     case USEABLE_START_TIME:
  253.                         pi.lastEphemeridesBlock.setUseableStartTime(parseDate(pi.keyValue.getValue(),
  254.                                                                               pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  255.                         break;

  257.                     case USEABLE_STOP_TIME:
  258.                         pi.lastEphemeridesBlock.setUseableStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  259.                         break;

  261.                     case STOP_TIME:
  262.                         pi.lastEphemeridesBlock.setStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  263.                         break;

  265.                     case INTERPOLATION:
  266.                         pi.lastEphemeridesBlock.setInterpolationMethod(pi.keyValue.getValue());
  267.                         break;

  269.                     case INTERPOLATION_DEGREE:
  270.                         pi.lastEphemeridesBlock.setInterpolationDegree(Integer .parseInt(pi.keyValue.getValue()));
  271.                         break;

  273.                     case META_STOP:
  274.                         file.setMuUsed();
  275.                         parseEphemeridesDataLines(reader, pi);
  276.                         break;

  278.                     case COVARIANCE_START:
  279.                         parseCovarianceDataLines(reader, pi);
  280.                         break;

  282.                     default:
  283.                         boolean parsed = false;
  284.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  285.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  286.                         if (pi.lastEphemeridesBlock != null) {
  287.                             parsed = parsed || parseMetaDataEntry(pi.keyValue,
  288.                                                                   pi.lastEphemeridesBlock.getMetaData(), pi.commentTmp);
  289.                             if (parsed && pi.keyValue.getKeyword() == Keyword.REF_FRAME_EPOCH) {
  290.                                 pi.lastEphemeridesBlock.setHasRefFrameEpoch(true);
  291.                             }
  292.                         }
  293.                         if (!parsed) {
  294.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  295.                         }
  296.                 }
  297.             }
  298.             file.checkTimeSystems();
  299.             return file;
  300.         } catch (IOException ioe) {
  301.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  302.         }
  303.     }

  305.     /**
  306.      * Parse an ephemeris data line and add its content to the ephemerides
  307.      * block.
  308.      *
  309.      * @param reader the reader
  310.      * @param pi the parser info
  311.      * @exception IOException if an error occurs while reading from the stream
  312.      */
  313.     private void parseEphemeridesDataLines(final BufferedReader reader,  final ParseInfo pi)
  314.         throws IOException {

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

  318.             ++pi.lineNumber;
  319.             if (line.trim().length() > 0) {
  320.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  321.                 if (pi.keyValue.getKeyword() == null) {
  322.                     Scanner sc = null;
  323.                     try {
  324.                         sc = new Scanner(line);
  325.                         final AbsoluteDate date = parseDate(sc.next(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  326.                         final Vector3D position = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  327.                                                                Double.parseDouble(sc.next()) * 1000,
  328.                                                                Double.parseDouble(sc.next()) * 1000);
  329.                         final Vector3D velocity = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  330.                                                                Double.parseDouble(sc.next()) * 1000,
  331.                                                                Double.parseDouble(sc.next()) * 1000);
  332.                         Vector3D acceleration = Vector3D.NaN;
  333.                         boolean hasAcceleration = false;
  334.                         if (sc.hasNext()) {
  335.                             acceleration = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  336.                                                         Double.parseDouble(sc.next()) * 1000,
  337.                                                         Double.parseDouble(sc.next()) * 1000);
  338.                             hasAcceleration = true;
  339.                         }
  340.                         final TimeStampedPVCoordinates epDataLine;
  341.                         if (hasAcceleration) {
  342.                             epDataLine = new TimeStampedPVCoordinates(date, position, velocity, acceleration);
  343.                         } else {
  344.                             epDataLine = new TimeStampedPVCoordinates(date, position, velocity);
  345.                         }
  346.                         pi.lastEphemeridesBlock.getEphemeridesDataLines().add(epDataLine);
  347.                         pi.lastEphemeridesBlock.updateHasAcceleration(hasAcceleration);
  348.                     } catch (NumberFormatException nfe) {
  349.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  350.                                                   pi.lineNumber, pi.fileName, line);
  351.                     } finally {
  352.                         if (sc != null) {
  353.                             sc.close();
  354.                         }
  355.                     }
  356.                 } else {
  357.                     switch (pi.keyValue.getKeyword()) {
  358.                         case META_START:
  359.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  360.                             pi.commentTmp.clear();
  361.                             pi.lineNumber--;
  362.                             reader.reset();
  363.                             return;
  364.                         case COVARIANCE_START:
  365.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  366.                             pi.commentTmp.clear();
  367.                             pi.lineNumber--;
  368.                             reader.reset();
  369.                             return;
  370.                         case COMMENT:
  371.                             pi.commentTmp.add(pi.keyValue.getValue());
  372.                             break;
  373.                         default :
  374.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  375.                     }
  376.                 }
  377.             }
  378.             reader.mark(300);

  380.         }
  381.     }

  383.     /**
  384.      * Parse the covariance data lines, create a set of CovarianceMatrix objects
  385.      * and add them in the covarianceMatrices list of the ephemerides block.
  386.      *
  387.      * @param reader the reader
  388.      * @param pi the parser info
  389.      * @throws IOException if an error occurs while reading from the stream
  390.      */
  391.     private void parseCovarianceDataLines(final BufferedReader reader, final ParseInfo pi)
  392.         throws IOException {
  393.         int i = 0;
  394.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {

  396.             ++pi.lineNumber;
  397.             if (line.trim().length() == 0) {
  398.                 continue;
  399.             }
  400.             pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  401.             if (pi.keyValue.getKeyword() == null) {
  402.                 final Scanner sc = new Scanner(line);
  403.                 for (int j = 0; j < i + 1; j++) {
  404.                     try {
  405.                         pi.lastMatrix.addToEntry(i, j, Double.parseDouble(sc.next()));
  406.                     } catch (NumberFormatException nfe) {
  407.                         sc.close();
  408.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  409.                                                   pi.lineNumber, pi.fileName, line);
  410.                     }
  411.                     if (j != i) {
  412.                         pi.lastMatrix.addToEntry(j, i, pi.lastMatrix.getEntry(i, j));
  413.                     }
  414.                 }
  415.                 if (i == 5) {
  416.                     final OEMFile.CovarianceMatrix cm =
  417.                             new OEMFile.CovarianceMatrix(pi.epoch, pi.covRefLofType, pi.covRefFrame, pi.lastMatrix);
  418.                     pi.lastEphemeridesBlock.getCovarianceMatrices().add(cm);
  419.                 }
  420.                 i++;
  421.                 if (sc != null) {
  422.                     sc.close();
  423.                 }
  424.             } else {
  425.                 switch (pi.keyValue.getKeyword()) {
  426.                     case EPOCH :
  427.                         i                = 0;
  428.                         pi.covRefLofType = null;
  429.                         pi.covRefFrame   = null;
  430.                         pi.lastMatrix    = MatrixUtils.createRealMatrix(6, 6);
  431.                         pi.epoch         = parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  432.                         break;
  433.                     case COV_REF_FRAME :
  434.                         final CCSDSFrame frame = parseCCSDSFrame(pi.keyValue.getValue());
  435.                         if (frame.isLof()) {
  436.                             pi.covRefLofType = frame.getLofType();
  437.                             pi.covRefFrame   = null;
  438.                         } else {
  439.                             pi.covRefLofType = null;
  440.                             pi.covRefFrame   = frame.getFrame(getConventions(), isSimpleEOP(), getDataContext());
  441.                         }
  442.                         break;
  443.                     case COVARIANCE_STOP :
  444.                         return;
  445.                     default :
  446.                         throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  447.                 }
  448.             }
  449.         }
  450.     }

  452.     /** Private class used to stock OEM parsing info.
  453.      * @author sports
  454.      */
  455.     private static class ParseInfo {

  457.         /** Ephemerides block being parsed. */
  458.         private OEMFile.EphemeridesBlock lastEphemeridesBlock;

  460.         /** Name of the file. */
  461.         private String fileName;

  463.         /** Current line number. */
  464.         private int lineNumber;

  466.         /** OEM file being read. */
  467.         private OEMFile file;

  469.         /** Key value of the line being read. */
  470.         private KeyValue keyValue;

  472.         /** Stored epoch. */
  473.         private AbsoluteDate epoch;

  475.         /** Covariance reference type of Local Orbital Frame. */
  476.         private LOFType covRefLofType;

  478.         /** Covariance reference frame. */
  479.         private Frame covRefFrame;
  480.         /** Stored matrix. */
  481.         private RealMatrix lastMatrix;

  483.         /** Stored comments. */
  484.         private List<String> commentTmp;

  486.         /** Create a new {@link ParseInfo} object. */
  487.         protected ParseInfo() {
  488.             lineNumber = 0;
  489.             file = new OEMFile();
  490.             commentTmp = new ArrayList<String>();
  491.         }
  492.     }
  493. }
Created with JaCoCo 0.8.5.201910111838