OEMParser.java

  1. /* Copyright 2002-2016 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.apache.commons.math3.exception.util.DummyLocalizable;
  28. import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
  29. import org.apache.commons.math3.linear.MatrixUtils;
  30. import org.apache.commons.math3.linear.RealMatrix;
  31. import org.orekit.errors.OrekitException;
  32. import org.orekit.errors.OrekitMessages;
  33. import org.orekit.files.general.OrbitFileParser;
  34. import org.orekit.frames.Frame;
  35. import org.orekit.frames.LOFType;
  36. import org.orekit.orbits.CartesianOrbit;
  37. import org.orekit.time.AbsoluteDate;
  38. import org.orekit.utils.IERSConventions;
  39. import org.orekit.utils.PVCoordinates;

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

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

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

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

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

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

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

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

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

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

  138.     /** {@inheritDoc} */
  139.     public OEMFile parse(final InputStream stream, final String fileName) throws OrekitException {

  141.         try {

  143.             final BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
  144.             // initialize internal data structures
  145.             final ParseInfo pi = new ParseInfo();
  146.             pi.fileName = fileName;
  147.             final OEMFile file = pi.file;

  149.             // set the additional data that has been configured prior the parsing by the user.
  150.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  151.             pi.file.setMuSet(getMu());
  152.             pi.file.setConventions(getConventions());

  154.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  155.                 ++pi.lineNumber;
  156.                 if (line.trim().length() == 0) {
  157.                     continue;
  158.                 }
  159.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  160.                 if (pi.keyValue.getKeyword() == null) {
  161.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  162.                 }
  163.                 switch (pi.keyValue.getKeyword()) {
  164.                     case CCSDS_OEM_VERS:
  165.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  166.                         break;

  168.                     case META_START:
  169.                         file.addEphemeridesBlock();
  170.                         pi.lastEphemeridesBlock = file.getEphemeridesBlocks().get(file.getEphemeridesBlocks().size() - 1);
  171.                         pi.lastEphemeridesBlock.getMetaData().setLaunchYear(getLaunchYear());
  172.                         pi.lastEphemeridesBlock.getMetaData().setLaunchNumber(getLaunchNumber());
  173.                         pi.lastEphemeridesBlock.getMetaData().setLaunchPiece(getLaunchPiece());
  174.                         break;

  176.                     case START_TIME:
  177.                         pi.lastEphemeridesBlock.setStartTime(parseDate(pi.keyValue.getValue(),
  178.                                                                        pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  179.                         break;

  181.                     case USEABLE_START_TIME:
  182.                         pi.lastEphemeridesBlock.setUseableStartTime(parseDate(pi.keyValue.getValue(),
  183.                                                                               pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  184.                         break;

  186.                     case USEABLE_STOP_TIME:
  187.                         pi.lastEphemeridesBlock.setUseableStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  188.                         break;

  190.                     case STOP_TIME:
  191.                         pi.lastEphemeridesBlock.setStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  192.                         break;

  194.                     case INTERPOLATION:
  195.                         pi.lastEphemeridesBlock.setInterpolationMethod(pi.keyValue.getValue());
  196.                         break;

  198.                     case INTERPOLATION_DEGREE:
  199.                         pi.lastEphemeridesBlock.setInterpolationDegree(Integer .parseInt(pi.keyValue.getValue()));
  200.                         break;

  202.                     case META_STOP:
  203.                         file.setMuUsed();
  204.                         parseEphemeridesDataLines(reader, pi);
  205.                         break;

  207.                     case COVARIANCE_START:
  208.                         parseCovarianceDataLines(reader, pi);
  209.                         break;

  211.                     default:
  212.                         boolean parsed = false;
  213.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  214.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  215.                         if (pi.lastEphemeridesBlock != null) {
  216.                             parsed = parsed || parseMetaDataEntry(pi.keyValue,
  217.                                                                   pi.lastEphemeridesBlock.getMetaData(), pi.commentTmp);
  218.                             if (parsed && pi.keyValue.getKeyword() == Keyword.REF_FRAME_EPOCH) {
  219.                                 pi.lastEphemeridesBlock.setHasRefFrameEpoch(true);
  220.                             }
  221.                         }
  222.                         if (!parsed) {
  223.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  224.                         }
  225.                 }
  226.             }
  227.             file.checkTimeSystems();
  228.             return file;
  229.         } catch (IOException ioe) {
  230.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  231.         }
  232.     }

  234.     /**
  235.      * Parse an ephemeris data line and add its content to the ephemerides
  236.      * block.
  237.      *
  238.      * @param reader the reader
  239.      * @param pi the parser info
  240.      * @exception IOException if an error occurs while reading from the stream
  241.      * @exception OrekitException if a date cannot be parsed
  242.      */
  243.     private void parseEphemeridesDataLines(final BufferedReader reader,  final ParseInfo pi)
  244.         throws OrekitException, IOException {

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

  248.             ++pi.lineNumber;
  249.             if (line.trim().length() > 0) {
  250.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  251.                 if (pi.keyValue.getKeyword() == null) {
  252.                     Scanner sc = null;
  253.                     try {
  254.                         sc = new Scanner(line);
  255.                         final AbsoluteDate date = parseDate(sc.next(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  256.                         final Vector3D position = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  257.                                                                Double.parseDouble(sc.next()) * 1000,
  258.                                                                Double.parseDouble(sc.next()) * 1000);
  259.                         final Vector3D velocity = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  260.                                                                Double.parseDouble(sc.next()) * 1000,
  261.                                                                Double.parseDouble(sc.next()) * 1000);
  262.                         final CartesianOrbit orbit =
  263.                                 new CartesianOrbit(new PVCoordinates(position, velocity),
  264.                                                    pi.lastEphemeridesBlock.getMetaData().getFrame(),
  265.                                                    date, pi.file.getMuUsed());
  266.                         Vector3D acceleration = null;
  267.                         if (sc.hasNext()) {
  268.                             acceleration = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  269.                                                         Double.parseDouble(sc.next()) * 1000,
  270.                                                         Double.parseDouble(sc.next()) * 1000);
  271.                         }
  272.                         final OEMFile.EphemeridesDataLine epDataLine =
  273.                                 new OEMFile.EphemeridesDataLine(orbit, acceleration);
  274.                         pi.lastEphemeridesBlock.getEphemeridesDataLines().add(epDataLine);
  275.                     } catch (NumberFormatException nfe) {
  276.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  277.                                                   pi.lineNumber, pi.fileName, line);
  278.                     } finally {
  279.                         if (sc != null) {
  280.                             sc.close();
  281.                         }
  282.                     }
  283.                 } else {
  284.                     switch (pi.keyValue.getKeyword()) {
  285.                         case META_START:
  286.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  287.                             pi.commentTmp.clear();
  288.                             pi.lineNumber--;
  289.                             reader.reset();
  290.                             return;
  291.                         case COVARIANCE_START:
  292.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  293.                             pi.commentTmp.clear();
  294.                             pi.lineNumber--;
  295.                             reader.reset();
  296.                             return;
  297.                         case COMMENT:
  298.                             pi.commentTmp.add(pi.keyValue.getValue());
  299.                             break;
  300.                         default :
  301.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  302.                     }
  303.                 }
  304.             }
  305.             reader.mark(300);

  307.         }
  308.     }

  310.     /**
  311.      * Parse the covariance data lines, create a set of CovarianceMatrix objects
  312.      * and add them in the covarianceMatrices list of the ephemerides block.
  313.      *
  314.      * @param reader the reader
  315.      * @param pi the parser info
  316.      * @throws IOException if an error occurs while reading from the stream
  317.      * @throws OrekitException if the frame cannot be retrieved
  318.      */
  319.     private void parseCovarianceDataLines(final BufferedReader reader, final ParseInfo pi)
  320.         throws IOException, OrekitException  {
  321.         int i = 0;
  322.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {

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

  380.     /** Private class used to stock OEM parsing info.
  381.      * @author sports
  382.      */
  383.     private static class ParseInfo {

  385.         /** Ephemerides block being parsed. */
  386.         private OEMFile.EphemeridesBlock lastEphemeridesBlock;

  388.         /** Name of the file. */
  389.         private String fileName;

  391.         /** Current line number. */
  392.         private int lineNumber;

  394.         /** OEM file being read. */
  395.         private OEMFile file;

  397.         /** Key value of the line being read. */
  398.         private KeyValue keyValue;

  400.         /** Stored epoch. */
  401.         private AbsoluteDate epoch;

  403.         /** Covariance reference type of Local Orbital Frame. */
  404.         private LOFType covRefLofType;

  406.         /** Covariance reference frame. */
  407.         private Frame covRefFrame;
  408.         /** Stored matrix. */
  409.         private RealMatrix lastMatrix;

  411.         /** Stored comments. */
  412.         private List<String> commentTmp;

  414.         /** Create a new {@link ParseInfo} object. */
  415.         protected ParseInfo() {
  416.             lineNumber = 0;
  417.             file = new OEMFile();
  418.             commentTmp = new ArrayList<String>();
  419.         }
  420.     }
  421. }
Created with JaCoCo 0.7.4.201502262128