OEMParser.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.util.ArrayList;
  24. import java.util.List;
  25. import java.util.Scanner;

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

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

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

  80.     /** Complete constructor.
  81.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  82.      * @param mu gravitational coefficient
  83.      * @param conventions IERS Conventions
  84.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  85.      * @param launchYear launch year for TLEs
  86.      * @param launchNumber launch number for TLEs
  87.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  88.      */
  89.     private OEMParser(final AbsoluteDate missionReferenceDate, final double mu,
  90.                       final IERSConventions conventions, final boolean simpleEOP,
  91.                       final int launchYear, final int launchNumber, final String launchPiece) {
  92.         super(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber, launchPiece);
  93.     }

  95.     /** {@inheritDoc} */
  96.     public OEMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  97.         return new OEMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  98.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece());
  99.     }

  101.     /** {@inheritDoc} */
  102.     public OEMParser withMu(final double newMu) {
  103.         return new OEMParser(getMissionReferenceDate(), newMu, getConventions(), isSimpleEOP(),
  104.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece());
  105.     }

  107.     /** {@inheritDoc} */
  108.     public OEMParser withConventions(final IERSConventions newConventions) {
  109.         return new OEMParser(getMissionReferenceDate(), getMu(), newConventions, isSimpleEOP(),
  110.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece());
  111.     }

  113.     /** {@inheritDoc} */
  114.     public OEMParser withSimpleEOP(final boolean newSimpleEOP) {
  115.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  116.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece());
  117.     }

  119.     /** {@inheritDoc} */
  120.     public OEMParser withInternationalDesignator(final int newLaunchYear,
  121.                                                  final int newLaunchNumber,
  122.                                                  final String newLaunchPiece) {
  123.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  124.                              newLaunchYear, newLaunchNumber, newLaunchPiece);
  125.     }

  127.     /** {@inheritDoc} */
  128.     @Override
  129.     public OEMFile parse(final String fileName) throws OrekitException {
  130.         return (OEMFile) super.parse(fileName);
  131.     }

  133.     /** {@inheritDoc} */
  134.     @Override
  135.     public OEMFile parse(final InputStream stream) throws OrekitException {
  136.         return (OEMFile) super.parse(stream);
  137.     }

  139.     /** {@inheritDoc} */
  140.     public OEMFile parse(final InputStream stream, final String fileName) throws OrekitException {
  141.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"))) {
  142.             return parse(reader, fileName);
  143.         } catch (IOException ioe) {
  144.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  145.         }
  146.     }

  148.     @Override
  149.     public OEMFile parse(final BufferedReader reader, final String fileName)
  150.             throws OrekitException {

  152.         try {

  154.             // initialize internal data structures
  155.             final ParseInfo pi = new ParseInfo();
  156.             pi.fileName = fileName;
  157.             final OEMFile file = pi.file;

  159.             // set the additional data that has been configured prior the parsing by the user.
  160.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  161.             pi.file.setMuSet(getMu());
  162.             pi.file.setConventions(getConventions());

  164.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  165.                 ++pi.lineNumber;
  166.                 if (line.trim().length() == 0) {
  167.                     continue;
  168.                 }
  169.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  170.                 if (pi.keyValue.getKeyword() == null) {
  171.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  172.                 }
  173.                 switch (pi.keyValue.getKeyword()) {
  174.                     case CCSDS_OEM_VERS:
  175.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  176.                         break;

  178.                     case META_START:
  179.                         file.addEphemeridesBlock();
  180.                         pi.lastEphemeridesBlock = file.getEphemeridesBlocks().get(file.getEphemeridesBlocks().size() - 1);
  181.                         pi.lastEphemeridesBlock.getMetaData().setLaunchYear(getLaunchYear());
  182.                         pi.lastEphemeridesBlock.getMetaData().setLaunchNumber(getLaunchNumber());
  183.                         pi.lastEphemeridesBlock.getMetaData().setLaunchPiece(getLaunchPiece());
  184.                         break;

  186.                     case START_TIME:
  187.                         pi.lastEphemeridesBlock.setStartTime(parseDate(pi.keyValue.getValue(),
  188.                                                                        pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  189.                         break;

  191.                     case USEABLE_START_TIME:
  192.                         pi.lastEphemeridesBlock.setUseableStartTime(parseDate(pi.keyValue.getValue(),
  193.                                                                               pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  194.                         break;

  196.                     case USEABLE_STOP_TIME:
  197.                         pi.lastEphemeridesBlock.setUseableStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  198.                         break;

  200.                     case STOP_TIME:
  201.                         pi.lastEphemeridesBlock.setStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  202.                         break;

  204.                     case INTERPOLATION:
  205.                         pi.lastEphemeridesBlock.setInterpolationMethod(pi.keyValue.getValue());
  206.                         break;

  208.                     case INTERPOLATION_DEGREE:
  209.                         pi.lastEphemeridesBlock.setInterpolationDegree(Integer .parseInt(pi.keyValue.getValue()));
  210.                         break;

  212.                     case META_STOP:
  213.                         file.setMuUsed();
  214.                         parseEphemeridesDataLines(reader, pi);
  215.                         break;

  217.                     case COVARIANCE_START:
  218.                         parseCovarianceDataLines(reader, pi);
  219.                         break;

  221.                     default:
  222.                         boolean parsed = false;
  223.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  224.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  225.                         if (pi.lastEphemeridesBlock != null) {
  226.                             parsed = parsed || parseMetaDataEntry(pi.keyValue,
  227.                                                                   pi.lastEphemeridesBlock.getMetaData(), pi.commentTmp);
  228.                             if (parsed && pi.keyValue.getKeyword() == Keyword.REF_FRAME_EPOCH) {
  229.                                 pi.lastEphemeridesBlock.setHasRefFrameEpoch(true);
  230.                             }
  231.                         }
  232.                         if (!parsed) {
  233.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  234.                         }
  235.                 }
  236.             }
  237.             file.checkTimeSystems();
  238.             return file;
  239.         } catch (IOException ioe) {
  240.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  241.         }
  242.     }

  244.     /**
  245.      * Parse an ephemeris data line and add its content to the ephemerides
  246.      * block.
  247.      *
  248.      * @param reader the reader
  249.      * @param pi the parser info
  250.      * @exception IOException if an error occurs while reading from the stream
  251.      * @exception OrekitException if a date cannot be parsed
  252.      */
  253.     private void parseEphemeridesDataLines(final BufferedReader reader,  final ParseInfo pi)
  254.         throws OrekitException, IOException {

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

  258.             ++pi.lineNumber;
  259.             if (line.trim().length() > 0) {
  260.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  261.                 if (pi.keyValue.getKeyword() == null) {
  262.                     Scanner sc = null;
  263.                     try {
  264.                         sc = new Scanner(line);
  265.                         final AbsoluteDate date = parseDate(sc.next(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  266.                         final Vector3D position = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  267.                                                                Double.parseDouble(sc.next()) * 1000,
  268.                                                                Double.parseDouble(sc.next()) * 1000);
  269.                         final Vector3D velocity = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  270.                                                                Double.parseDouble(sc.next()) * 1000,
  271.                                                                Double.parseDouble(sc.next()) * 1000);
  272.                         Vector3D acceleration = Vector3D.NaN;
  273.                         boolean hasAcceleration = false;
  274.                         if (sc.hasNext()) {
  275.                             acceleration = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  276.                                                         Double.parseDouble(sc.next()) * 1000,
  277.                                                         Double.parseDouble(sc.next()) * 1000);
  278.                             hasAcceleration = true;
  279.                         }
  280.                         final TimeStampedPVCoordinates epDataLine;
  281.                         if (hasAcceleration) {
  282.                             epDataLine = new TimeStampedPVCoordinates(date, position, velocity, acceleration);
  283.                         } else {
  284.                             epDataLine = new TimeStampedPVCoordinates(date, position, velocity);
  285.                         }
  286.                         pi.lastEphemeridesBlock.getEphemeridesDataLines().add(epDataLine);
  287.                         pi.lastEphemeridesBlock.updateHasAcceleration(hasAcceleration);
  288.                     } catch (NumberFormatException nfe) {
  289.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  290.                                                   pi.lineNumber, pi.fileName, line);
  291.                     } finally {
  292.                         if (sc != null) {
  293.                             sc.close();
  294.                         }
  295.                     }
  296.                 } else {
  297.                     switch (pi.keyValue.getKeyword()) {
  298.                         case META_START:
  299.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  300.                             pi.commentTmp.clear();
  301.                             pi.lineNumber--;
  302.                             reader.reset();
  303.                             return;
  304.                         case COVARIANCE_START:
  305.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  306.                             pi.commentTmp.clear();
  307.                             pi.lineNumber--;
  308.                             reader.reset();
  309.                             return;
  310.                         case COMMENT:
  311.                             pi.commentTmp.add(pi.keyValue.getValue());
  312.                             break;
  313.                         default :
  314.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  315.                     }
  316.                 }
  317.             }
  318.             reader.mark(300);

  320.         }
  321.     }

  323.     /**
  324.      * Parse the covariance data lines, create a set of CovarianceMatrix objects
  325.      * and add them in the covarianceMatrices list of the ephemerides block.
  326.      *
  327.      * @param reader the reader
  328.      * @param pi the parser info
  329.      * @throws IOException if an error occurs while reading from the stream
  330.      * @throws OrekitException if the frame cannot be retrieved
  331.      */
  332.     private void parseCovarianceDataLines(final BufferedReader reader, final ParseInfo pi)
  333.         throws IOException, OrekitException  {
  334.         int i = 0;
  335.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {

  337.             ++pi.lineNumber;
  338.             if (line.trim().length() == 0) {
  339.                 continue;
  340.             }
  341.             pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  342.             if (pi.keyValue.getKeyword() == null) {
  343.                 final Scanner sc = new Scanner(line);
  344.                 for (int j = 0; j < i + 1; j++) {
  345.                     try {
  346.                         pi.lastMatrix.addToEntry(i, j, Double.parseDouble(sc.next()));
  347.                     } catch (NumberFormatException nfe) {
  348.                         sc.close();
  349.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  350.                                                   pi.lineNumber, pi.fileName, line);
  351.                     }
  352.                     if (j != i) {
  353.                         pi.lastMatrix.addToEntry(j, i, pi.lastMatrix.getEntry(i, j));
  354.                     }
  355.                 }
  356.                 if (i == 5) {
  357.                     final OEMFile.CovarianceMatrix cm =
  358.                             new OEMFile.CovarianceMatrix(pi.epoch, pi.covRefLofType, pi.covRefFrame, pi.lastMatrix);
  359.                     pi.lastEphemeridesBlock.getCovarianceMatrices().add(cm);
  360.                 }
  361.                 i++;
  362.                 if (sc != null) {
  363.                     sc.close();
  364.                 }
  365.             } else {
  366.                 switch (pi.keyValue.getKeyword()) {
  367.                     case EPOCH :
  368.                         i                = 0;
  369.                         pi.covRefLofType = null;
  370.                         pi.covRefFrame   = null;
  371.                         pi.lastMatrix    = MatrixUtils.createRealMatrix(6, 6);
  372.                         pi.epoch         = parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  373.                         break;
  374.                     case COV_REF_FRAME :
  375.                         final CCSDSFrame frame = parseCCSDSFrame(pi.keyValue.getValue());
  376.                         if (frame.isLof()) {
  377.                             pi.covRefLofType = frame.getLofType();
  378.                             pi.covRefFrame   = null;
  379.                         } else {
  380.                             pi.covRefLofType = null;
  381.                             pi.covRefFrame   = frame.getFrame(getConventions(), isSimpleEOP());
  382.                         }
  383.                         break;
  384.                     case COVARIANCE_STOP :
  385.                         return;
  386.                     default :
  387.                         throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  388.                 }
  389.             }
  390.         }
  391.     }

  393.     /** Private class used to stock OEM parsing info.
  394.      * @author sports
  395.      */
  396.     private static class ParseInfo {

  398.         /** Ephemerides block being parsed. */
  399.         private OEMFile.EphemeridesBlock lastEphemeridesBlock;

  401.         /** Name of the file. */
  402.         private String fileName;

  404.         /** Current line number. */
  405.         private int lineNumber;

  407.         /** OEM file being read. */
  408.         private OEMFile file;

  410.         /** Key value of the line being read. */
  411.         private KeyValue keyValue;

  413.         /** Stored epoch. */
  414.         private AbsoluteDate epoch;

  416.         /** Covariance reference type of Local Orbital Frame. */
  417.         private LOFType covRefLofType;

  419.         /** Covariance reference frame. */
  420.         private Frame covRefFrame;
  421.         /** Stored matrix. */
  422.         private RealMatrix lastMatrix;

  424.         /** Stored comments. */
  425.         private List<String> commentTmp;

  427.         /** Create a new {@link ParseInfo} object. */
  428.         protected ParseInfo() {
  429.             lineNumber = 0;
  430.             file = new OEMFile();
  431.             commentTmp = new ArrayList<String>();
  432.         }
  433.     }
  434. }
Created with JaCoCo 0.7.9.201702052155