ODMParser.java

  1. /* Copyright 2002-2013 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.FileInputStream;
  20. import java.io.FileNotFoundException;
  21. import java.io.IOException;
  22. import java.io.InputStream;
  23. import java.util.List;
  24. import java.util.regex.Matcher;
  25. import java.util.regex.Pattern;

  27. import org.apache.commons.math3.util.FastMath;
  28. import org.orekit.errors.OrekitException;
  29. import org.orekit.errors.OrekitMessages;
  30. import org.orekit.files.general.OrbitFile;
  31. import org.orekit.time.AbsoluteDate;
  32. import org.orekit.time.DateTimeComponents;
  33. import org.orekit.time.TimeScalesFactory;
  34. import org.orekit.utils.Constants;
  35. import org.orekit.utils.IERSConventions;

  37. /** Base class for all CCSDS Orbit Data Message parsers.
  38.  * <p>
  39.  * This base class is immutable, and hence thread safe. When parts
  40.  * must be changed, such as reference date for Mission Elapsed Time or
  41.  * Mission Relative Time time systems, or the gravitational coefficient or
  42.  * the IERS conventions, the various {@code withXxx} methods must be called,
  43.  * which create a new immutable instance with the new parameters. This
  44.  * is a combination of the <a href="">builder design pattern</a> and
  45.  * a <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  46.  * interface</a>.
  47.  * </p>
  48.  * @author Luc Maisonobe
  49.  * @since 6.1
  50.  */
  51. public abstract class ODMParser {

  53.     /** Pattern for international designator. */
  54.     private static final Pattern INTERNATIONAL_DESIGNATOR = Pattern.compile("(\\p{Digit}{4})-(\\p{Digit}{3})(\\p{Upper}{1,3})");

  56.     /** Reference date for Mission Elapsed Time or Mission Relative Time time systems. */
  57.     private final AbsoluteDate missionReferenceDate;

  59.     /** Gravitational coefficient. */
  60.     private final  double mu;

  62.     /** IERS Conventions. */
  63.     private final  IERSConventions conventions;

  65.     /** Indicator for simple or accurate EOP interpolation. */
  66.     private final  boolean simpleEOP;

  68.     /** Launch Year. */
  69.     private int launchYear;

  71.     /** Launch number. */
  72.     private int launchNumber;

  74.     /** Piece of launch (from "A" to "ZZZ"). */
  75.     private String launchPiece;

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

  98.     /** Set initial date.
  99.      * @param newMissionReferenceDate mission reference date to use while parsing
  100.      * @return a new instance, with mission reference date replaced
  101.      * @see #getMissionReferenceDate()
  102.      */
  103.     public abstract ODMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate);

  105.     /** Get initial date.
  106.      * @return mission reference date to use while parsing
  107.      * @see #withMissionReferenceDate(AbsoluteDate)
  108.      */
  109.     public AbsoluteDate getMissionReferenceDate() {
  110.         return missionReferenceDate;
  111.     }

  113.     /** Set gravitational coefficient.
  114.      * @param newMu gravitational coefficient to use while parsing
  115.      * @return a new instance, with gravitational coefficient date replaced
  116.      * @see #getMu()
  117.      */
  118.     public abstract ODMParser withMu(final double newMu);

  120.     /** Get gravitational coefficient.
  121.      * @return gravitational coefficient to use while parsing
  122.      * @see #withMu(double)
  123.      */
  124.     public double getMu() {
  125.         return mu;
  126.     }

  128.     /** Set IERS conventions.
  129.      * @param newConventions IERS conventions to use while parsing
  130.      * @return a new instance, with IERS conventions replaced
  131.      * @see #getConventions()
  132.      */
  133.     public abstract ODMParser withConventions(final IERSConventions newConventions);

  135.     /** Get IERS conventions.
  136.      * @return IERS conventions to use while parsing
  137.      * @see #withConventions(IERSConventions)
  138.      */
  139.     public IERSConventions getConventions() {
  140.         return conventions;
  141.     }

  143.     /** Set EOP interpolation method.
  144.      * @param newSimpleEOP if true, tidal effects are ignored when interpolating EOP
  145.      * @return a new instance, with EOP interpolation method replaced
  146.      * @see #isSimpleEOP()
  147.      */
  148.     public abstract ODMParser withSimpleEOP(final boolean newSimpleEOP);

  150.     /** Get EOP interpolation method.
  151.      * @return true if tidal effects are ignored when interpolating EOP
  152.      * @see #withSimpleEOP(boolean)
  153.      */
  154.     public boolean isSimpleEOP() {
  155.         return simpleEOP;
  156.     }

  158.     /** Set international designator.
  159.      * <p>
  160.      * This method may be used to ensure the launch year number and pieces are
  161.      * correctly set if they are not present in the CCSDS file header in the
  162.      * OBJECT_ID in the form YYYY-NNN-P{PP}. If they are already in the header,
  163.      * they will be parsed automatically regardless of this method being called
  164.      * or not (i.e. header information override information set here).
  165.      * </p>
  166.      * @param newLaunchYear launch year
  167.      * @param newLaunchNumber launch number
  168.      * @param newLaunchPiece piece of launch (from "A" to "ZZZ")
  169.      * @return a new instance, with TLE settings replaced
  170.      */
  171.     public abstract ODMParser withInternationalDesignator(final int newLaunchYear,
  172.                                                           final int newLaunchNumber,
  173.                                                           final String newLaunchPiece);

  175.     /** Get the launch year.
  176.      * @return launch year
  177.      */
  178.     public int getLaunchYear() {
  179.         return launchYear;
  180.     }

  182.     /** Get the launch number.
  183.      * @return launch number
  184.      */
  185.     public int getLaunchNumber() {
  186.         return launchNumber;
  187.     }

  189.     /** Get the piece of launch.
  190.      * @return piece of launch
  191.      */
  192.     public String getLaunchPiece() {
  193.         return launchPiece;
  194.     }

  196.     /** Parse a CCSDS Orbit Data Message.
  197.      * @param fileName name of the file containing the message
  198.      * @return parsed orbit
  199.      * @exception OrekitException if orbit message cannot be parsed
  200.      */
  201.     public ODMFile parse(final String fileName)
  202.         throws OrekitException {

  204.         InputStream stream = null;

  206.         try {
  207.             stream = new FileInputStream(fileName);
  208.             return parse(stream, fileName);
  209.         } catch (FileNotFoundException e) {
  210.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  211.         } finally {
  212.             try {
  213.                 if (stream != null) {
  214.                     stream.close();
  215.                 }
  216.             } catch (IOException e) {
  217.                 // ignore
  218.             }
  219.         }

  221.     }

  223.     /** Parse a CCSDS Orbit Data Message.
  224.      * @param stream stream containing message
  225.      * @return parsed orbit
  226.      * @exception OrekitException if orbit message cannot be parsed
  227.      */
  228.     public ODMFile parse(final InputStream stream)
  229.         throws OrekitException {
  230.         return parse(stream, "<unknown>");
  231.     }

  233.     /** Parse a CCSDS Orbit Data Message.
  234.      * @param stream stream containing message
  235.      * @param fileName name of the file containing the message (for error messages)
  236.      * @return parsed orbit
  237.      * @exception OrekitException if orbit message cannot be parsed
  238.      */
  239.     public abstract ODMFile parse(final InputStream stream, final String fileName)
  240.         throws OrekitException;

  242.     /** Parse a comment line.
  243.      * @param keyValue key=value pair containing the comment
  244.      * @param comment placeholder where the current comment line should be added
  245.      * @return true if the line was a comment line and was parsed
  246.      */
  247.     protected boolean parseComment(final KeyValue keyValue, final List<String> comment) {
  248.         if (keyValue.getKeyword() == Keyword.COMMENT) {
  249.             comment.add(keyValue.getValue());
  250.             return true;
  251.         } else {
  252.             return false;
  253.         }
  254.     }

  256.     /** Parse an entry from the header.
  257.      * @param keyValue key = value pair
  258.      * @param odmFile instance to update with parsed entry
  259.      * @param comment previous comment lines, will be emptied if used by the keyword
  260.      * @return true if the keyword was a header keyword and has been parsed
  261.      * @exception OrekitException if UTC time scale cannot be retrieved to parse creation date
  262.      */
  263.     protected boolean parseHeaderEntry(final KeyValue keyValue,
  264.                                        final ODMFile odmFile, final List<String> comment)
  265.         throws OrekitException {
  266.         switch (keyValue.getKeyword()) {

  268.         case CREATION_DATE:
  269.             if (!comment.isEmpty()) {
  270.                 odmFile.setHeaderComment(comment);
  271.                 comment.clear();
  272.             }
  273.             odmFile.setCreationDate(new AbsoluteDate(keyValue.getValue(), TimeScalesFactory.getUTC()));
  274.             return true;

  276.         case ORIGINATOR:
  277.             odmFile.setOriginator(keyValue.getValue());
  278.             return true;

  280.         default:
  281.             return false;

  283.         }

  285.     }

  287.     /** Parse a meta-data key = value entry.
  288.      * @param keyValue key = value pair
  289.      * @param metaData instance to update with parsed entry
  290.      * @param comment previous comment lines, will be emptied if used by the keyword
  291.      * @return true if the keyword was a meta-data keyword and has been parsed
  292.      * @exception OrekitException if center body or frame cannot be retrieved
  293.      */
  294.     protected boolean parseMetaDataEntry(final KeyValue keyValue,
  295.                                          final ODMMetaData metaData, final List<String> comment)
  296.         throws OrekitException {
  297.         switch (keyValue.getKeyword()) {
  298.         case OBJECT_NAME:
  299.             if (!comment.isEmpty()) {
  300.                 metaData.setComment(comment);
  301.                 comment.clear();
  302.             }
  303.             metaData.setObjectName(keyValue.getValue());
  304.             return true;

  306.         case OBJECT_ID: {
  307.             metaData.setObjectID(keyValue.getValue());
  308.             final Matcher matcher = INTERNATIONAL_DESIGNATOR.matcher(keyValue.getValue());
  309.             if (matcher.matches()) {
  310.                 metaData.setLaunchYear(Integer.parseInt(matcher.group(1)));
  311.                 metaData.setLaunchNumber(Integer.parseInt(matcher.group(2)));
  312.                 metaData.setLaunchPiece(matcher.group(3));
  313.             }
  314.             return true;
  315.         }

  317.         case CENTER_NAME:
  318.             metaData.setCenterName(keyValue.getValue());
  319.             final String canonicalValue;
  320.             if (keyValue.getValue().equals("SOLAR SYSTEM BARYCENTER") || keyValue.getValue().equals("SSB")) {
  321.                 canonicalValue = "SOLAR_SYSTEM_BARYCENTER";
  322.             } else if (keyValue.getValue().equals("EARTH MOON BARYCENTER") || keyValue.getValue().equals("EARTH-MOON BARYCENTER") ||
  323.                        keyValue.getValue().equals("EARTH BARYCENTER") || keyValue.getValue().equals("EMB")) {
  324.                 canonicalValue = "EARTH_MOON";
  325.             } else {
  326.                 canonicalValue = keyValue.getValue();
  327.             }
  328.             for (final CenterName c : CenterName.values()) {
  329.                 if (c.name().equals(canonicalValue)) {
  330.                     metaData.setHasCreatableBody(true);
  331.                     metaData.setCenterBody(c.getCelestialBody());
  332.                     metaData.getODMFile().setMuCreated(c.getCelestialBody().getGM());
  333.                 }
  334.             }
  335.             return true;

  337.         case REF_FRAME:
  338.             metaData.setRefFrame(parseCCSDSFrame(keyValue.getValue()).getFrame(getConventions(), isSimpleEOP()));
  339.             return true;

  341.         case REF_FRAME_EPOCH:
  342.             metaData.setFrameEpochString(keyValue.getValue());
  343.             return true;

  345.         case TIME_SYSTEM:
  346.             final OrbitFile.TimeSystem timeSystem = OrbitFile.TimeSystem.valueOf(keyValue.getValue());
  347.             metaData.setTimeSystem(timeSystem);
  348.             if (metaData.getFrameEpochString() != null) {
  349.                 metaData.setFrameEpoch(parseDate(metaData.getFrameEpochString(), timeSystem));
  350.             }
  351.             return true;

  353.         default:
  354.             return false;
  355.         }
  356.     }

  358.     /** Parse a general state data key = value entry.
  359.      * @param keyValue key = value pair
  360.      * @param general instance to update with parsed entry
  361.      * @param comment previous comment lines, will be emptied if used by the keyword
  362.      * @return true if the keyword was a meta-data keyword and has been parsed
  363.      * @exception OrekitException if center body or frame cannot be retrieved
  364.      */
  365.     protected boolean parseGeneralStateDataEntry(final KeyValue keyValue,
  366.                                                  final OGMFile general, final List<String> comment)
  367.         throws OrekitException {
  368.         switch (keyValue.getKeyword()) {

  370.         case EPOCH:
  371.             general.setEpochComment(comment);
  372.             comment.clear();
  373.             general.setEpoch(parseDate(keyValue.getValue(), general.getTimeSystem()));
  374.             return true;

  376.         case SEMI_MAJOR_AXIS:
  377.             general.setKeplerianElementsComment(comment);
  378.             comment.clear();
  379.             general.setA(keyValue.getDoubleValue() * 1000);
  380.             general.setHasKeplerianElements(true);
  381.             return true;

  383.         case ECCENTRICITY:
  384.             general.setE(keyValue.getDoubleValue());
  385.             return true;

  387.         case INCLINATION:
  388.             general.setI(FastMath.toRadians(keyValue.getDoubleValue()));
  389.             return true;

  391.         case RA_OF_ASC_NODE:
  392.             general.setRaan(FastMath.toRadians(keyValue.getDoubleValue()));
  393.             return true;

  395.         case ARG_OF_PERICENTER:
  396.             general.setPa(FastMath.toRadians(keyValue.getDoubleValue()));
  397.             return true;

  399.         case TRUE_ANOMALY:
  400.             general.setAnomalyType("TRUE");
  401.             general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
  402.             return true;

  404.         case MEAN_ANOMALY:
  405.             general.setAnomalyType("MEAN");
  406.             general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
  407.             return true;

  409.         case GM:
  410.             general.setMuParsed(keyValue.getDoubleValue() * 1e9);
  411.             return true;

  413.         case MASS:
  414.             comment.addAll(0, general.getSpacecraftComment());
  415.             general.setSpacecraftComment(comment);
  416.             comment.clear();
  417.             general.setMass(keyValue.getDoubleValue());
  418.             return true;

  420.         case SOLAR_RAD_AREA:
  421.             comment.addAll(0, general.getSpacecraftComment());
  422.             general.setSpacecraftComment(comment);
  423.             comment.clear();
  424.             general.setSolarRadArea(keyValue.getDoubleValue());
  425.             return true;

  427.         case SOLAR_RAD_COEFF:
  428.             comment.addAll(0, general.getSpacecraftComment());
  429.             general.setSpacecraftComment(comment);
  430.             comment.clear();
  431.             general.setSolarRadCoeff(keyValue.getDoubleValue());
  432.             return true;

  434.         case DRAG_AREA:
  435.             comment.addAll(0, general.getSpacecraftComment());
  436.             general.setSpacecraftComment(comment);
  437.             comment.clear();
  438.             general.setDragArea(keyValue.getDoubleValue());
  439.             return true;

  441.         case DRAG_COEFF:
  442.             comment.addAll(0, general.getSpacecraftComment());
  443.             general.setSpacecraftComment(comment);
  444.             comment.clear();
  445.             general.setDragCoeff(keyValue.getDoubleValue());
  446.             return true;

  448.         case COV_REF_FRAME:
  449.             general.setCovarianceComment(comment);
  450.             comment.clear();
  451.             final CCSDSFrame covFrame = parseCCSDSFrame(keyValue.getValue());
  452.             if (covFrame.isLof()) {
  453.                 general.setCovRefLofType(covFrame.getLofType());
  454.             } else {
  455.                 general.setCovRefFrame(covFrame.getFrame(getConventions(), isSimpleEOP()));
  456.             }
  457.             return true;

  459.         case CX_X:
  460.             general.createCovarianceMatrix();
  461.             general.setCovarianceMatrixEntry(0, 0, keyValue.getDoubleValue());
  462.             return true;

  464.         case CY_X:
  465.             general.setCovarianceMatrixEntry(0, 1, keyValue.getDoubleValue());
  466.             return true;

  468.         case CY_Y:
  469.             general.setCovarianceMatrixEntry(1, 1, keyValue.getDoubleValue());
  470.             return true;

  472.         case CZ_X:
  473.             general.setCovarianceMatrixEntry(0, 2, keyValue.getDoubleValue());
  474.             return true;

  476.         case CZ_Y:
  477.             general.setCovarianceMatrixEntry(1, 2, keyValue.getDoubleValue());
  478.             return true;

  480.         case CZ_Z:
  481.             general.setCovarianceMatrixEntry(2, 2, keyValue.getDoubleValue());
  482.             return true;

  484.         case CX_DOT_X:
  485.             general.setCovarianceMatrixEntry(0, 3, keyValue.getDoubleValue());
  486.             return true;

  488.         case CX_DOT_Y:
  489.             general.setCovarianceMatrixEntry(1, 3, keyValue.getDoubleValue());
  490.             return true;

  492.         case CX_DOT_Z:
  493.             general.setCovarianceMatrixEntry(2, 3, keyValue.getDoubleValue());
  494.             return true;

  496.         case CX_DOT_X_DOT:
  497.             general.setCovarianceMatrixEntry(3, 3, keyValue.getDoubleValue());
  498.             return true;

  500.         case CY_DOT_X:
  501.             general.setCovarianceMatrixEntry(0, 4, keyValue.getDoubleValue());
  502.             return true;

  504.         case CY_DOT_Y:
  505.             general.setCovarianceMatrixEntry(1, 4, keyValue.getDoubleValue());
  506.             return true;

  508.         case CY_DOT_Z:
  509.             general.setCovarianceMatrixEntry(2, 4, keyValue.getDoubleValue());
  510.             return true;

  512.         case CY_DOT_X_DOT:
  513.             general.setCovarianceMatrixEntry(3, 4, keyValue.getDoubleValue());
  514.             return true;

  516.         case CY_DOT_Y_DOT:
  517.             general.setCovarianceMatrixEntry(4, 4, keyValue.getDoubleValue());
  518.             return true;

  520.         case CZ_DOT_X:
  521.             general.setCovarianceMatrixEntry(0, 5, keyValue.getDoubleValue());
  522.             return true;

  524.         case CZ_DOT_Y:
  525.             general.setCovarianceMatrixEntry(1, 5, keyValue.getDoubleValue());
  526.             return true;

  528.         case CZ_DOT_Z:
  529.             general.setCovarianceMatrixEntry(2, 5, keyValue.getDoubleValue());
  530.             return true;

  532.         case CZ_DOT_X_DOT:
  533.             general.setCovarianceMatrixEntry(3, 5, keyValue.getDoubleValue());
  534.             return true;

  536.         case CZ_DOT_Y_DOT:
  537.             general.setCovarianceMatrixEntry(4, 5, keyValue.getDoubleValue());
  538.             return true;

  540.         case CZ_DOT_Z_DOT:
  541.             general.setCovarianceMatrixEntry(5, 5, keyValue.getDoubleValue());
  542.             return true;

  544.         case USER_DEFINED_X:
  545.             general.setUserDefinedParameters(keyValue.getKey(), keyValue.getValue());
  546.             return true;

  548.         default:
  549.             return false;
  550.         }
  551.     }

  553.     /** Parse a CCSDS frame.
  554.      * @param frameName name of the frame, as the value of a CCSDS key=value line
  555.      * @return CCSDS frame corresponding to the name
  556.      */
  557.     protected CCSDSFrame parseCCSDSFrame(final String frameName) {
  558.         return CCSDSFrame.valueOf(frameName.replaceAll("-", ""));
  559.     }

  561.     /** Parse a date.
  562.      * @param date date to parse, as the value of a CCSDS key=value line
  563.      * @param timeSystem time system to use
  564.      * @return parsed date
  565.      * @exception OrekitException if some time scale cannot be retrieved
  566.      */
  567.     protected AbsoluteDate parseDate(final String date, final OrbitFile.TimeSystem timeSystem)
  568.         throws OrekitException {
  569.         switch (timeSystem) {
  570.         case GMST:
  571.             return new AbsoluteDate(date, TimeScalesFactory.getGMST());
  572.         case GPS:
  573.             return new AbsoluteDate(date, TimeScalesFactory.getGPS());
  574.         case TAI:
  575.             return new AbsoluteDate(date, TimeScalesFactory.getTAI());
  576.         case TCB:
  577.             return new AbsoluteDate(date, TimeScalesFactory.getTCB());
  578.         case TDB:
  579.             return new AbsoluteDate(date, TimeScalesFactory.getTDB());
  580.         case TCG:
  581.             return new AbsoluteDate(date, TimeScalesFactory.getTCG());
  582.         case TT:
  583.             return new AbsoluteDate(date, TimeScalesFactory.getTT());
  584.         case UT1:
  585.             return new AbsoluteDate(date, TimeScalesFactory.getUT1(conventions, false));
  586.         case UTC:
  587.             return new AbsoluteDate(date, TimeScalesFactory.getUTC());
  588.         case MET: {
  589.             final DateTimeComponents clock = DateTimeComponents.parseDateTime(date);
  590.             final double offset = clock.getDate().getYear() * Constants.JULIAN_YEAR +
  591.                     clock.getDate().getDayOfYear() * Constants.JULIAN_DAY +
  592.                     clock.getTime().getSecondsInDay();
  593.             return missionReferenceDate.shiftedBy(offset);
  594.         }
  595.         case MRT: {
  596.             final DateTimeComponents clock = DateTimeComponents.parseDateTime(date);
  597.             final double offset = clock.getDate().getYear() * Constants.JULIAN_YEAR +
  598.                     clock.getDate().getDayOfYear() * Constants.JULIAN_DAY +
  599.                     clock.getTime().getSecondsInDay();
  600.             return missionReferenceDate.shiftedBy(offset);
  601.         }
  602.         default:
  603.             throw OrekitException.createInternalError(null);
  604.         }
  605.     }

  607. }
Created with JaCoCo 0.6.3.201306030806