OEMParser.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.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.nio.charset.StandardCharsets;
  24. import java.util.ArrayList;
  25. import java.util.List;
  26. import java.util.Scanner;

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

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

  50.     /** Default interpolation degree. */
  51.     private int interpolationDegree;

  53.     /** Simple constructor.
  54.      * <p>
  55.      * This class is immutable, and hence thread safe. When parts
  56.      * must be changed, such as reference date for Mission Elapsed Time or
  57.      * Mission Relative Time time systems, or the gravitational coefficient or
  58.      * the IERS conventions, the various {@code withXxx} methods must be called,
  59.      * which create a new immutable instance with the new parameters. This
  60.      * is a combination of the
  61.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  62.      * pattern</a> and a
  63.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  64.      * interface</a>.
  65.      * </p>
  66.      * <p>
  67.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  68.      * If such time systems are used, it must be initialized before parsing by calling {@link
  69.      * #withMissionReferenceDate(AbsoluteDate)}.
  70.      * </p>
  71.      * <p>
  72.      * The gravitational coefficient is not set here. If it is needed in order
  73.      * to parse Cartesian orbits where the value is not set in the CCSDS file, it must
  74.      * be initialized before parsing by calling {@link #withMu(double)}.
  75.      * </p>
  76.      * <p>
  77.      * The IERS conventions to use is not set here. If it is needed in order to
  78.      * parse some reference frames or UT1 time scale, it must be initialized before
  79.      * parsing by calling {@link #withConventions(IERSConventions)}.
  80.      * </p>
  81.      * <p>
  82.      * The international designator parameters (launch year, launch number and
  83.      * launch piece) are not set here. If they are needed, they must be initialized before
  84.      * parsing by calling {@link #withInternationalDesignator(int, int, String)}
  85.      * </p>
  86.      * <p>
  87.      * The default interpolation degree is not set here. It is set to one by default. If another value
  88.      * is needed it must be initialized before parsing by calling {@link #withInterpolationDegree(int)}
  89.      * </p>
  90.      *
  91.      * <p>This method uses the {@link DataContext#getDefault() default data context}. See
  92.      * {@link #withDataContext(DataContext)}.
  93.      */
  94.     @DefaultDataContext
  95.     public OEMParser() {
  96.         this(DataContext.getDefault());
  97.     }

  99.     /** Constructor with data context.
  100.      * <p>
  101.      * This class is immutable, and hence thread safe. When parts
  102.      * must be changed, such as reference date for Mission Elapsed Time or
  103.      * Mission Relative Time time systems, or the gravitational coefficient or
  104.      * the IERS conventions, the various {@code withXxx} methods must be called,
  105.      * which create a new immutable instance with the new parameters. This
  106.      * is a combination of the
  107.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  108.      * pattern</a> and a
  109.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  110.      * interface</a>.
  111.      * </p>
  112.      * <p>
  113.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  114.      * If such time systems are used, it must be initialized before parsing by calling {@link
  115.      * #withMissionReferenceDate(AbsoluteDate)}.
  116.      * </p>
  117.      * <p>
  118.      * The gravitational coefficient is not set here. If it is needed in order
  119.      * to parse Cartesian orbits where the value is not set in the CCSDS file, it must
  120.      * be initialized before parsing by calling {@link #withMu(double)}.
  121.      * </p>
  122.      * <p>
  123.      * The IERS conventions to use is not set here. If it is needed in order to
  124.      * parse some reference frames or UT1 time scale, it must be initialized before
  125.      * parsing by calling {@link #withConventions(IERSConventions)}.
  126.      * </p>
  127.      * <p>
  128.      * The international designator parameters (launch year, launch number and
  129.      * launch piece) are not set here. If they are needed, they must be initialized before
  130.      * parsing by calling {@link #withInternationalDesignator(int, int, String)}
  131.      * </p>
  132.      * <p>
  133.      * The default interpolation degree is not set here. It is set to one by default. If another value
  134.      * is needed it must be initialized before parsing by calling {@link #withInterpolationDegree(int)}
  135.      * </p>
  136.      *
  137.      * @param dataContext used by the parser.
  138.      *
  139.      * @see #OEMParser()
  140.      * @see #withDataContext(DataContext)
  141.      * @since 10.1
  142.      */
  143.     public OEMParser(final DataContext dataContext) {
  144.         this(AbsoluteDate.FUTURE_INFINITY, Double.NaN, null, true, 0, 0, "", 1, dataContext);
  145.     }

  147.     /** Complete constructor.
  148.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  149.      * @param mu gravitational coefficient
  150.      * @param conventions IERS Conventions
  151.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  152.      * @param launchYear launch year for TLEs
  153.      * @param launchNumber launch number for TLEs
  154.      * @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
  155.      * @param interpolationDegree interpolation degree
  156.      * @param dataContext used to retrieve frames, time scales, etc.
  157.      */
  158.     private OEMParser(final AbsoluteDate missionReferenceDate, final double mu,
  159.                       final IERSConventions conventions, final boolean simpleEOP,
  160.                       final int launchYear, final int launchNumber,
  161.                       final String launchPiece, final int interpolationDegree,
  162.                       final DataContext dataContext) {
  163.         super(missionReferenceDate, mu, conventions, simpleEOP, launchYear, launchNumber,
  164.                 launchPiece, dataContext);
  165.         this.interpolationDegree = interpolationDegree;
  166.     }

  168.     /** {@inheritDoc} */
  169.     @Override
  170.     public OEMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  171.         return new OEMParser(newMissionReferenceDate, getMu(), getConventions(), isSimpleEOP(),
  172.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  173.                              getInterpolationDegree(), getDataContext());
  174.     }

  176.     /** {@inheritDoc} */
  177.     @Override
  178.     public OEMParser withMu(final double newMu) {
  179.         return new OEMParser(getMissionReferenceDate(), newMu, getConventions(), isSimpleEOP(),
  180.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  181.                              getInterpolationDegree(), getDataContext());
  182.     }

  184.     /** {@inheritDoc} */
  185.     @Override
  186.     public OEMParser withConventions(final IERSConventions newConventions) {
  187.         return new OEMParser(getMissionReferenceDate(), getMu(), newConventions, isSimpleEOP(),
  188.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  189.                              getInterpolationDegree(), getDataContext());
  190.     }

  192.     /** {@inheritDoc} */
  193.     @Override
  194.     public OEMParser withSimpleEOP(final boolean newSimpleEOP) {
  195.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), newSimpleEOP,
  196.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  197.                              getInterpolationDegree(), getDataContext());
  198.     }

  200.     /** {@inheritDoc} */
  201.     @Override
  202.     public OEMParser withInternationalDesignator(final int newLaunchYear,
  203.                                                  final int newLaunchNumber,
  204.                                                  final String newLaunchPiece) {
  205.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  206.                              newLaunchYear, newLaunchNumber, newLaunchPiece,
  207.                              getInterpolationDegree(), getDataContext());
  208.     }

  210.     /** {@inheritDoc} */
  211.     @Override
  212.     public OEMParser withDataContext(final DataContext dataContext) {
  213.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  214.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  215.                              getInterpolationDegree(), dataContext);
  216.     }

  218.     /** Set default interpolation degree.
  219.      * <p>
  220.      * This method may be used to set a default interpolation degree which will be used
  221.      * when no interpolation degree is parsed in the meta-data of the file. Upon instantiation
  222.      * with {@link #OEMParser(DataContext)} the default interpolation degree is one.
  223.      * </p>
  224.      * @param newInterpolationDegree default interpolation degree to use while parsing
  225.      * @return a new instance, with interpolation degree data replaced
  226.      * @see #getInterpolationDegree()
  227.      * @since 10.3
  228.      */
  229.     public OEMParser withInterpolationDegree(final int newInterpolationDegree) {
  230.         return new OEMParser(getMissionReferenceDate(), getMu(), getConventions(), isSimpleEOP(),
  231.                              getLaunchYear(), getLaunchNumber(), getLaunchPiece(),
  232.                              newInterpolationDegree, getDataContext());
  233.     }

  235.     /** Get default interpolation degree.
  236.      * @return interpolationDegree default interpolation degree to use while parsing
  237.      * @see #withInterpolationDegree(int)
  238.      * @since 10.3
  239.      */
  240.     public int getInterpolationDegree() {
  241.         return interpolationDegree;
  242.     }

  244.     /** {@inheritDoc} */
  245.     @Override
  246.     public OEMFile parse(final String fileName) {
  247.         return (OEMFile) super.parse(fileName);
  248.     }

  250.     /** {@inheritDoc} */
  251.     @Override
  252.     public OEMFile parse(final InputStream stream) {
  253.         return (OEMFile) super.parse(stream);
  254.     }

  256.     /** {@inheritDoc} */
  257.     @Override
  258.     public OEMFile parse(final InputStream stream, final String fileName) {
  259.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  260.             return parse(reader, fileName);
  261.         } catch (IOException ioe) {
  262.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  263.         }
  264.     }

  266.     /** {@inheritDoc} */
  267.     @Override
  268.     public OEMFile parse(final BufferedReader reader, final String fileName) {

  270.         try {

  272.             // initialize internal data structures
  273.             final ParseInfo pi = new ParseInfo();
  274.             pi.fileName = fileName;
  275.             final OEMFile file = pi.file;

  277.             // set the additional data that has been configured prior the parsing by the user.
  278.             pi.file.setMissionReferenceDate(getMissionReferenceDate());
  279.             pi.file.setMuSet(getMu());
  280.             pi.file.setConventions(getConventions());
  281.             pi.file.setDataContext(getDataContext());

  283.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  284.                 ++pi.lineNumber;
  285.                 if (line.trim().length() == 0) {
  286.                     continue;
  287.                 }
  288.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  289.                 if (pi.keyValue.getKeyword() == null) {
  290.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  291.                 }
  292.                 switch (pi.keyValue.getKeyword()) {
  293.                     case CCSDS_OEM_VERS:
  294.                         file.setFormatVersion(pi.keyValue.getDoubleValue());
  295.                         break;

  297.                     case META_START:
  298.                         file.addEphemeridesBlock();
  299.                         pi.lastEphemeridesBlock = file.getEphemeridesBlocks().get(file.getEphemeridesBlocks().size() - 1);
  300.                         pi.lastEphemeridesBlock.getMetaData().setLaunchYear(getLaunchYear());
  301.                         pi.lastEphemeridesBlock.getMetaData().setLaunchNumber(getLaunchNumber());
  302.                         pi.lastEphemeridesBlock.getMetaData().setLaunchPiece(getLaunchPiece());
  303.                         pi.lastEphemeridesBlock.setInterpolationDegree(getInterpolationDegree());
  304.                         break;

  306.                     case START_TIME:
  307.                         pi.lastEphemeridesBlock.setStartTime(parseDate(pi.keyValue.getValue(),
  308.                                                                        pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  309.                         break;

  311.                     case USEABLE_START_TIME:
  312.                         pi.lastEphemeridesBlock.setUseableStartTime(parseDate(pi.keyValue.getValue(),
  313.                                                                               pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  314.                         break;

  316.                     case USEABLE_STOP_TIME:
  317.                         pi.lastEphemeridesBlock.setUseableStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  318.                         break;

  320.                     case STOP_TIME:
  321.                         pi.lastEphemeridesBlock.setStopTime(parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem()));
  322.                         break;

  324.                     case INTERPOLATION:
  325.                         pi.lastEphemeridesBlock.setInterpolationMethod(pi.keyValue.getValue());
  326.                         break;

  328.                     case INTERPOLATION_DEGREE:
  329.                         pi.lastEphemeridesBlock.setInterpolationDegree(Integer.parseInt(pi.keyValue.getValue()));
  330.                         break;

  332.                     case META_STOP:
  333.                         file.setMuUsed();
  334.                         parseEphemeridesDataLines(reader, pi);
  335.                         break;

  337.                     case COVARIANCE_START:
  338.                         parseCovarianceDataLines(reader, pi);
  339.                         break;

  341.                     default:
  342.                         boolean parsed = false;
  343.                         parsed = parsed || parseComment(pi.keyValue, pi.commentTmp);
  344.                         parsed = parsed || parseHeaderEntry(pi.keyValue, file, pi.commentTmp);
  345.                         if (pi.lastEphemeridesBlock != null) {
  346.                             parsed = parsed || parseMetaDataEntry(pi.keyValue,
  347.                                                                   pi.lastEphemeridesBlock.getMetaData(), pi.commentTmp);
  348.                             if (parsed && pi.keyValue.getKeyword() == Keyword.REF_FRAME_EPOCH) {
  349.                                 pi.lastEphemeridesBlock.setHasRefFrameEpoch(true);
  350.                             }
  351.                         }
  352.                         if (!parsed) {
  353.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  354.                         }
  355.                 }
  356.             }
  357.             file.checkTimeSystems();
  358.             return file;
  359.         } catch (IOException ioe) {
  360.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  361.         }
  362.     }

  364.     /**
  365.      * Parse an ephemeris data line and add its content to the ephemerides
  366.      * block.
  367.      *
  368.      * @param reader the reader
  369.      * @param pi the parser info
  370.      * @exception IOException if an error occurs while reading from the stream
  371.      */
  372.     private void parseEphemeridesDataLines(final BufferedReader reader,  final ParseInfo pi)
  373.         throws IOException {

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

  377.             ++pi.lineNumber;
  378.             if (line.trim().length() > 0) {
  379.                 pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  380.                 if (pi.keyValue.getKeyword() == null) {
  381.                     try (Scanner sc = new Scanner(line)) {
  382.                         final AbsoluteDate date = parseDate(sc.next(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  383.                         final Vector3D position = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  384.                                                                Double.parseDouble(sc.next()) * 1000,
  385.                                                                Double.parseDouble(sc.next()) * 1000);
  386.                         final Vector3D velocity = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  387.                                                                Double.parseDouble(sc.next()) * 1000,
  388.                                                                Double.parseDouble(sc.next()) * 1000);
  389.                         Vector3D acceleration = Vector3D.NaN;
  390.                         boolean hasAcceleration = false;
  391.                         if (sc.hasNext()) {
  392.                             acceleration = new Vector3D(Double.parseDouble(sc.next()) * 1000,
  393.                                                         Double.parseDouble(sc.next()) * 1000,
  394.                                                         Double.parseDouble(sc.next()) * 1000);
  395.                             hasAcceleration = true;
  396.                         }
  397.                         final TimeStampedPVCoordinates epDataLine;
  398.                         if (hasAcceleration) {
  399.                             epDataLine = new TimeStampedPVCoordinates(date, position, velocity, acceleration);
  400.                         } else {
  401.                             epDataLine = new TimeStampedPVCoordinates(date, position, velocity);
  402.                         }
  403.                         pi.lastEphemeridesBlock.getEphemeridesDataLines().add(epDataLine);
  404.                         pi.lastEphemeridesBlock.updateHasAcceleration(hasAcceleration);
  405.                     } catch (NumberFormatException nfe) {
  406.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  407.                                                   pi.lineNumber, pi.fileName, line);
  408.                     }
  409.                 } else {
  410.                     switch (pi.keyValue.getKeyword()) {
  411.                         case META_START:
  412.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  413.                             pi.commentTmp.clear();
  414.                             pi.lineNumber--;
  415.                             reader.reset();
  416.                             return;
  417.                         case COVARIANCE_START:
  418.                             pi.lastEphemeridesBlock.setEphemeridesDataLinesComment(pi.commentTmp);
  419.                             pi.commentTmp.clear();
  420.                             pi.lineNumber--;
  421.                             reader.reset();
  422.                             return;
  423.                         case COMMENT:
  424.                             pi.commentTmp.add(pi.keyValue.getValue());
  425.                             break;
  426.                         default :
  427.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  428.                     }
  429.                 }
  430.             }
  431.             reader.mark(300);

  433.         }
  434.     }

  436.     /**
  437.      * Parse the covariance data lines, create a set of CovarianceMatrix objects
  438.      * and add them in the covarianceMatrices list of the ephemerides block.
  439.      *
  440.      * @param reader the reader
  441.      * @param pi the parser info
  442.      * @throws IOException if an error occurs while reading from the stream
  443.      */
  444.     private void parseCovarianceDataLines(final BufferedReader reader, final ParseInfo pi)
  445.         throws IOException {
  446.         int i = 0;
  447.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {

  449.             ++pi.lineNumber;
  450.             if (line.trim().length() == 0) {
  451.                 continue;
  452.             }
  453.             pi.keyValue = new KeyValue(line, pi.lineNumber, pi.fileName);
  454.             if (pi.keyValue.getKeyword() == null) {
  455.                 try (Scanner sc = new Scanner(line)) {
  456.                     for (int j = 0; j < i + 1; j++) {
  457.                         pi.lastMatrix.addToEntry(i, j, Double.parseDouble(sc.next()));
  458.                         if (j != i) {
  459.                             pi.lastMatrix.addToEntry(j, i, pi.lastMatrix.getEntry(i, j));
  460.                         }
  461.                     }
  462.                     if (i == 5) {
  463.                         final OEMFile.CovarianceMatrix cm =
  464.                                 new OEMFile.CovarianceMatrix(pi.epoch, pi.covRefLofType, pi.covRefFrame, pi.lastMatrix);
  465.                         pi.lastEphemeridesBlock.getCovarianceMatrices().add(cm);
  466.                     }
  467.                     i++;
  468.                 } catch (NumberFormatException nfe) {
  469.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  470.                                               pi.lineNumber, pi.fileName, line);
  471.                 }
  472.             } else {
  473.                 switch (pi.keyValue.getKeyword()) {
  474.                     case EPOCH :
  475.                         i                = 0;
  476.                         pi.covRefLofType = null;
  477.                         pi.covRefFrame   = null;
  478.                         pi.lastMatrix    = MatrixUtils.createRealMatrix(6, 6);
  479.                         pi.epoch         = parseDate(pi.keyValue.getValue(), pi.lastEphemeridesBlock.getMetaData().getTimeSystem());
  480.                         break;
  481.                     case COV_REF_FRAME :
  482.                         final CCSDSFrame frame = parseCCSDSFrame(pi.keyValue.getValue());
  483.                         if (frame.isLof()) {
  484.                             pi.covRefLofType = frame.getLofType();
  485.                             pi.covRefFrame   = null;
  486.                         } else {
  487.                             pi.covRefLofType = null;
  488.                             pi.covRefFrame   = frame.getFrame(getConventions(), isSimpleEOP(), getDataContext());
  489.                         }
  490.                         break;
  491.                     case COVARIANCE_STOP :
  492.                         return;
  493.                     default :
  494.                         throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, pi.lineNumber, pi.fileName, line);
  495.                 }
  496.             }
  497.         }
  498.     }

  500.     /** Private class used to stock OEM parsing info.
  501.      * @author sports
  502.      */
  503.     private static class ParseInfo {

  505.         /** Ephemerides block being parsed. */
  506.         private OEMFile.EphemeridesBlock lastEphemeridesBlock;

  508.         /** Name of the file. */
  509.         private String fileName;

  511.         /** Current line number. */
  512.         private int lineNumber;

  514.         /** OEM file being read. */
  515.         private OEMFile file;

  517.         /** Key value of the line being read. */
  518.         private KeyValue keyValue;

  520.         /** Stored epoch. */
  521.         private AbsoluteDate epoch;

  523.         /** Covariance reference type of Local Orbital Frame. */
  524.         private LOFType covRefLofType;

  526.         /** Covariance reference frame. */
  527.         private Frame covRefFrame;
  528.         /** Stored matrix. */
  529.         private RealMatrix lastMatrix;

  531.         /** Stored comments. */
  532.         private List<String> commentTmp;

  534.         /** Create a new {@link ParseInfo} object. */
  535.         protected ParseInfo() {
  536.             lineNumber = 0;
  537.             file = new OEMFile();
  538.             commentTmp = new ArrayList<String>();
  539.         }
  540.     }
  541. }
Created with JaCoCo 0.8.6.202009150832