CRDParser.java

  1. /* Copyright 2002-2022 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.ilrs;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.util.Optional;
  22. import java.util.regex.Pattern;
  23. import java.util.stream.Stream;

  25. import org.hipparchus.util.FastMath;
  26. import org.orekit.annotation.DefaultDataContext;
  27. import org.orekit.data.DataContext;
  28. import org.orekit.data.DataSource;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitMessages;
  31. import org.orekit.files.ilrs.CRD.AnglesMeasurement;
  32. import org.orekit.files.ilrs.CRD.CRDDataBlock;
  33. import org.orekit.files.ilrs.CRD.MeteorologicalMeasurement;
  34. import org.orekit.files.ilrs.CRD.RangeMeasurement;
  35. import org.orekit.files.ilrs.CRDConfiguration.DetectorConfiguration;
  36. import org.orekit.files.ilrs.CRDConfiguration.LaserConfiguration;
  37. import org.orekit.files.ilrs.CRDConfiguration.MeteorologicalConfiguration;
  38. import org.orekit.files.ilrs.CRDConfiguration.SoftwareConfiguration;
  39. import org.orekit.files.ilrs.CRDConfiguration.SystemConfiguration;
  40. import org.orekit.files.ilrs.CRDConfiguration.TimingSystemConfiguration;
  41. import org.orekit.files.ilrs.CRDConfiguration.TransponderConfiguration;
  42. import org.orekit.time.AbsoluteDate;
  43. import org.orekit.time.DateComponents;
  44. import org.orekit.time.TimeComponents;
  45. import org.orekit.time.TimeScale;
  46. import org.orekit.utils.Constants;
  47. import org.orekit.utils.units.Unit;
  48. import org.orekit.utils.units.UnitsConverter;

  50. /**
  51.  * A parser for the CRD data file format.
  52.  * <p>
  53.  * It supports both 1.0 and 2.0 versions
  54.  * <p>
  55.  * <b>Note</b>: Not all the records are read by the parser. Only the most significants are parsed.
  56.  * Contributions are welcome to support more fields in the format.
  57.  * @see <a href="https://ilrs.gsfc.nasa.gov/docs/2009/crd_v1.01.pdf">1.0 file format</a>
  58.  * @see <a href="https://ilrs.gsfc.nasa.gov/docs/2019/crd_v2.01.pdf">2.0 file format</a>
  59.  * @author Bryan Cazabonne
  60.  * @since 10.3
  61.  */
  62. public class CRDParser {

  64.     /** Default supported files name pattern for CRD files. */
  65.     public static final String DEFAULT_CRD_SUPPORTED_NAMES = "^(?!0+$)\\w{1,12}\\_\\d{6,8}.\\w{3}$";

  67.     /** Nanometers units. */
  68.     private static final Unit NM = Unit.parse("nm");

  70.     /** Kilohertz units. */
  71.     private static final Unit KHZ = Unit.parse("kHz");

  73.     /** Microseconds units. */
  74.     private static final Unit US = Unit.parse("µs");

  76.     /** mbar to bar converter. */
  77.     private static final UnitsConverter MBAR_TO_BAR = new UnitsConverter(Unit.parse("mbar"), Unit.parse("bar"));

  79.     /** File format. */
  80.     private static final String FILE_FORMAT = "CRD";

  82.     /** Pattern for delimiting regular expressions. */
  83.     private static final Pattern SEPARATOR = Pattern.compile("\\s+");

  85.     /** Pattern for delimiting expressions with comma. */
  86.     private static final Pattern COMMA = Pattern.compile(",");

  88.     /** Time scale used to define epochs in CPF file. */
  89.     private final TimeScale timeScale;

  91.     /**
  92.      * Default constructor.
  93.      * <p>
  94.      * This constructor uses the {@link DataContext#getDefault() default data context}.
  95.      */
  96.     @DefaultDataContext
  97.     public CRDParser() {
  98.         this(DataContext.getDefault().getTimeScales().getUTC());
  99.     }

  101.     /**
  102.      * Constructor.
  103.      * @param utc utc time scale to read epochs
  104.      */
  105.     public CRDParser(final TimeScale utc) {
  106.         this.timeScale = utc;
  107.     }

  109.     /**
  110.      * Get the time scale used to read the file.
  111.      * @return the time scale used to read the file
  112.      */
  113.     public TimeScale getTimeScale() {
  114.         return timeScale;
  115.     }

  117.     /**
  118.      * Parse a CRD file.
  119.      * @param source data source containing the CRD file.
  120.      * @return a parsed CRD file.
  121.      * @throws IOException if {@code reader} throws one.
  122.      */
  123.     public CRD parse(final DataSource source) throws IOException {

  125.         // Initialize internal data structures
  126.         final ParseInfo pi = new ParseInfo();

  128.         int lineNumber = 0;
  129.         Stream<LineParser> crdParsers = Stream.of(LineParser.H1);
  130.         try (BufferedReader reader = new BufferedReader(source.getOpener().openReaderOnce())) {
  131.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  132.                 ++lineNumber;
  133.                 final String l = line;
  134.                 final Optional<LineParser> selected = crdParsers.filter(p -> p.canHandle(l)).findFirst();
  135.                 if (selected.isPresent()) {
  136.                     try {
  137.                         selected.get().parse(line, pi);
  138.                     } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  139.                         throw new OrekitException(e,
  140.                                 OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  141.                                 lineNumber, source.getName(), line);
  142.                     }
  143.                     crdParsers = selected.get().allowedNext();
  144.                 }
  145.                 if (pi.done) {
  146.                     // Return file
  147.                     return pi.file;
  148.                 }
  149.             }
  150.         }

  152.         // We never reached the EOF marker
  153.         throw new OrekitException(OrekitMessages.CRD_UNEXPECTED_END_OF_FILE, lineNumber);

  155.     }

  157.     /**
  158.      * Computes if a day shift has happened comparing the current and past epoch, described by seconds in the day.
  159.      * This is useful as the data is sorted in the chronological order inside the file.
  160.      *
  161.      * @param lastSecOfDay
  162.      * @param secOfDay
  163.      * @return Boolean true if change in day.
  164.      */
  165.     private static int checkRollover(final double lastSecOfDay, final double secOfDay) {
  166.         return (secOfDay > lastSecOfDay) ? 0 : 1;
  167.     }

  169.     /** Transient data used for parsing a CRD file. The data is kept in a
  170.      * separate data structure to make the parser thread-safe.
  171.      * <p><b>Note</b>: The class intentionally does not provide accessor
  172.      * methods, as it is only used internally for parsing a CRD file.</p>
  173.      */
  174.     private class ParseInfo {

  176.         /** The corresponding CDR file. */
  177.         private CRD file;

  179.         /** Version. */
  180.         private int version;

  182.         /** The current data block. */
  183.         private CRDDataBlock dataBlock;

  185.         /** Data block header. */
  186.         private CRDHeader header;

  188.         /** Cofiguration records. */
  189.         private CRDConfiguration configurationRecords;

  191.         /** Time scale. */
  192.         private TimeScale timeScale;

  194.         /** Current data block start epoch. */
  195.         private DateComponents startEpoch;

  197.         /** End Of File reached indicator. */
  198.         private boolean done;

  200.         /** Last parsed range measurement. */
  201.         private RangeMeasurement lastRange;

  203.         /**
  204.          * Constructor.
  205.          */
  206.         protected ParseInfo() {

  208.             // Initialise default values
  209.             this.done       = false;
  210.             this.version    = 1;
  211.             this.startEpoch = DateComponents.J2000_EPOCH;
  212.             this.lastRange  = null;

  214.             // Initialise empty object
  215.             this.file                 = new CRD();
  216.             this.header               = new CRDHeader();
  217.             this.configurationRecords = new CRDConfiguration();
  218.             this.dataBlock            = new CRDDataBlock();

  220.             // Time scale
  221.             this.timeScale = CRDParser.this.timeScale;

  223.         }

  225.     }

  227.     /** Parsers for specific lines. */
  228.     private enum LineParser {

  230.         /** Format header. */
  231.         H1("H1", "h1") {

  233.             /** {@inheritDoc} */
  234.             @Override
  235.             public void parse(final String line, final ParseInfo pi) {

  237.                 // Data contained in the line
  238.                 final String[] values = SEPARATOR.split(line);

  240.                 // Format and version
  241.                 final String format = values[1];
  242.                 pi.version = Integer.parseInt(values[2]);

  244.                 // Throw an exception if format is not equal to "CRD"
  245.                 if (!format.equalsIgnoreCase(FILE_FORMAT)) {
  246.                     throw new OrekitException(OrekitMessages.UNEXPECTED_FORMAT_FOR_ILRS_FILE, FILE_FORMAT, format);
  247.                 }

  249.                 // Fill first elements
  250.                 pi.header.setFormat(format);
  251.                 pi.header.setVersion(pi.version);

  253.                 // Epoch of ephemeris production
  254.                 final int year  = Integer.parseInt(values[3]);
  255.                 final int month = Integer.parseInt(values[4]);
  256.                 final int day   = Integer.parseInt(values[5]);
  257.                 pi.header.setProductionEpoch(new DateComponents(year, month, day));

  259.                 // Hour of ephemeris production
  260.                 pi.header.setProductionHour(Integer.parseInt(values[6]));

  262.             }

  264.             /** {@inheritDoc} */
  265.             @Override
  266.             public Stream<LineParser> allowedNext() {
  267.                 return Stream.of(H2, COMMENTS);
  268.             }

  270.         },

  272.         /** Format header. */
  273.         H2("H2", "h2") {

  275.             /** {@inheritDoc} */
  276.             @Override
  277.             public void parse(final String line, final ParseInfo pi) {

  279.                 // Data contained in the line
  280.                 final String[] values = SEPARATOR.split(line);

  282.                 // Station name
  283.                 pi.header.setStationName(values[1]);

  285.                 // Crustal Dynamics Project keys
  286.                 pi.header.setSystemIdentifier(Integer.parseInt(values[2]));
  287.                 pi.header.setSystemNumber(Integer.parseInt(values[3]));
  288.                 pi.header.setSystemOccupancy(Integer.parseInt(values[4]));

  290.                 // Station epoch time scale
  291.                 pi.header.setEpochIdentifier(Integer.parseInt(values[5]));

  293.                 // Station network
  294.                 if (pi.version == 2) {
  295.                     pi.header.setStationNetword(values[6]);
  296.                 }

  298.             }

  300.             /** {@inheritDoc} */
  301.             @Override
  302.             public Stream<LineParser> allowedNext() {
  303.                 return Stream.of(H3, COMMENTS);
  304.             }

  306.         },

  308.         /** Format header. */
  309.         H3("H3", "h3") {

  311.             /** {@inheritDoc} */
  312.             @Override
  313.             public void parse(final String line, final ParseInfo pi) {

  315.                 // Data contained in the line
  316.                 final String[] values = SEPARATOR.split(line);

  318.                 // Target name
  319.                 pi.header.setName(values[1]);

  321.                 // Identifiers
  322.                 pi.header.setIlrsSatelliteId(values[2]);
  323.                 pi.header.setSic(values[3]);
  324.                 pi.header.setNoradId(values[4]);

  326.                 // Spacecraft Epoch Time Scale
  327.                 pi.header.setSpacecraftEpochTimeScale(Integer.parseInt(values[5]));

  329.                 // Target class and location (if needed)
  330.                 pi.header.setTargetClass(Integer.parseInt(values[6]));
  331.                 if (pi.version == 2) {
  332.                     pi.header.setTargetLocation(Integer.parseInt(values[7]));
  333.                 }

  335.             }

  337.             /** {@inheritDoc} */
  338.             @Override
  339.             public Stream<LineParser> allowedNext() {
  340.                 return Stream.of(H4, COMMENTS);
  341.             }

  343.         },

  345.         /** Format header. */
  346.         H4("H4", "h4") {

  348.             /** {@inheritDoc} */
  349.             @Override
  350.             public void parse(final String line, final ParseInfo pi) {

  352.                 // Data contained in the line
  353.                 final String[] values = SEPARATOR.split(line);

  355.                 // Data type
  356.                 pi.header.setDataType(Integer.parseInt(values[1]));

  358.                 // Start epoch
  359.                 final int    yearS   = Integer.parseInt(values[2]);
  360.                 final int    monthS  = Integer.parseInt(values[3]);
  361.                 final int    dayS    = Integer.parseInt(values[4]);
  362.                 final int    hourS   = Integer.parseInt(values[5]);
  363.                 final int    minuteS = Integer.parseInt(values[6]);
  364.                 final double secondS = Integer.parseInt(values[7]);

  366.                 pi.startEpoch = new DateComponents(yearS, monthS, dayS);

  368.                 pi.header.setStartEpoch(new AbsoluteDate(yearS, monthS, dayS,
  369.                         hourS, minuteS, secondS,
  370.                         pi.timeScale));

  372.                 // End epoch
  373.                 final int    yearE   = Integer.parseInt(values[8]);
  374.                 final int    monthE  = Integer.parseInt(values[9]);
  375.                 final int    dayE    = Integer.parseInt(values[10]);
  376.                 final int    hourE   = Integer.parseInt(values[11]);
  377.                 final int    minuteE = Integer.parseInt(values[12]);
  378.                 final double secondE = Integer.parseInt(values[13]);

  380.                 pi.header.setEndEpoch(new AbsoluteDate(yearE, monthE, dayE,
  381.                         hourE, minuteE, secondE,
  382.                         pi.timeScale));

  384.                 // Data release
  385.                 pi.header.setDataReleaseFlag(Integer.parseInt(values[14]));

  387.                 // Correction flags
  388.                 pi.header.setIsTroposphericRefractionApplied(readBoolean(values[15]));
  389.                 pi.header.setIsCenterOfMassCorrectionApplied(readBoolean(values[16]));
  390.                 pi.header.setIsReceiveAmplitudeCorrectionApplied(readBoolean(values[17]));
  391.                 pi.header.setIsStationSystemDelayApplied(readBoolean(values[18]));
  392.                 pi.header.setIsTransponderDelayApplied(readBoolean(values[19]));

  394.                 // Range type indicator
  395.                 pi.header.setRangeType(Integer.parseInt(values[20]));

  397.                 // Data quality indicator
  398.                 pi.header.setQualityIndicator(Integer.parseInt(values[21]));

  400.             }

  402.             /** {@inheritDoc} */
  403.             @Override
  404.             public Stream<LineParser> allowedNext() {
  405.                 return Stream.of(H5, C0, COMMENTS);
  406.             }

  408.         },

  410.         /** Format header. */
  411.         H5("H5", "h5") {

  413.             /** {@inheritDoc} */
  414.             @Override
  415.             public void parse(final String line, final ParseInfo pi) {

  417.                 // Data contained in the line
  418.                 final String[] values = SEPARATOR.split(line);

  420.                 // Fill data
  421.                 pi.header.setPredictionType(Integer.parseInt(values[1]));
  422.                 pi.header.setYearOfCentury(Integer.parseInt(values[2]));
  423.                 pi.header.setDateAndTime(values[3]);
  424.                 pi.header.setPredictionProvider(values[4]);
  425.                 pi.header.setSequenceNumber(Integer.parseInt(values[5]));

  427.             }

  429.             /** {@inheritDoc} */
  430.             @Override
  431.             public Stream<LineParser> allowedNext() {
  432.                 return Stream.of(C0, COMMENTS);
  433.             }

  435.         },

  437.         /** System configuration record. */
  438.         C0("C0", "c0") {

  440.             /** {@inheritDoc} */
  441.             @Override
  442.             public void parse(final String line, final ParseInfo pi) {

  444.                 // Initialise an empty system configuration record
  445.                 final SystemConfiguration systemRecord = new SystemConfiguration();

  447.                 // Data contained in the line
  448.                 final String[] values = SEPARATOR.split(line);

  450.                 // Wavelength
  451.                 systemRecord.setWavelength(NM.toSI(Double.parseDouble(values[2])));

  453.                 // System ID
  454.                 systemRecord.setSystemId(values[3]);

  456.                 // Set the system configuration record
  457.                 pi.configurationRecords.setSystemRecord(systemRecord);

  459.             }

  461.             /** {@inheritDoc} */
  462.             @Override
  463.             public Stream<LineParser> allowedNext() {
  464.                 return Stream.of(C1, C2, C3, C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  465.             }

  467.         },


  470.         /** Laser configuration record. */
  471.         C1("C1", "c1") {

  473.             /** {@inheritDoc} */
  474.             @Override
  475.             public void parse(final String line, final ParseInfo pi) {

  477.                 // Initialise an empty laser configuration record
  478.                 final LaserConfiguration laserRecord = new LaserConfiguration();

  480.                 // Data contained in the line
  481.                 final String[] values = SEPARATOR.split(line);

  483.                 // Fill values
  484.                 laserRecord.setLaserId(values[2]);
  485.                 laserRecord.setLaserType(values[3]);
  486.                 laserRecord.setPrimaryWavelength(NM.toSI(Double.parseDouble(values[4])));
  487.                 laserRecord.setNominalFireRate(Double.parseDouble(values[5]));
  488.                 laserRecord.setPulseEnergy(Double.parseDouble(values[6]));
  489.                 laserRecord.setPulseWidth(Double.parseDouble(values[7]));
  490.                 laserRecord.setBeamDivergence(Double.parseDouble(values[8]));
  491.                 laserRecord.setPulseInOutgoingSemiTrain(Integer.parseInt(values[9]));

  493.                 // Set the laser configuration record
  494.                 pi.configurationRecords.setLaserRecord(laserRecord);

  496.             }

  498.             /** {@inheritDoc} */
  499.             @Override
  500.             public Stream<LineParser> allowedNext() {
  501.                 return Stream.of(C2, C3, C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  502.             }

  504.         },

  506.         /** Detector configuration record. */
  507.         C2("C2", "c2") {

  509.             /** {@inheritDoc} */
  510.             @Override
  511.             public void parse(final String line, final ParseInfo pi) {

  513.                 // Initialise an empty detector configuration record
  514.                 final DetectorConfiguration detectorRecord = new DetectorConfiguration();

  516.                 // Data contained in the line
  517.                 final String[] values = SEPARATOR.split(line);

  519.                 // Fill values
  520.                 detectorRecord.setDetectorId(values[2]);
  521.                 detectorRecord.setDetectorType(values[3]);
  522.                 detectorRecord.setApplicableWavelength(NM.toSI(Double.parseDouble(values[4])));
  523.                 detectorRecord.setQuantumEfficiency(Double.parseDouble(values[5]));
  524.                 detectorRecord.setAppliedVoltage(Double.parseDouble(values[6]));
  525.                 detectorRecord.setDarkCount(KHZ.toSI(Double.parseDouble(values[7])));
  526.                 detectorRecord.setOutputPulseType(values[8]);
  527.                 detectorRecord.setOutputPulseWidth(Double.parseDouble(values[9]));
  528.                 detectorRecord.setSpectralFilter(NM.toSI(Double.parseDouble(values[10])));
  529.                 detectorRecord.setTransmissionOfSpectralFilter(Double.parseDouble(values[11]));
  530.                 detectorRecord.setSpatialFilter(Double.parseDouble(values[12]));
  531.                 detectorRecord.setExternalSignalProcessing(values[13]);

  533.                 // Check file version for additional data
  534.                 if (pi.version == 2) {
  535.                     detectorRecord.setAmplifierGain(Double.parseDouble(values[14]));
  536.                     detectorRecord.setAmplifierBandwidth(KHZ.toSI(Double.parseDouble(values[15])));
  537.                     detectorRecord.setAmplifierInUse(values[16]);
  538.                 }

  540.                 // Set the detector configuration record
  541.                 pi.configurationRecords.setDetectorRecord(detectorRecord);

  543.             }

  545.             /** {@inheritDoc} */
  546.             @Override
  547.             public Stream<LineParser> allowedNext() {
  548.                 return Stream.of(C3, C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  549.             }

  551.         },

  553.         /** Timing system configuration record. */
  554.         C3("C3", "c3") {

  556.             /** {@inheritDoc} */
  557.             @Override
  558.             public void parse(final String line, final ParseInfo pi) {

  560.                 // Initialise an empty timing system configuration record
  561.                 final TimingSystemConfiguration timingRecord = new TimingSystemConfiguration();

  563.                 // Data contained in the line
  564.                 final String[] values = SEPARATOR.split(line);

  566.                 // Fill values
  567.                 timingRecord.setLocalTimingId(values[2]);
  568.                 timingRecord.setTimeSource(values[3]);
  569.                 timingRecord.setFrequencySource(values[4]);
  570.                 timingRecord.setTimer(values[5]);
  571.                 timingRecord.setTimerSerialNumber(values[6]);
  572.                 timingRecord.setEpochDelayCorrection(US.toSI(Double.parseDouble(values[7])));

  574.                 // Set the timing system configuration record
  575.                 pi.configurationRecords.setTimingRecord(timingRecord);

  577.             }

  579.             /** {@inheritDoc} */
  580.             @Override
  581.             public Stream<LineParser> allowedNext() {
  582.                 return Stream.of(C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  583.             }

  585.         },

  587.         /** Transponder configuration record. */
  588.         C4("C4", "c4") {

  590.             /** {@inheritDoc} */
  591.             @Override
  592.             public void parse(final String line, final ParseInfo pi) {

  594.                 // Initialise an empty transponder configuration record
  595.                 final TransponderConfiguration transponderRecord = new TransponderConfiguration();

  597.                 // Data contained in the line
  598.                 final String[] values = SEPARATOR.split(line);

  600.                 // Estimated offsets and drifts
  601.                 transponderRecord.setTransponderId(values[2]);
  602.                 transponderRecord.setStationUTCOffset(NM.toSI(Double.parseDouble(values[3])));
  603.                 transponderRecord.setStationOscDrift(Double.parseDouble(values[4]));
  604.                 transponderRecord.setTranspUTCOffset(NM.toSI(Double.parseDouble(values[5])));
  605.                 transponderRecord.setTranspOscDrift(Double.parseDouble(values[6]));

  607.                 // Transponder clock reference time
  608.                 transponderRecord.setTranspClkRefTime(Double.parseDouble(values[7]));

  610.                 // Clock and drift indicators
  611.                 transponderRecord.setStationClockAndDriftApplied(Integer.parseInt(values[8]));
  612.                 transponderRecord.setSpacecraftClockAndDriftApplied(Integer.parseInt(values[9]));

  614.                 // Spacecraft time simplified
  615.                 transponderRecord.setIsSpacecraftTimeSimplified(readBoolean(values[10]));

  617.                 // Set the transponder configuration record
  618.                 pi.configurationRecords.setTransponderRecord(transponderRecord);

  620.             }

  622.             /** {@inheritDoc} */
  623.             @Override
  624.             public Stream<LineParser> allowedNext() {
  625.                 return Stream.of(C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  626.             }

  628.         },

  630.         /** Software configuration record. */
  631.         C5("C5", "c5") {

  633.             /** {@inheritDoc} */
  634.             @Override
  635.             public void parse(final String line, final ParseInfo pi) {

  637.                 // Initialise an empty software configuration record
  638.                 final SoftwareConfiguration softwareRecord = new SoftwareConfiguration();

  640.                 // Data contained in the line
  641.                 final String[] values = SEPARATOR.split(line);

  643.                 // Fill values
  644.                 softwareRecord.setSoftwareId(values[2]);
  645.                 softwareRecord.setTrackingSoftwares(COMMA.split(values[3]));
  646.                 softwareRecord.setTrackingSoftwareVersions(COMMA.split(values[4]));
  647.                 softwareRecord.setProcessingSoftwares(COMMA.split(values[5]));
  648.                 softwareRecord.setProcessingSoftwareVersions(COMMA.split(values[6]));

  650.                 // Set the software configuration record
  651.                 pi.configurationRecords.setSoftwareRecord(softwareRecord);

  653.             }

  655.             /** {@inheritDoc} */
  656.             @Override
  657.             public Stream<LineParser> allowedNext() {
  658.                 return Stream.of(C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  659.             }

  661.         },

  663.         /** Meteorological instrumentation configuration record. */
  664.         C6("C6", "c6") {

  666.             /** {@inheritDoc} */
  667.             @Override
  668.             public void parse(final String line, final ParseInfo pi) {

  670.                 // Initialise an empty meteorological configuration record
  671.                 final MeteorologicalConfiguration meteoRecord = new MeteorologicalConfiguration();

  673.                 // Data contained in the line
  674.                 final String[] values = SEPARATOR.split(line);

  676.                 // Fill values
  677.                 meteoRecord.setMeteorologicalId(values[2]);
  678.                 meteoRecord.setPressSensorManufacturer(values[3]);
  679.                 meteoRecord.setPressSensorModel(values[4]);
  680.                 meteoRecord.setPressSensorSerialNumber(values[5]);
  681.                 meteoRecord.setTempSensorManufacturer(values[6]);
  682.                 meteoRecord.setTempSensorModel(values[7]);
  683.                 meteoRecord.setTempSensorSerialNumber(values[8]);
  684.                 meteoRecord.setHumiSensorManufacturer(values[9]);
  685.                 meteoRecord.setHumiSensorModel(values[10]);
  686.                 meteoRecord.setHumiSensorSerialNumber(values[11]);

  688.                 // Set the meteorological configuration record
  689.                 pi.configurationRecords.setMeteorologicalRecord(meteoRecord);

  691.             }

  693.             /** {@inheritDoc} */
  694.             @Override
  695.             public Stream<LineParser> allowedNext() {
  696.                 return Stream.of(C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  697.             }

  699.         },

  701.         /** Calibration Target configuration record. */
  702.         C7("C7", "c7") {

  704.             /** {@inheritDoc} */
  705.             @Override
  706.             public void parse(final String line, final ParseInfo pi) {
  707.                 // Not implemented yet
  708.             }

  710.             /** {@inheritDoc} */
  711.             @Override
  712.             public Stream<LineParser> allowedNext() {
  713.                 return Stream.of(TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  714.             }

  716.         },

  718.         /** Range Record (Full rate, Sampled Engineering/Quicklook). */
  719.         TEN("10") {

  721.             /** Storage for the last epoch parsed to compare with the current.*/
  722.             private double lastSecOfDay = 0;

  724.             /** Shift in days due to the rollover.*/
  725.             private int dayShift = 0;

  727.             /** {@inheritDoc} */
  728.             @Override
  729.             public void parse(final String line, final ParseInfo pi) {

  731.                 // Data contained in the line
  732.                 final String[] values = SEPARATOR.split(line);

  734.                 // Read data
  735.                 final double secOfDay     = Double.parseDouble(values[1]);
  736.                 final double timeOfFlight = Double.parseDouble(values[2]);
  737.                 final int    epochEvent   = Integer.parseInt(values[4]);

  739.                 // Check secOfDay for rollover
  740.                 dayShift = dayShift + checkRollover(lastSecOfDay, secOfDay);
  741.                 // Initialise a new Range measurement
  742.                 AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  743.                 if (pi.lastRange != null) {
  744.                     final double duration = epoch.durationFrom(pi.lastRange.getDate());
  745.                     if (duration < 0) {
  746.                         epoch = epoch.shiftedBy(Constants.JULIAN_DAY);
  747.                     }
  748.                 }
  749.                 final RangeMeasurement range = new RangeMeasurement(epoch, timeOfFlight, epochEvent);
  750.                 pi.dataBlock.addRangeData(range);

  752.                 lastSecOfDay = secOfDay;
  753.                 pi.lastRange = range;

  755.             }

  757.             /** {@inheritDoc} */
  758.             @Override
  759.             public Stream<LineParser> allowedNext() {
  760.                 return Stream.of(H8, TEN, TWELVE, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  761.             }

  763.         },

  765.         /** Range Record (Normal point). */
  766.         ELEVEN("11") {

  768.             /** Storage for the last epoch parsed to compare with the current.*/
  769.             private double lastSecOfDay = 0;

  771.             /** Shift in days due to the rollover.*/
  772.             private int dayShift = 0;

  774.             /** {@inheritDoc} */
  775.             @Override
  776.             public void parse(final String line, final ParseInfo pi) {

  778.                 // Data contained in the line
  779.                 final String[] values = SEPARATOR.split(line);

  781.                 // Read data
  782.                 final double secOfDay     = Double.parseDouble(values[1]);
  783.                 final double timeOfFlight = Double.parseDouble(values[2]);
  784.                 final int    epochEvent   = Integer.parseInt(values[4]);
  785.                 final double snr          = (pi.version == 2) ? Double.parseDouble(values[13]) : Double.NaN;

  787.                 // Check secOfDay for rollover
  788.                 dayShift = dayShift + checkRollover(lastSecOfDay, secOfDay);
  789.                 // Initialise a new Range measurement
  790.                 AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  791.                 if (pi.lastRange != null) {
  792.                     final double duration = epoch.durationFrom(pi.lastRange.getDate());
  793.                     if (duration < 0) {
  794.                         epoch = epoch.shiftedBy(Constants.JULIAN_DAY);
  795.                     }
  796.                 }
  797.                 final RangeMeasurement range = new RangeMeasurement(epoch, timeOfFlight, epochEvent, snr);
  798.                 pi.dataBlock.addRangeData(range);

  800.                 lastSecOfDay = secOfDay;
  801.                 pi.lastRange = range;

  803.             }

  805.             /** {@inheritDoc} */
  806.             @Override
  807.             public Stream<LineParser> allowedNext() {
  808.                 return Stream.of(H8, ELEVEN, TWELVE, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  809.             }

  811.         },

  813.         /** Range Supplement Record. */
  814.         TWELVE("12") {

  816.             /** {@inheritDoc} */
  817.             @Override
  818.             public void parse(final String line, final ParseInfo pi) {
  819.                 // Not implemented yet
  820.             }

  822.             /** {@inheritDoc} */
  823.             @Override
  824.             public Stream<LineParser> allowedNext() {
  825.                 return Stream.of(H8, TEN, ELEVEN, TWELVE, METEO, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  826.             }

  828.         },

  830.         /** Meteorological record. */
  831.         METEO("20") {

  833.             /** Storage for the last epoch parsed to compare with the current.*/
  834.             private double lastSecOfDay = 0;

  836.             /** Shift in days due to the rollover.*/
  837.             private int dayShift = 0;

  839.             /** {@inheritDoc} */
  840.             @Override
  841.             public void parse(final String line, final ParseInfo pi) {

  843.                 // Data contained in the line
  844.                 final String[] values = SEPARATOR.split(line);

  846.                 // Read data
  847.                 final double secOfDay    = Double.parseDouble(values[1]);
  848.                 final double pressure    = MBAR_TO_BAR.convert(Double.parseDouble(values[2]));
  849.                 final double temperature = Double.parseDouble(values[3]);
  850.                 final double humidity    = Double.parseDouble(values[4]);

  852.                 // Check secOfDay for rollover
  853.                 dayShift = dayShift + checkRollover(lastSecOfDay, secOfDay);
  854.                 // Initialise a new Range measurement
  855.                 final AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale).shiftedBy(dayShift * 86400);
  856.                 final MeteorologicalMeasurement meteo = new MeteorologicalMeasurement(epoch, pressure,
  857.                         temperature, humidity);
  858.                 pi.dataBlock.addMeteoData(meteo);

  860.             }

  862.             /** {@inheritDoc} */
  863.             @Override
  864.             public Stream<LineParser> allowedNext() {
  865.                 return Stream.of(H8, METEO, METEO_SUPP, TEN, ELEVEN, TWELVE, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  866.             }

  868.         },

  870.         /** Meteorological Supplement record. */
  871.         METEO_SUPP("21") {

  873.             /** {@inheritDoc} */
  874.             @Override
  875.             public void parse(final String line, final ParseInfo pi) {
  876.                 // Not implemented yet
  877.             }

  879.             /** {@inheritDoc} */
  880.             @Override
  881.             public Stream<LineParser> allowedNext() {
  882.                 return Stream.of(H8, METEO, METEO_SUPP, TEN, ELEVEN, TWELVE, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  883.             }

  885.         },

  887.         /** Pointing Angle Record. */
  888.         ANGLES("30") {

  890.             /** Storage for the last epoch parsed to compare with the current.*/
  891.             private double lastSecOfDay = 0;

  893.             /** Shift in days due to the rollover.*/
  894.             private int dayShift = 0;

  896.             /** {@inheritDoc} */
  897.             @Override
  898.             public void parse(final String line, final ParseInfo pi) {

  900.                 // Data contained in the line
  901.                 final String[] values = SEPARATOR.split(line);

  903.                 // Read data
  904.                 final double  secOfDay              = Double.parseDouble(values[1]);
  905.                 final double  azmiuth               = FastMath.toRadians(Double.parseDouble(values[2]));
  906.                 final double  elevation             = FastMath.toRadians(Double.parseDouble(values[3]));
  907.                 final int     directionFlag         = Integer.parseInt(values[4]);
  908.                 final int     orginFlag             = Integer.parseInt(values[5]);
  909.                 final boolean isRefractionCorrected = readBoolean(values[6]);


  912.                 // Angles rates
  913.                 double azimuthRate   = Double.NaN;
  914.                 double elevationRate = Double.NaN;
  915.                 if (pi.version == 2) {
  916.                     azimuthRate   = readDoubleWithNaN(values[7]);
  917.                     elevationRate = readDoubleWithNaN(values[8]);
  918.                 }

  920.                 // Check secOfDay for rollover
  921.                 dayShift = dayShift + checkRollover(lastSecOfDay, secOfDay);
  922.                 // Initialise a new angles measurement
  923.                 final AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  924.                 final AnglesMeasurement angles = new AnglesMeasurement(epoch, azmiuth, elevation,
  925.                         directionFlag, orginFlag,
  926.                         isRefractionCorrected,
  927.                         azimuthRate, elevationRate);
  928.                 pi.dataBlock.addAnglesData(angles);

  930.             }

  932.             /** {@inheritDoc} */
  933.             @Override
  934.             public Stream<LineParser> allowedNext() {
  935.                 return Stream.of(H8, METEO, TEN, ELEVEN, ANGLES, CALIB, STAT, COMPATIBILITY, COMMENTS);
  936.             }

  938.         },

  940.         /** Calibration Record. */
  941.         CALIB("40") {

  943.             /** {@inheritDoc} */
  944.             @Override
  945.             public void parse(final String line, final ParseInfo pi) {
  946.                 // Not implemented yet
  947.             }

  949.             /** {@inheritDoc} */
  950.             @Override
  951.             public Stream<LineParser> allowedNext() {
  952.                 return Stream.of(H8, METEO, CALIB, CALIB_DETAILS, CALIB_SHOT, TEN, ELEVEN, TWELVE, ANGLES, STAT, COMPATIBILITY, COMMENTS);
  953.             }

  955.         },

  957.         /** Calibration Details Record. */
  958.         CALIB_DETAILS("41") {

  960.             /** {@inheritDoc} */
  961.             @Override
  962.             public void parse(final String line, final ParseInfo pi) {
  963.                 // Not implemented yet
  964.             }

  966.             /** {@inheritDoc} */
  967.             @Override
  968.             public Stream<LineParser> allowedNext() {
  969.                 return Stream.of(H8, METEO, CALIB, CALIB_DETAILS, CALIB_SHOT, TEN, ELEVEN, TWELVE, ANGLES, STAT, COMPATIBILITY, COMMENTS);
  970.             }

  972.         },

  974.         /** Calibration "Shot" Record. */
  975.         CALIB_SHOT("42") {

  977.             /** {@inheritDoc} */
  978.             @Override
  979.             public void parse(final String line, final ParseInfo pi) {
  980.                 // Not implemented yet
  981.             }

  983.             /** {@inheritDoc} */
  984.             @Override
  985.             public Stream<LineParser> allowedNext() {
  986.                 return Stream.of(H8, METEO, CALIB, CALIB_DETAILS, CALIB_SHOT, TEN, ELEVEN, TWELVE, ANGLES, STAT, COMPATIBILITY, COMMENTS);
  987.             }

  989.         },

  991.         /** Session (Pass) Statistics Record. */
  992.         STAT("50") {

  994.             /** {@inheritDoc} */
  995.             @Override
  996.             public void parse(final String line, final ParseInfo pi) {
  997.                 // Not implemented yet
  998.             }

  1000.             /** {@inheritDoc} */
  1001.             @Override
  1002.             public Stream<LineParser> allowedNext() {
  1003.                 return Stream.of(H8, METEO, CALIB, CALIB_DETAILS, CALIB_SHOT, TEN, ELEVEN, TWELVE, ANGLES, STAT, COMPATIBILITY, H8, COMMENTS);
  1004.             }

  1006.         },

  1008.         /** Compatibility record. */
  1009.         COMPATIBILITY("60") {

  1011.             /** {@inheritDoc} */
  1012.             @Override
  1013.             public void parse(final String line, final ParseInfo pi) {
  1014.                 // Not implemented yet
  1015.             }

  1017.             /** {@inheritDoc} */
  1018.             @Override
  1019.             public Stream<LineParser> allowedNext() {
  1020.                 return Stream.of(H8, METEO, CALIB, CALIB_DETAILS, CALIB_SHOT, TEN, ELEVEN, TWELVE, ANGLES, STAT, COMPATIBILITY, COMMENTS);
  1021.             }

  1023.         },

  1025.         /** Comments. */
  1026.         COMMENTS("00") {

  1028.             /** {@inheritDoc} */
  1029.             @Override
  1030.             public void parse(final String line, final ParseInfo pi) {

  1032.                 // Comment
  1033.                 final String comment = line.split(getFirstIdentifier())[1].trim();
  1034.                 pi.file.getComments().add(comment);

  1036.             }

  1038.             /** {@inheritDoc} */
  1039.             @Override
  1040.             public Stream<LineParser> allowedNext() {
  1041.                 return Stream.of(H1, H2, H3, H4, H5, H8, H9, C0, C1, C2, C3, C4, C5, C6, C7, TEN, ELEVEN, TWELVE, METEO,
  1042.                         METEO_SUPP, ANGLES, CALIB, CALIB_DETAILS, CALIB_SHOT, STAT, COMPATIBILITY, COMMENTS);

  1044.             }

  1046.         },

  1048.         /** End of data block. */
  1049.         H8("H8", "h8") {

  1051.             /** {@inheritDoc} */
  1052.             @Override
  1053.             public void parse(final String line, final ParseInfo pi) {

  1055.                 // Fill data block
  1056.                 pi.dataBlock.setHeader(pi.header);
  1057.                 pi.dataBlock.setConfigurationRecords(pi.configurationRecords);

  1059.                 // Add the data block to the CRD file
  1060.                 pi.file.addDataBlock(pi.dataBlock);

  1062.                 // Initialize a new empty containers
  1063.                 pi.startEpoch           = DateComponents.J2000_EPOCH;
  1064.                 pi.header               = new CRDHeader();
  1065.                 pi.configurationRecords = new CRDConfiguration();
  1066.                 pi.dataBlock            = new CRDDataBlock();
  1067.                 pi.lastRange            = null;

  1069.             }

  1071.             /** {@inheritDoc} */
  1072.             @Override
  1073.             public Stream<LineParser> allowedNext() {
  1074.                 return Stream.of(H1, H9, COMMENTS);
  1075.             }

  1077.         },

  1079.         /** Last record in file. */
  1080.         H9("H9", "h9") {

  1082.             /** {@inheritDoc} */
  1083.             @Override
  1084.             public void parse(final String line, final ParseInfo pi) {
  1085.                 pi.done = true;
  1086.             }

  1088.             /** {@inheritDoc} */
  1089.             @Override
  1090.             public Stream<LineParser> allowedNext() {
  1091.                 return Stream.of(H9);
  1092.             }

  1094.         };

  1096.         /** Patterns for identifying line. */
  1097.         private final Pattern[] patterns;

  1099.         /** Identifiers. */
  1100.         private final String[] identifiers;

  1102.         /** Simple constructor.
  1103.          * @param identifier regular expression for identifying line (i.e. first element)
  1104.          */
  1105.         LineParser(final String... identifier) {
  1106.             this.identifiers = identifier;
  1107.             // Initialise patterns
  1108.             this.patterns    = new Pattern[identifiers.length];
  1109.             for (int index = 0; index < patterns.length; index++) {
  1110.                 patterns[index] = Pattern.compile(identifiers[index]);
  1111.             }
  1112.         }

  1114.         /**
  1115.          * Get the regular expression for identifying line.
  1116.          * @return the regular expression for identifying line
  1117.          */
  1118.         public String getFirstIdentifier() {
  1119.             return identifiers[0];
  1120.         }

  1122.         /** Parse a line.
  1123.          * @param line line to parse
  1124.          * @param pi holder for transient data
  1125.          */
  1126.         public abstract void parse(String line, ParseInfo pi);

  1128.         /** Get the allowed parsers for next line.
  1129.          * @return allowed parsers for next line
  1130.          */
  1131.         public abstract Stream<LineParser> allowedNext();

  1133.         /** Check if parser can handle line.
  1134.          * @param line line to parse
  1135.          * @return true if parser can handle the specified line
  1136.          */
  1137.         public boolean canHandle(final String line) {
  1138.             // Line identifier
  1139.             final String lineId = SEPARATOR.split(line)[0];
  1140.             // Loop on patterns
  1141.             for (Pattern pattern : patterns) {
  1142.                 if (pattern.matcher(lineId).matches()) {
  1143.                     return true;
  1144.                 }
  1145.             }
  1146.             // No match
  1147.             return false;
  1148.         }

  1150.         /**
  1151.          * Read a boolean from a string value.
  1152.          * @param value input value
  1153.          * @return the correspondin boolean
  1154.          */
  1155.         private static boolean readBoolean(final String value) {
  1156.             return Integer.parseInt(value) == 1;
  1157.         }

  1159.         /**
  1160.          * Read a double value taking into consideration a possible "na".
  1161.          * @param value input string
  1162.          * @return the corresponding double value
  1163.          */
  1164.         private static double readDoubleWithNaN(final String value) {
  1165.             return "na".equals(value) ? Double.NaN : Double.parseDouble(value);
  1166.         }

  1168.     }

  1170. }
Created with JaCoCo 0.8.8.202204050719