ODMParser.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.files.ccsds;

  19. import java.io.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.annotation.DefaultDataContext;
  28. import org.orekit.bodies.CelestialBodies;
  29. import org.orekit.data.DataContext;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.errors.OrekitMessages;
  32. import org.orekit.time.AbsoluteDate;
  33. import org.orekit.utils.IERSConventions;

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

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

  55.     /** Pattern for dash. */
  56.     private static final Pattern DASH = Pattern.compile("-");

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

  61.     /** Gravitational coefficient. */
  62.     private final  double mu;

  64.     /** IERS Conventions. */
  65.     private final  IERSConventions conventions;

  67.     /** Indicator for simple or accurate EOP interpolation. */
  68.     private final  boolean simpleEOP;

  70.     /** Data context used for obtain frames and time scales. */
  71.     private final DataContext dataContext;

  73.     /** Launch Year. */
  74.     private int launchYear;

  76.     /** Launch number. */
  77.     private int launchNumber;

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

  82.     /** Complete constructor.
  83.      *
  84.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  85.      *
  86.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  87.      * @param mu gravitational coefficient
  88.      * @param conventions IERS Conventions
  89.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  90.      * @param launchYear launch year for TLEs
  91.      * @param launchNumber launch number for TLEs
  92.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  93.      * @see #ODMParser(AbsoluteDate, double, IERSConventions, boolean, int, int, String, DataContext)
  94.      * @deprecated use {@link #ODMParser(AbsoluteDate, double, IERSConventions, boolean,
  95.      * int, int, String, DataContext)} instead.
  96.      */
  97.     @Deprecated
  98.     @DefaultDataContext
  99.     protected ODMParser(final AbsoluteDate missionReferenceDate, final double mu,
  100.                         final IERSConventions conventions, final boolean simpleEOP,
  101.                         final int launchYear, final int launchNumber, final String launchPiece) {
  102.         this(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber,
  103.                 launchPiece, DataContext.getDefault());
  104.     }

  106.     /** Complete constructor.
  107.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  108.      * @param mu gravitational coefficient
  109.      * @param conventions IERS Conventions
  110.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  111.      * @param launchYear launch year for TLEs
  112.      * @param launchNumber launch number for TLEs
  113.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  114.      * @param dataContext used to retrieve frames and time scales.
  115.      * @since 10.1
  116.      */
  117.     protected ODMParser(final AbsoluteDate missionReferenceDate, final double mu,
  118.                         final IERSConventions conventions, final boolean simpleEOP,
  119.                         final int launchYear, final int launchNumber,
  120.                         final String launchPiece,
  121.                         final DataContext dataContext) {
  122.         this.missionReferenceDate = missionReferenceDate;
  123.         this.mu                   = mu;
  124.         this.conventions          = conventions;
  125.         this.simpleEOP            = simpleEOP;
  126.         this.launchYear           = launchYear;
  127.         this.launchNumber         = launchNumber;
  128.         this.launchPiece          = launchPiece;
  129.         this.dataContext          = dataContext;
  130.     }

  132.     /** Set initial date.
  133.      * @param newMissionReferenceDate mission reference date to use while parsing
  134.      * @return a new instance, with mission reference date replaced
  135.      * @see #getMissionReferenceDate()
  136.      */
  137.     public abstract ODMParser withMissionReferenceDate(AbsoluteDate newMissionReferenceDate);

  139.     /** Get initial date.
  140.      * @return mission reference date to use while parsing
  141.      * @see #withMissionReferenceDate(AbsoluteDate)
  142.      */
  143.     public AbsoluteDate getMissionReferenceDate() {
  144.         return missionReferenceDate;
  145.     }

  147.     /** Set gravitational coefficient.
  148.      * @param newMu gravitational coefficient to use while parsing
  149.      * @return a new instance, with gravitational coefficient value replaced
  150.      * @see #getMu()
  151.      */
  152.     public abstract ODMParser withMu(double newMu);

  154.     /** Get gravitational coefficient.
  155.      * @return gravitational coefficient to use while parsing
  156.      * @see #withMu(double)
  157.      */
  158.     public double getMu() {
  159.         return mu;
  160.     }

  162.     /** Set IERS conventions.
  163.      * @param newConventions IERS conventions to use while parsing
  164.      * @return a new instance, with IERS conventions replaced
  165.      * @see #getConventions()
  166.      */
  167.     public abstract ODMParser withConventions(IERSConventions newConventions);

  169.     /** Get IERS conventions.
  170.      * @return IERS conventions to use while parsing
  171.      * @see #withConventions(IERSConventions)
  172.      */
  173.     public IERSConventions getConventions() {
  174.         return conventions;
  175.     }

  177.     /** Set EOP interpolation method.
  178.      * @param newSimpleEOP if true, tidal effects are ignored when interpolating EOP
  179.      * @return a new instance, with EOP interpolation method replaced
  180.      * @see #isSimpleEOP()
  181.      */
  182.     public abstract ODMParser withSimpleEOP(boolean newSimpleEOP);

  184.     /** Get EOP interpolation method.
  185.      * @return true if tidal effects are ignored when interpolating EOP
  186.      * @see #withSimpleEOP(boolean)
  187.      */
  188.     public boolean isSimpleEOP() {
  189.         return simpleEOP;
  190.     }

  192.     /** Set international designator.
  193.      * <p>
  194.      * This method may be used to ensure the launch year number and pieces are
  195.      * correctly set if they are not present in the CCSDS file header in the
  196.      * OBJECT_ID in the form YYYY-NNNP{PP}. If they are already in the header,
  197.      * they will be parsed automatically regardless of this method being called
  198.      * or not (i.e. header information override information set here).
  199.      * </p>
  200.      * @param newLaunchYear launch year
  201.      * @param newLaunchNumber launch number
  202.      * @param newLaunchPiece piece of launch (from "A" to "ZZZ")
  203.      * @return a new instance, with TLE settings replaced
  204.      */
  205.     public abstract ODMParser withInternationalDesignator(int newLaunchYear,
  206.                                                           int newLaunchNumber,
  207.                                                           String newLaunchPiece);

  209.     /** Get the launch year.
  210.      * @return launch year
  211.      */
  212.     public int getLaunchYear() {
  213.         return launchYear;
  214.     }

  216.     /** Get the launch number.
  217.      * @return launch number
  218.      */
  219.     public int getLaunchNumber() {
  220.         return launchNumber;
  221.     }

  223.     /** Get the piece of launch.
  224.      * @return piece of launch
  225.      */
  226.     public String getLaunchPiece() {
  227.         return launchPiece;
  228.     }

  230.     /**
  231.      * Get the data context used for getting frames, time scales, and celestial bodies.
  232.      *
  233.      * @return the data context.
  234.      */
  235.     public DataContext getDataContext() {
  236.         return dataContext;
  237.     }

  239.     /**
  240.      * Set the data context.
  241.      *
  242.      * @param newDataContext used for frames, time scales, and celestial bodies.
  243.      * @return a new instance with the data context replaced.
  244.      */
  245.     public abstract ODMParser withDataContext(DataContext newDataContext);

  247.     /** Parse a CCSDS Orbit Data Message.
  248.      * @param fileName name of the file containing the message
  249.      * @return parsed orbit
  250.      */
  251.     public ODMFile parse(final String fileName) {
  252.         try (InputStream stream = new FileInputStream(fileName)) {
  253.             return parse(stream, fileName);
  254.         } catch (IOException e) {
  255.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  256.         }
  257.     }

  259.     /** Parse a CCSDS Orbit Data Message.
  260.      * @param stream stream containing message
  261.      * @return parsed orbit
  262.      */
  263.     public ODMFile parse(final InputStream stream) {
  264.         return parse(stream, "<unknown>");
  265.     }

  267.     /** Parse a CCSDS Orbit Data Message.
  268.      * @param stream stream containing message
  269.      * @param fileName name of the file containing the message (for error messages)
  270.      * @return parsed orbit
  271.      */
  272.     public abstract ODMFile parse(InputStream stream, String fileName);

  274.     /** Parse a comment line.
  275.      * @param keyValue key=value pair containing the comment
  276.      * @param comment placeholder where the current comment line should be added
  277.      * @return true if the line was a comment line and was parsed
  278.      */
  279.     protected boolean parseComment(final KeyValue keyValue, final List<String> comment) {
  280.         if (keyValue.getKeyword() == Keyword.COMMENT) {
  281.             comment.add(keyValue.getValue());
  282.             return true;
  283.         } else {
  284.             return false;
  285.         }
  286.     }

  288.     /** Parse an entry from the header.
  289.      * @param keyValue key = value pair
  290.      * @param odmFile instance to update with parsed entry
  291.      * @param comment previous comment lines, will be emptied if used by the keyword
  292.      * @return true if the keyword was a header keyword and has been parsed
  293.      */
  294.     protected boolean parseHeaderEntry(final KeyValue keyValue,
  295.                                        final ODMFile odmFile, final List<String> comment) {
  296.         switch (keyValue.getKeyword()) {

  298.             case CREATION_DATE:
  299.                 if (!comment.isEmpty()) {
  300.                     odmFile.setHeaderComment(comment);
  301.                     comment.clear();
  302.                 }
  303.                 odmFile.setCreationDate(new AbsoluteDate(
  304.                         keyValue.getValue(),
  305.                         dataContext.getTimeScales().getUTC()));
  306.                 return true;

  308.             case ORIGINATOR:
  309.                 odmFile.setOriginator(keyValue.getValue());
  310.                 return true;

  312.             default:
  313.                 return false;

  315.         }

  317.     }

  319.     /** Parse a meta-data key = value entry.
  320.      * @param keyValue key = value pair
  321.      * @param metaData instance to update with parsed entry
  322.      * @param comment previous comment lines, will be emptied if used by the keyword
  323.      * @return true if the keyword was a meta-data keyword and has been parsed
  324.      */
  325.     protected boolean parseMetaDataEntry(final KeyValue keyValue,
  326.                                          final ODMMetaData metaData, final List<String> comment) {
  327.         switch (keyValue.getKeyword()) {
  328.             case OBJECT_NAME:
  329.                 if (!comment.isEmpty()) {
  330.                     metaData.setComment(comment);
  331.                     comment.clear();
  332.                 }
  333.                 metaData.setObjectName(keyValue.getValue());
  334.                 return true;

  336.             case OBJECT_ID: {
  337.                 metaData.setObjectID(keyValue.getValue());
  338.                 final Matcher matcher = INTERNATIONAL_DESIGNATOR.matcher(keyValue.getValue());
  339.                 if (matcher.matches()) {
  340.                     metaData.setLaunchYear(Integer.parseInt(matcher.group(1)));
  341.                     metaData.setLaunchNumber(Integer.parseInt(matcher.group(2)));
  342.                     metaData.setLaunchPiece(matcher.group(3));
  343.                 }
  344.                 return true;
  345.             }

  347.             case CENTER_NAME:
  348.                 metaData.setCenterName(keyValue.getValue());
  349.                 final String canonicalValue;
  350.                 if (keyValue.getValue().equals("SOLAR SYSTEM BARYCENTER") || keyValue.getValue().equals("SSB")) {
  351.                     canonicalValue = "SOLAR_SYSTEM_BARYCENTER";
  352.                 } else if (keyValue.getValue().equals("EARTH MOON BARYCENTER") || keyValue.getValue().equals("EARTH-MOON BARYCENTER") ||
  353.                         keyValue.getValue().equals("EARTH BARYCENTER") || keyValue.getValue().equals("EMB")) {
  354.                     canonicalValue = "EARTH_MOON";
  355.                 } else {
  356.                     canonicalValue = keyValue.getValue();
  357.                 }
  358.                 for (final CenterName c : CenterName.values()) {
  359.                     if (c.name().equals(canonicalValue)) {
  360.                         metaData.setHasCreatableBody(true);
  361.                         final CelestialBodies celestialBodies =
  362.                                 getDataContext().getCelestialBodies();
  363.                         metaData.setCenterBody(c.getCelestialBody(celestialBodies));
  364.                         metaData.getODMFile().setMuCreated(
  365.                                 c.getCelestialBody(celestialBodies).getGM());
  366.                     }
  367.                 }
  368.                 return true;

  370.             case REF_FRAME:
  371.                 metaData.setFrameString(keyValue.getValue());
  372.                 metaData.setRefFrame(parseCCSDSFrame(keyValue.getValue())
  373.                         .getFrame(getConventions(), isSimpleEOP(), getDataContext()));
  374.                 return true;

  376.             case REF_FRAME_EPOCH:
  377.                 metaData.setFrameEpochString(keyValue.getValue());
  378.                 return true;

  380.             case TIME_SYSTEM:
  381.                 if (!CcsdsTimeScale.contains(keyValue.getValue())) {
  382.                     throw new OrekitException(
  383.                             OrekitMessages.CCSDS_TIME_SYSTEM_NOT_IMPLEMENTED,
  384.                             keyValue.getValue());
  385.                 }
  386.                 final CcsdsTimeScale timeSystem =
  387.                         CcsdsTimeScale.valueOf(keyValue.getValue());
  388.                 metaData.setTimeSystem(timeSystem);
  389.                 if (metaData.getFrameEpochString() != null) {
  390.                     metaData.setFrameEpoch(parseDate(metaData.getFrameEpochString(), timeSystem));
  391.                 }
  392.                 return true;

  394.             default:
  395.                 return false;
  396.         }
  397.     }

  399.     /** Parse a general state data key = value entry.
  400.      * @param keyValue key = value pair
  401.      * @param general instance to update with parsed entry
  402.      * @param comment previous comment lines, will be emptied if used by the keyword
  403.      * @return true if the keyword was a meta-data keyword and has been parsed
  404.      */
  405.     protected boolean parseGeneralStateDataEntry(final KeyValue keyValue,
  406.                                                  final OGMFile general, final List<String> comment) {
  407.         switch (keyValue.getKeyword()) {

  409.             case EPOCH:
  410.                 general.setEpochComment(comment);
  411.                 comment.clear();
  412.                 general.setEpoch(parseDate(keyValue.getValue(), general.getMetaData().getTimeSystem()));
  413.                 return true;

  415.             case SEMI_MAJOR_AXIS:
  416.                 general.setKeplerianElementsComment(comment);
  417.                 comment.clear();
  418.                 general.setA(keyValue.getDoubleValue() * 1000);
  419.                 general.setHasKeplerianElements(true);
  420.                 return true;

  422.             case ECCENTRICITY:
  423.                 general.setE(keyValue.getDoubleValue());
  424.                 return true;

  426.             case INCLINATION:
  427.                 general.setI(FastMath.toRadians(keyValue.getDoubleValue()));
  428.                 return true;

  430.             case RA_OF_ASC_NODE:
  431.                 general.setRaan(FastMath.toRadians(keyValue.getDoubleValue()));
  432.                 return true;

  434.             case ARG_OF_PERICENTER:
  435.                 general.setPa(FastMath.toRadians(keyValue.getDoubleValue()));
  436.                 return true;

  438.             case TRUE_ANOMALY:
  439.                 general.setAnomalyType("TRUE");
  440.                 general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
  441.                 return true;

  443.             case MEAN_ANOMALY:
  444.                 general.setAnomalyType("MEAN");
  445.                 general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
  446.                 return true;

  448.             case GM:
  449.                 general.setMuParsed(keyValue.getDoubleValue() * 1e9);
  450.                 return true;

  452.             case MASS:
  453.                 comment.addAll(0, general.getSpacecraftComment());
  454.                 general.setSpacecraftComment(comment);
  455.                 comment.clear();
  456.                 general.setMass(keyValue.getDoubleValue());
  457.                 return true;

  459.             case SOLAR_RAD_AREA:
  460.                 comment.addAll(0, general.getSpacecraftComment());
  461.                 general.setSpacecraftComment(comment);
  462.                 comment.clear();
  463.                 general.setSolarRadArea(keyValue.getDoubleValue());
  464.                 return true;

  466.             case SOLAR_RAD_COEFF:
  467.                 comment.addAll(0, general.getSpacecraftComment());
  468.                 general.setSpacecraftComment(comment);
  469.                 comment.clear();
  470.                 general.setSolarRadCoeff(keyValue.getDoubleValue());
  471.                 return true;

  473.             case DRAG_AREA:
  474.                 comment.addAll(0, general.getSpacecraftComment());
  475.                 general.setSpacecraftComment(comment);
  476.                 comment.clear();
  477.                 general.setDragArea(keyValue.getDoubleValue());
  478.                 return true;

  480.             case DRAG_COEFF:
  481.                 comment.addAll(0, general.getSpacecraftComment());
  482.                 general.setSpacecraftComment(comment);
  483.                 comment.clear();
  484.                 general.setDragCoeff(keyValue.getDoubleValue());
  485.                 return true;

  487.             case COV_REF_FRAME:
  488.                 general.setCovarianceComment(comment);
  489.                 comment.clear();
  490.                 final CCSDSFrame covFrame = parseCCSDSFrame(keyValue.getValue());
  491.                 if (covFrame.isLof()) {
  492.                     general.setCovRefLofType(covFrame.getLofType());
  493.                 } else {
  494.                     general.setCovRefFrame(covFrame
  495.                             .getFrame(getConventions(), isSimpleEOP(), getDataContext()));
  496.                 }
  497.                 return true;

  499.             case CX_X:
  500.                 general.createCovarianceMatrix();
  501.                 general.setCovarianceMatrixEntry(0, 0, keyValue.getDoubleValue() * 1.0e6);
  502.                 return true;

  504.             case CY_X:
  505.                 general.setCovarianceMatrixEntry(0, 1, keyValue.getDoubleValue() * 1.0e6);
  506.                 return true;

  508.             case CY_Y:
  509.                 general.setCovarianceMatrixEntry(1, 1, keyValue.getDoubleValue() * 1.0e6);
  510.                 return true;

  512.             case CZ_X:
  513.                 general.setCovarianceMatrixEntry(0, 2, keyValue.getDoubleValue() * 1.0e6);
  514.                 return true;

  516.             case CZ_Y:
  517.                 general.setCovarianceMatrixEntry(1, 2, keyValue.getDoubleValue() * 1.0e6);
  518.                 return true;

  520.             case CZ_Z:
  521.                 general.setCovarianceMatrixEntry(2, 2, keyValue.getDoubleValue() * 1.0e6);
  522.                 return true;

  524.             case CX_DOT_X:
  525.                 general.setCovarianceMatrixEntry(0, 3, keyValue.getDoubleValue() * 1.0e6);
  526.                 return true;

  528.             case CX_DOT_Y:
  529.                 general.setCovarianceMatrixEntry(1, 3, keyValue.getDoubleValue() * 1.0e6);
  530.                 return true;

  532.             case CX_DOT_Z:
  533.                 general.setCovarianceMatrixEntry(2, 3, keyValue.getDoubleValue() * 1.0e6);
  534.                 return true;

  536.             case CX_DOT_X_DOT:
  537.                 general.setCovarianceMatrixEntry(3, 3, keyValue.getDoubleValue() * 1.0e6);
  538.                 return true;

  540.             case CY_DOT_X:
  541.                 general.setCovarianceMatrixEntry(0, 4, keyValue.getDoubleValue() * 1.0e6);
  542.                 return true;

  544.             case CY_DOT_Y:
  545.                 general.setCovarianceMatrixEntry(1, 4, keyValue.getDoubleValue() * 1.0e6);
  546.                 return true;

  548.             case CY_DOT_Z:
  549.                 general.setCovarianceMatrixEntry(2, 4, keyValue.getDoubleValue() * 1.0e6);
  550.                 return true;

  552.             case CY_DOT_X_DOT:
  553.                 general.setCovarianceMatrixEntry(3, 4, keyValue.getDoubleValue() * 1.0e6);
  554.                 return true;

  556.             case CY_DOT_Y_DOT:
  557.                 general.setCovarianceMatrixEntry(4, 4, keyValue.getDoubleValue() * 1.0e6);
  558.                 return true;

  560.             case CZ_DOT_X:
  561.                 general.setCovarianceMatrixEntry(0, 5, keyValue.getDoubleValue() * 1.0e6);
  562.                 return true;

  564.             case CZ_DOT_Y:
  565.                 general.setCovarianceMatrixEntry(1, 5, keyValue.getDoubleValue() * 1.0e6);
  566.                 return true;

  568.             case CZ_DOT_Z:
  569.                 general.setCovarianceMatrixEntry(2, 5, keyValue.getDoubleValue() * 1.0e6);
  570.                 return true;

  572.             case CZ_DOT_X_DOT:
  573.                 general.setCovarianceMatrixEntry(3, 5, keyValue.getDoubleValue() * 1.0e6);
  574.                 return true;

  576.             case CZ_DOT_Y_DOT:
  577.                 general.setCovarianceMatrixEntry(4, 5, keyValue.getDoubleValue() * 1.0e6);
  578.                 return true;

  580.             case CZ_DOT_Z_DOT:
  581.                 general.setCovarianceMatrixEntry(5, 5, keyValue.getDoubleValue() * 1.0e6);
  582.                 return true;

  584.             case USER_DEFINED_X:
  585.                 general.setUserDefinedParameters(keyValue.getKey(), keyValue.getValue());
  586.                 return true;

  588.             default:
  589.                 return false;
  590.         }
  591.     }

  593.     /** Parse a CCSDS frame.
  594.      * @param frameName name of the frame, as the value of a CCSDS key=value line
  595.      * @return CCSDS frame corresponding to the name
  596.      */
  597.     protected CCSDSFrame parseCCSDSFrame(final String frameName) {
  598.         return CCSDSFrame.valueOf(DASH.matcher(frameName).replaceAll(""));
  599.     }

  601.     /** Parse a date.
  602.      * @param date date to parse, as the value of a CCSDS key=value line
  603.      * @param timeSystem time system to use
  604.      * @return parsed date
  605.      */
  606.     protected AbsoluteDate parseDate(final String date, final CcsdsTimeScale timeSystem) {
  607.         return timeSystem.parseDate(date, conventions, missionReferenceDate,
  608.                 getDataContext().getTimeScales());
  609.     }

  611. }
Created with JaCoCo 0.8.6.202009150832