ODMParser.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.FileInputStream;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.util.List;
  23. import java.util.regex.Matcher;
  24. import java.util.regex.Pattern;

  26. import org.hipparchus.util.FastMath;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.errors.OrekitMessages;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.TimeScalesFactory;
  31. import org.orekit.utils.IERSConventions;

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

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

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

  56.     /** Gravitational coefficient. */
  57.     private final  double mu;

  59.     /** IERS Conventions. */
  60.     private final  IERSConventions conventions;

  62.     /** Indicator for simple or accurate EOP interpolation. */
  63.     private final  boolean simpleEOP;

  65.     /** Launch Year. */
  66.     private int launchYear;

  68.     /** Launch number. */
  69.     private int launchNumber;

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

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

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

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

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

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

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

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

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

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

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

  172.     /** Get the launch year.
  173.      * @return launch year
  174.      */
  175.     public int getLaunchYear() {
  176.         return launchYear;
  177.     }

  179.     /** Get the launch number.
  180.      * @return launch number
  181.      */
  182.     public int getLaunchNumber() {
  183.         return launchNumber;
  184.     }

  186.     /** Get the piece of launch.
  187.      * @return piece of launch
  188.      */
  189.     public String getLaunchPiece() {
  190.         return launchPiece;
  191.     }

  193.     /** Parse a CCSDS Orbit Data Message.
  194.      * @param fileName name of the file containing the message
  195.      * @return parsed orbit
  196.      * @exception OrekitException if orbit message cannot be parsed
  197.      */
  198.     public ODMFile parse(final String fileName)
  199.         throws OrekitException {
  200.         try (InputStream stream = new FileInputStream(fileName)) {
  201.             return parse(stream, fileName);
  202.         } catch (IOException e) {
  203.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  204.         }
  205.     }

  207.     /** Parse a CCSDS Orbit Data Message.
  208.      * @param stream stream containing message
  209.      * @return parsed orbit
  210.      * @exception OrekitException if orbit message cannot be parsed
  211.      */
  212.     public ODMFile parse(final InputStream stream)
  213.         throws OrekitException {
  214.         return parse(stream, "<unknown>");
  215.     }

  217.     /** Parse a CCSDS Orbit Data Message.
  218.      * @param stream stream containing message
  219.      * @param fileName name of the file containing the message (for error messages)
  220.      * @return parsed orbit
  221.      * @exception OrekitException if orbit message cannot be parsed
  222.      */
  223.     public abstract ODMFile parse(InputStream stream, String fileName)
  224.         throws OrekitException;

  226.     /** Parse a comment line.
  227.      * @param keyValue key=value pair containing the comment
  228.      * @param comment placeholder where the current comment line should be added
  229.      * @return true if the line was a comment line and was parsed
  230.      */
  231.     protected boolean parseComment(final KeyValue keyValue, final List<String> comment) {
  232.         if (keyValue.getKeyword() == Keyword.COMMENT) {
  233.             comment.add(keyValue.getValue());
  234.             return true;
  235.         } else {
  236.             return false;
  237.         }
  238.     }

  240.     /** Parse an entry from the header.
  241.      * @param keyValue key = value pair
  242.      * @param odmFile instance to update with parsed entry
  243.      * @param comment previous comment lines, will be emptied if used by the keyword
  244.      * @return true if the keyword was a header keyword and has been parsed
  245.      * @exception OrekitException if UTC time scale cannot be retrieved to parse creation date
  246.      */
  247.     protected boolean parseHeaderEntry(final KeyValue keyValue,
  248.                                        final ODMFile odmFile, final List<String> comment)
  249.         throws OrekitException {
  250.         switch (keyValue.getKeyword()) {

  252.             case CREATION_DATE:
  253.                 if (!comment.isEmpty()) {
  254.                     odmFile.setHeaderComment(comment);
  255.                     comment.clear();
  256.                 }
  257.                 odmFile.setCreationDate(new AbsoluteDate(keyValue.getValue(), TimeScalesFactory.getUTC()));
  258.                 return true;

  260.             case ORIGINATOR:
  261.                 odmFile.setOriginator(keyValue.getValue());
  262.                 return true;

  264.             default:
  265.                 return false;

  267.         }

  269.     }

  271.     /** Parse a meta-data key = value entry.
  272.      * @param keyValue key = value pair
  273.      * @param metaData instance to update with parsed entry
  274.      * @param comment previous comment lines, will be emptied if used by the keyword
  275.      * @return true if the keyword was a meta-data keyword and has been parsed
  276.      * @exception OrekitException if center body or frame cannot be retrieved
  277.      */
  278.     protected boolean parseMetaDataEntry(final KeyValue keyValue,
  279.                                          final ODMMetaData metaData, final List<String> comment)
  280.         throws OrekitException {
  281.         switch (keyValue.getKeyword()) {
  282.             case OBJECT_NAME:
  283.                 if (!comment.isEmpty()) {
  284.                     metaData.setComment(comment);
  285.                     comment.clear();
  286.                 }
  287.                 metaData.setObjectName(keyValue.getValue());
  288.                 return true;

  290.             case OBJECT_ID: {
  291.                 metaData.setObjectID(keyValue.getValue());
  292.                 final Matcher matcher = INTERNATIONAL_DESIGNATOR.matcher(keyValue.getValue());
  293.                 if (matcher.matches()) {
  294.                     metaData.setLaunchYear(Integer.parseInt(matcher.group(1)));
  295.                     metaData.setLaunchNumber(Integer.parseInt(matcher.group(2)));
  296.                     metaData.setLaunchPiece(matcher.group(3));
  297.                 }
  298.                 return true;
  299.             }

  301.             case CENTER_NAME:
  302.                 metaData.setCenterName(keyValue.getValue());
  303.                 final String canonicalValue;
  304.                 if (keyValue.getValue().equals("SOLAR SYSTEM BARYCENTER") || keyValue.getValue().equals("SSB")) {
  305.                     canonicalValue = "SOLAR_SYSTEM_BARYCENTER";
  306.                 } else if (keyValue.getValue().equals("EARTH MOON BARYCENTER") || keyValue.getValue().equals("EARTH-MOON BARYCENTER") ||
  307.                         keyValue.getValue().equals("EARTH BARYCENTER") || keyValue.getValue().equals("EMB")) {
  308.                     canonicalValue = "EARTH_MOON";
  309.                 } else {
  310.                     canonicalValue = keyValue.getValue();
  311.                 }
  312.                 for (final CenterName c : CenterName.values()) {
  313.                     if (c.name().equals(canonicalValue)) {
  314.                         metaData.setHasCreatableBody(true);
  315.                         metaData.setCenterBody(c.getCelestialBody());
  316.                         metaData.getODMFile().setMuCreated(c.getCelestialBody().getGM());
  317.                     }
  318.                 }
  319.                 return true;

  321.             case REF_FRAME:
  322.                 metaData.setFrameString(keyValue.getValue());
  323.                 metaData.setRefFrame(parseCCSDSFrame(keyValue.getValue()).getFrame(getConventions(), isSimpleEOP()));
  324.                 return true;

  326.             case REF_FRAME_EPOCH:
  327.                 metaData.setFrameEpochString(keyValue.getValue());
  328.                 return true;

  330.             case TIME_SYSTEM:
  331.                 if (!CcsdsTimeScale.contains(keyValue.getValue())) {
  332.                     throw new OrekitException(
  333.                             OrekitMessages.CCSDS_TIME_SYSTEM_NOT_IMPLEMENTED,
  334.                             keyValue.getValue());
  335.                 }
  336.                 final CcsdsTimeScale timeSystem =
  337.                         CcsdsTimeScale.valueOf(keyValue.getValue());
  338.                 metaData.setTimeSystem(timeSystem);
  339.                 if (metaData.getFrameEpochString() != null) {
  340.                     metaData.setFrameEpoch(parseDate(metaData.getFrameEpochString(), timeSystem));
  341.                 }
  342.                 return true;

  344.             default:
  345.                 return false;
  346.         }
  347.     }

  349.     /** Parse a general state data key = value entry.
  350.      * @param keyValue key = value pair
  351.      * @param general instance to update with parsed entry
  352.      * @param comment previous comment lines, will be emptied if used by the keyword
  353.      * @return true if the keyword was a meta-data keyword and has been parsed
  354.      * @exception OrekitException if center body or frame cannot be retrieved
  355.      */
  356.     protected boolean parseGeneralStateDataEntry(final KeyValue keyValue,
  357.                                                  final OGMFile general, final List<String> comment)
  358.         throws OrekitException {
  359.         switch (keyValue.getKeyword()) {

  361.             case EPOCH:
  362.                 general.setEpochComment(comment);
  363.                 comment.clear();
  364.                 general.setEpoch(parseDate(keyValue.getValue(), general.getMetaData().getTimeSystem()));
  365.                 return true;

  367.             case SEMI_MAJOR_AXIS:
  368.                 general.setKeplerianElementsComment(comment);
  369.                 comment.clear();
  370.                 general.setA(keyValue.getDoubleValue() * 1000);
  371.                 general.setHasKeplerianElements(true);
  372.                 return true;

  374.             case ECCENTRICITY:
  375.                 general.setE(keyValue.getDoubleValue());
  376.                 return true;

  378.             case INCLINATION:
  379.                 general.setI(FastMath.toRadians(keyValue.getDoubleValue()));
  380.                 return true;

  382.             case RA_OF_ASC_NODE:
  383.                 general.setRaan(FastMath.toRadians(keyValue.getDoubleValue()));
  384.                 return true;

  386.             case ARG_OF_PERICENTER:
  387.                 general.setPa(FastMath.toRadians(keyValue.getDoubleValue()));
  388.                 return true;

  390.             case TRUE_ANOMALY:
  391.                 general.setAnomalyType("TRUE");
  392.                 general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
  393.                 return true;

  395.             case MEAN_ANOMALY:
  396.                 general.setAnomalyType("MEAN");
  397.                 general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
  398.                 return true;

  400.             case GM:
  401.                 general.setMuParsed(keyValue.getDoubleValue() * 1e9);
  402.                 return true;

  404.             case MASS:
  405.                 comment.addAll(0, general.getSpacecraftComment());
  406.                 general.setSpacecraftComment(comment);
  407.                 comment.clear();
  408.                 general.setMass(keyValue.getDoubleValue());
  409.                 return true;

  411.             case SOLAR_RAD_AREA:
  412.                 comment.addAll(0, general.getSpacecraftComment());
  413.                 general.setSpacecraftComment(comment);
  414.                 comment.clear();
  415.                 general.setSolarRadArea(keyValue.getDoubleValue());
  416.                 return true;

  418.             case SOLAR_RAD_COEFF:
  419.                 comment.addAll(0, general.getSpacecraftComment());
  420.                 general.setSpacecraftComment(comment);
  421.                 comment.clear();
  422.                 general.setSolarRadCoeff(keyValue.getDoubleValue());
  423.                 return true;

  425.             case DRAG_AREA:
  426.                 comment.addAll(0, general.getSpacecraftComment());
  427.                 general.setSpacecraftComment(comment);
  428.                 comment.clear();
  429.                 general.setDragArea(keyValue.getDoubleValue());
  430.                 return true;

  432.             case DRAG_COEFF:
  433.                 comment.addAll(0, general.getSpacecraftComment());
  434.                 general.setSpacecraftComment(comment);
  435.                 comment.clear();
  436.                 general.setDragCoeff(keyValue.getDoubleValue());
  437.                 return true;

  439.             case COV_REF_FRAME:
  440.                 general.setCovarianceComment(comment);
  441.                 comment.clear();
  442.                 final CCSDSFrame covFrame = parseCCSDSFrame(keyValue.getValue());
  443.                 if (covFrame.isLof()) {
  444.                     general.setCovRefLofType(covFrame.getLofType());
  445.                 } else {
  446.                     general.setCovRefFrame(covFrame.getFrame(getConventions(), isSimpleEOP()));
  447.                 }
  448.                 return true;

  450.             case CX_X:
  451.                 general.createCovarianceMatrix();
  452.                 general.setCovarianceMatrixEntry(0, 0, keyValue.getDoubleValue() * 1.0e6);
  453.                 return true;

  455.             case CY_X:
  456.                 general.setCovarianceMatrixEntry(0, 1, keyValue.getDoubleValue() * 1.0e6);
  457.                 return true;

  459.             case CY_Y:
  460.                 general.setCovarianceMatrixEntry(1, 1, keyValue.getDoubleValue() * 1.0e6);
  461.                 return true;

  463.             case CZ_X:
  464.                 general.setCovarianceMatrixEntry(0, 2, keyValue.getDoubleValue() * 1.0e6);
  465.                 return true;

  467.             case CZ_Y:
  468.                 general.setCovarianceMatrixEntry(1, 2, keyValue.getDoubleValue() * 1.0e6);
  469.                 return true;

  471.             case CZ_Z:
  472.                 general.setCovarianceMatrixEntry(2, 2, keyValue.getDoubleValue() * 1.0e6);
  473.                 return true;

  475.             case CX_DOT_X:
  476.                 general.setCovarianceMatrixEntry(0, 3, keyValue.getDoubleValue() * 1.0e6);
  477.                 return true;

  479.             case CX_DOT_Y:
  480.                 general.setCovarianceMatrixEntry(1, 3, keyValue.getDoubleValue() * 1.0e6);
  481.                 return true;

  483.             case CX_DOT_Z:
  484.                 general.setCovarianceMatrixEntry(2, 3, keyValue.getDoubleValue() * 1.0e6);
  485.                 return true;

  487.             case CX_DOT_X_DOT:
  488.                 general.setCovarianceMatrixEntry(3, 3, keyValue.getDoubleValue() * 1.0e6);
  489.                 return true;

  491.             case CY_DOT_X:
  492.                 general.setCovarianceMatrixEntry(0, 4, keyValue.getDoubleValue() * 1.0e6);
  493.                 return true;

  495.             case CY_DOT_Y:
  496.                 general.setCovarianceMatrixEntry(1, 4, keyValue.getDoubleValue() * 1.0e6);
  497.                 return true;

  499.             case CY_DOT_Z:
  500.                 general.setCovarianceMatrixEntry(2, 4, keyValue.getDoubleValue() * 1.0e6);
  501.                 return true;

  503.             case CY_DOT_X_DOT:
  504.                 general.setCovarianceMatrixEntry(3, 4, keyValue.getDoubleValue() * 1.0e6);
  505.                 return true;

  507.             case CY_DOT_Y_DOT:
  508.                 general.setCovarianceMatrixEntry(4, 4, keyValue.getDoubleValue() * 1.0e6);
  509.                 return true;

  511.             case CZ_DOT_X:
  512.                 general.setCovarianceMatrixEntry(0, 5, keyValue.getDoubleValue() * 1.0e6);
  513.                 return true;

  515.             case CZ_DOT_Y:
  516.                 general.setCovarianceMatrixEntry(1, 5, keyValue.getDoubleValue() * 1.0e6);
  517.                 return true;

  519.             case CZ_DOT_Z:
  520.                 general.setCovarianceMatrixEntry(2, 5, keyValue.getDoubleValue() * 1.0e6);
  521.                 return true;

  523.             case CZ_DOT_X_DOT:
  524.                 general.setCovarianceMatrixEntry(3, 5, keyValue.getDoubleValue() * 1.0e6);
  525.                 return true;

  527.             case CZ_DOT_Y_DOT:
  528.                 general.setCovarianceMatrixEntry(4, 5, keyValue.getDoubleValue() * 1.0e6);
  529.                 return true;

  531.             case CZ_DOT_Z_DOT:
  532.                 general.setCovarianceMatrixEntry(5, 5, keyValue.getDoubleValue() * 1.0e6);
  533.                 return true;

  535.             case USER_DEFINED_X:
  536.                 general.setUserDefinedParameters(keyValue.getKey(), keyValue.getValue());
  537.                 return true;

  539.             default:
  540.                 return false;
  541.         }
  542.     }

  544.     /** Parse a CCSDS frame.
  545.      * @param frameName name of the frame, as the value of a CCSDS key=value line
  546.      * @return CCSDS frame corresponding to the name
  547.      */
  548.     protected CCSDSFrame parseCCSDSFrame(final String frameName) {
  549.         return CCSDSFrame.valueOf(frameName.replaceAll("-", ""));
  550.     }

  552.     /** Parse a date.
  553.      * @param date date to parse, as the value of a CCSDS key=value line
  554.      * @param timeSystem time system to use
  555.      * @return parsed date
  556.      * @exception OrekitException if some time scale cannot be retrieved
  557.      */
  558.     protected AbsoluteDate parseDate(final String date, final CcsdsTimeScale timeSystem)
  559.         throws OrekitException {
  560.         return timeSystem.parseDate(date, conventions, missionReferenceDate);
  561.     }

  563. }
Created with JaCoCo 0.7.9.201702052155