CRDParser.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.ilrs;

  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.nio.file.Files;
  25. import java.nio.file.Paths;
  26. import java.util.Optional;
  27. import java.util.regex.Pattern;
  28. import java.util.stream.Stream;

  30. import org.hipparchus.util.FastMath;
  31. import org.orekit.annotation.DefaultDataContext;
  32. import org.orekit.data.DataContext;
  33. import org.orekit.errors.OrekitException;
  34. import org.orekit.errors.OrekitMessages;
  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.files.ilrs.CRDFile.AnglesMeasurement;
  43. import org.orekit.files.ilrs.CRDFile.CRDDataBlock;
  44. import org.orekit.files.ilrs.CRDFile.MeteorologicalMeasurement;
  45. import org.orekit.files.ilrs.CRDFile.RangeMeasurement;
  46. import org.orekit.time.AbsoluteDate;
  47. import org.orekit.time.DateComponents;
  48. import org.orekit.time.TimeComponents;
  49. import org.orekit.time.TimeScale;

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

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

  68.     /** Nanometers to meters converter. */
  69.     private static final double NM_TO_M = 1.0e-9;

  71.     /** Kilohertz to hertz converter. */
  72.     private static final double KHZ_TO_HZ = 1.0e3;

  74.     /** Microseconds to seconds converter. */
  75.     private static final double US_TO_S = 1.0e-6;

  77.     /** Milli to none converter. */
  78.     private static final double MILLI_TO_NONE = 1.0e-3;

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

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

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

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

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

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

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

  118.     /**
  119.      * Parse a CRD file from an input stream using the UTF-8 charset.
  120.      *
  121.      * <p> This method creates a {@link BufferedReader} from the stream and as such this
  122.      * method may read more data than necessary from {@code stream} and the additional
  123.      * data will be lost. The other parse methods do not have this issue.
  124.      *
  125.      * @param stream to read the CRD file from.
  126.      * @return a parsed CRD file.
  127.      * @throws IOException if {@code stream} throws one.
  128.      * @see #parse(String)
  129.      * @see #parse(BufferedReader, String)
  130.      */
  131.     public CRDFile parse(final InputStream stream) throws IOException {
  132.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  133.             return parse(reader, stream.toString());
  134.         }
  135.     }

  137.     /**
  138.      * Parse an CRD file from a file on the local file system.
  139.      * @param fileName path to the CRD file.
  140.      * @return parsed CRD file.
  141.      * @throws IOException if one is thrown while opening or reading from {@code fileName}
  142.      */
  143.     public CRDFile parse(final String fileName) throws IOException {
  144.         try (BufferedReader reader = Files.newBufferedReader(Paths.get(fileName),
  145.                                                              StandardCharsets.UTF_8)) {
  146.             return parse(reader, fileName);
  147.         }
  148.     }

  150.     /**
  151.      * Parse a CRD file from a stream.
  152.      * @param reader   containing the CRD file.
  153.      * @param fileName to use in error messages.
  154.      * @return a parsed CRD file.
  155.      * @throws IOException if {@code reader} throws one.
  156.      */
  157.     public CRDFile parse(final BufferedReader reader,
  158.                          final String fileName) throws IOException {

  160.         // Initialize internal data structures
  161.         final ParseInfo pi = new ParseInfo();

  163.         int lineNumber = 0;
  164.         Stream<LineParser> cdrParsers = Stream.of(LineParser.H1);
  165.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  166.             ++lineNumber;
  167.             final String l = line;
  168.             final Optional<LineParser> selected = cdrParsers.filter(p -> p.canHandle(l)).findFirst();
  169.             if (selected.isPresent()) {
  170.                 try {
  171.                     selected.get().parse(line, pi);
  172.                 } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  173.                     throw new OrekitException(e,
  174.                                               OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  175.                                               lineNumber, fileName, line);
  176.                 }
  177.                 cdrParsers = selected.get().allowedNext();
  178.             }
  179.             if (pi.done) {
  180.                 // Return file
  181.                 return pi.file;
  182.             }
  183.         }

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

  188.     }

  190.     /** Transient data used for parsing a CRD file. The data is kept in a
  191.      * separate data structure to make the parser thread-safe.
  192.      * <p><b>Note</b>: The class intentionally does not provide accessor
  193.      * methods, as it is only used internally for parsing a CRD file.</p>
  194.      */
  195.     private class ParseInfo {

  197.         /** The corresponding CDR file. */
  198.         private CRDFile file;

  200.         /** Version. */
  201.         private int version;

  203.         /** The current data block. */
  204.         private CRDDataBlock dataBlock;

  206.         /** Data block header. */
  207.         private CRDHeader header;

  209.         /** Cofiguration records. */
  210.         private CRDConfiguration configurationRecords;

  212.         /** Time scale. */
  213.         private TimeScale timeScale;

  215.         /** Current data block start epoch. */
  216.         private DateComponents startEpoch;

  218.         /** End Of File reached indicator. */
  219.         private boolean done;

  221.         /**
  222.          * Constructor.
  223.          */
  224.         protected ParseInfo() {

  226.             // Initialise default values
  227.             this.done       = false;
  228.             this.version    = 1;
  229.             this.startEpoch = DateComponents.J2000_EPOCH;

  231.             // Initialise empty object
  232.             this.file                 = new CRDFile();
  233.             this.header               = new CRDHeader();
  234.             this.configurationRecords = new CRDConfiguration();
  235.             this.dataBlock            = new CRDDataBlock();

  237.             // Time scale
  238.             this.timeScale = CRDParser.this.timeScale;

  240.         }

  242.     }

  244.     /** Parsers for specific lines. */
  245.     private enum LineParser {

  247.         /** Format header. */
  248.         H1("H1", "h1") {

  250.             /** {@inheritDoc} */
  251.             @Override
  252.             public void parse(final String line, final ParseInfo pi) {

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

  257.                 // Format and version
  258.                 final String format = values[1];
  259.                 pi.version = Integer.parseInt(values[2]);

  261.                 // Throw an exception if format is not equal to "CRD"
  262.                 if (!format.equalsIgnoreCase(FILE_FORMAT)) {
  263.                     throw new OrekitException(OrekitMessages.UNEXPECTED_FORMAT_FOR_ILRS_FILE, FILE_FORMAT, format);
  264.                 }

  266.                 // Fill first elements
  267.                 pi.header.setFormat(format);
  268.                 pi.header.setVersion(pi.version);

  270.                 // Epoch of ephemeris production
  271.                 final int year  = Integer.parseInt(values[3]);
  272.                 final int month = Integer.parseInt(values[4]);
  273.                 final int day   = Integer.parseInt(values[5]);
  274.                 pi.header.setProductionEpoch(new DateComponents(year, month, day));

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

  279.             }

  281.             /** {@inheritDoc} */
  282.             @Override
  283.             public Stream<LineParser> allowedNext() {
  284.                 return Stream.of(H2);
  285.             }

  287.         },

  289.         /** Format header. */
  290.         H2("H2", "h2") {

  292.             /** {@inheritDoc} */
  293.             @Override
  294.             public void parse(final String line, final ParseInfo pi) {

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

  299.                 // Station name
  300.                 pi.header.setStationName(values[1]);

  302.                 // Crustal Dynamics Project keys
  303.                 pi.header.setSystemIdentifier(Integer.parseInt(values[2]));
  304.                 pi.header.setSystemNumber(Integer.parseInt(values[3]));
  305.                 pi.header.setSystemOccupancy(Integer.parseInt(values[4]));

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

  310.                 // Station network
  311.                 if (pi.version == 2) {
  312.                     pi.header.setStationNetword(values[6]);
  313.                 }

  315.             }

  317.             /** {@inheritDoc} */
  318.             @Override
  319.             public Stream<LineParser> allowedNext() {
  320.                 return Stream.of(H3);
  321.             }

  323.         },

  325.         /** Format header. */
  326.         H3("H3", "h3") {

  328.             /** {@inheritDoc} */
  329.             @Override
  330.             public void parse(final String line, final ParseInfo pi) {

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

  335.                 // Target name
  336.                 pi.header.setName(values[1]);

  338.                 // Identifiers
  339.                 pi.header.setIlrsSatelliteId(values[2]);
  340.                 pi.header.setSic(values[3]);
  341.                 pi.header.setNoradId(values[4]);

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

  346.                 // Target class and location (if needed)
  347.                 pi.header.setTargetClass(Integer.parseInt(values[6]));
  348.                 if (pi.version == 2) {
  349.                     pi.header.setTargetLocation(Integer.parseInt(values[7]));
  350.                 }

  352.             }

  354.             /** {@inheritDoc} */
  355.             @Override
  356.             public Stream<LineParser> allowedNext() {
  357.                 return Stream.of(H4);
  358.             }

  360.         },

  362.         /** Format header. */
  363.         H4("H4", "h4") {

  365.             /** {@inheritDoc} */
  366.             @Override
  367.             public void parse(final String line, final ParseInfo pi) {

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

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

  375.                 // Start epoch
  376.                 final int    yearS   = Integer.parseInt(values[2]);
  377.                 final int    monthS  = Integer.parseInt(values[3]);
  378.                 final int    dayS    = Integer.parseInt(values[4]);
  379.                 final int    hourS   = Integer.parseInt(values[5]);
  380.                 final int    minuteS = Integer.parseInt(values[6]);
  381.                 final double secondS = Integer.parseInt(values[7]);

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

  385.                 pi.header.setStartEpoch(new AbsoluteDate(yearS, monthS, dayS,
  386.                                                          hourS, minuteS, secondS,
  387.                                                          pi.timeScale));

  389.                 // End epoch
  390.                 final int    yearE   = Integer.parseInt(values[8]);
  391.                 final int    monthE  = Integer.parseInt(values[9]);
  392.                 final int    dayE    = Integer.parseInt(values[10]);
  393.                 final int    hourE   = Integer.parseInt(values[11]);
  394.                 final int    minuteE = Integer.parseInt(values[12]);
  395.                 final double secondE = Integer.parseInt(values[13]);

  397.                 pi.header.setEndEpoch(new AbsoluteDate(yearE, monthE, dayE,
  398.                                                        hourE, minuteE, secondE,
  399.                                                        pi.timeScale));

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

  404.                 // Correction flags
  405.                 pi.header.setIsTroposphericRefractionApplied(readBoolean(values[15]));
  406.                 pi.header.setIsCenterOfMassCorrectionApplied(readBoolean(values[16]));
  407.                 pi.header.setIsReceiveAmplitudeCorrectionApplied(readBoolean(values[17]));
  408.                 pi.header.setIsStationSystemDelayApplied(readBoolean(values[18]));
  409.                 pi.header.setIsTransponderDelayApplied(readBoolean(values[19]));

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

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

  417.             }

  419.             /** {@inheritDoc} */
  420.             @Override
  421.             public Stream<LineParser> allowedNext() {
  422.                 return Stream.of(H5, C0);
  423.             }

  425.         },

  427.         /** Format header. */
  428.         H5("H5", "h5") {

  430.             /** {@inheritDoc} */
  431.             @Override
  432.             public void parse(final String line, final ParseInfo pi) {

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

  437.                 // Fill data
  438.                 pi.header.setPredictionType(Integer.parseInt(values[1]));
  439.                 pi.header.setYearOfCentury(Integer.parseInt(values[2]));
  440.                 pi.header.setDateAndTime(values[3]);
  441.                 pi.header.setPredictionProvider(values[4]);
  442.                 pi.header.setSequenceNumber(Integer.parseInt(values[5]));

  444.             }

  446.             /** {@inheritDoc} */
  447.             @Override
  448.             public Stream<LineParser> allowedNext() {
  449.                 return Stream.of(C0);
  450.             }

  452.         },

  454.         /** System configuration record. */
  455.         C0("C0", "c0") {

  457.             /** {@inheritDoc} */
  458.             @Override
  459.             public void parse(final String line, final ParseInfo pi) {

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

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

  467.                 // Wavelength
  468.                 systemRecord.setWavelength(Double.parseDouble(values[2]) * NM_TO_M);

  470.                 // System ID
  471.                 systemRecord.setSystemId(values[3]);

  473.                 // Set the system configuration record
  474.                 pi.configurationRecords.setSystemRecord(systemRecord);

  476.             }

  478.             /** {@inheritDoc} */
  479.             @Override
  480.             public Stream<LineParser> allowedNext() {
  481.                 return Stream.of(C1, C2, C3, C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  482.             }

  484.         },


  487.         /** Laser configuration record. */
  488.         C1("C1", "c1") {

  490.             /** {@inheritDoc} */
  491.             @Override
  492.             public void parse(final String line, final ParseInfo pi) {

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

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

  500.                 // Fill values
  501.                 laserRecord.setLaserId(values[2]);
  502.                 laserRecord.setLaserType(values[3]);
  503.                 laserRecord.setPrimaryWavelength(Double.parseDouble(values[4]) * NM_TO_M);
  504.                 laserRecord.setNominalFireRate(Double.parseDouble(values[5]));
  505.                 laserRecord.setPulseEnergy(Double.parseDouble(values[6]));
  506.                 laserRecord.setPulseWidth(Double.parseDouble(values[7]));
  507.                 laserRecord.setBeamDivergence(Double.parseDouble(values[8]));
  508.                 laserRecord.setPulseInOutgoingSemiTrain(Integer.parseInt(values[9]));

  510.                 // Set the laser configuration record
  511.                 pi.configurationRecords.setLaserRecord(laserRecord);

  513.             }

  515.             /** {@inheritDoc} */
  516.             @Override
  517.             public Stream<LineParser> allowedNext() {
  518.                 return Stream.of(C2, C3, C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  519.             }

  521.         },

  523.         /** Detector configuration record. */
  524.         C2("C2", "c2") {

  526.             /** {@inheritDoc} */
  527.             @Override
  528.             public void parse(final String line, final ParseInfo pi) {

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

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

  536.                 // Fill values
  537.                 detectorRecord.setDetectorId(values[2]);
  538.                 detectorRecord.setDetectorType(values[3]);
  539.                 detectorRecord.setApplicableWavelength(Double.parseDouble(values[4]) * NM_TO_M);
  540.                 detectorRecord.setQuantumEfficiency(Double.parseDouble(values[5]));
  541.                 detectorRecord.setAppliedVoltage(Double.parseDouble(values[6]));
  542.                 detectorRecord.setDarkCount(Double.parseDouble(values[7]) * KHZ_TO_HZ);
  543.                 detectorRecord.setOutputPulseType(values[8]);
  544.                 detectorRecord.setOutputPulseWidth(Double.parseDouble(values[9]));
  545.                 detectorRecord.setSpectralFilter(Double.parseDouble(values[10]) * NM_TO_M);
  546.                 detectorRecord.setTransmissionOfSpectralFilter(Double.parseDouble(values[11]));
  547.                 detectorRecord.setSpatialFilter(Double.parseDouble(values[12]));
  548.                 detectorRecord.setExternalSignalProcessing(values[13]);

  550.                 // Check file version for additional data
  551.                 if (pi.version == 2) {
  552.                     detectorRecord.setAmplifierGain(Double.parseDouble(values[14]));
  553.                     detectorRecord.setAmplifierBandwidth(Double.parseDouble(values[15]) * KHZ_TO_HZ);
  554.                     detectorRecord.setAmplifierInUse(values[16]);
  555.                 }

  557.                 // Set the detector configuration record
  558.                 pi.configurationRecords.setDetectorRecord(detectorRecord);

  560.             }

  562.             /** {@inheritDoc} */
  563.             @Override
  564.             public Stream<LineParser> allowedNext() {
  565.                 return Stream.of(C3, C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  566.             }

  568.         },

  570.         /** Timing system configuration record. */
  571.         C3("C3", "c3") {

  573.             /** {@inheritDoc} */
  574.             @Override
  575.             public void parse(final String line, final ParseInfo pi) {

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

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

  583.                 // Fill values
  584.                 timingRecord.setLocalTimingId(values[2]);
  585.                 timingRecord.setTimeSource(values[3]);
  586.                 timingRecord.setFrequencySource(values[4]);
  587.                 timingRecord.setTimer(values[5]);
  588.                 timingRecord.setTimerSerialNumber(values[6]);
  589.                 timingRecord.setEpochDelayCorrection(Double.parseDouble(values[7]) * US_TO_S);

  591.                 // Set the timing system configuration record
  592.                 pi.configurationRecords.setTimingRecord(timingRecord);

  594.             }

  596.             /** {@inheritDoc} */
  597.             @Override
  598.             public Stream<LineParser> allowedNext() {
  599.                 return Stream.of(C4, C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  600.             }

  602.         },

  604.         /** Transponder configuration record. */
  605.         C4("C4", "c4") {

  607.             /** {@inheritDoc} */
  608.             @Override
  609.             public void parse(final String line, final ParseInfo pi) {

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

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

  617.                 // Estimated offsets and drifts
  618.                 transponderRecord.setTransponderId(values[2]);
  619.                 transponderRecord.setStationUTCOffset(Double.parseDouble(values[3]) * NM_TO_M);
  620.                 transponderRecord.setStationOscDrift(Double.parseDouble(values[4]));
  621.                 transponderRecord.setTranspUTCOffset(Double.parseDouble(values[5]) * NM_TO_M);
  622.                 transponderRecord.setTranspOscDrift(Double.parseDouble(values[6]));

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

  627.                 // Clock and drift indicators
  628.                 transponderRecord.setStationClockAndDriftApplied(Integer.parseInt(values[8]));
  629.                 transponderRecord.setSpacecraftClockAndDriftApplied(Integer.parseInt(values[9]));

  631.                 // Spacecraft time simplified
  632.                 transponderRecord.setIsSpacecraftTimeSimplified(readBoolean(values[10]));

  634.                 // Set the transponder configuration record
  635.                 pi.configurationRecords.setTransponderRecord(transponderRecord);

  637.             }

  639.             /** {@inheritDoc} */
  640.             @Override
  641.             public Stream<LineParser> allowedNext() {
  642.                 return Stream.of(C5, C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  643.             }

  645.         },

  647.         /** Software configuration record. */
  648.         C5("C5", "c5") {

  650.             /** {@inheritDoc} */
  651.             @Override
  652.             public void parse(final String line, final ParseInfo pi) {

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

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

  660.                 // Fill values
  661.                 softwareRecord.setSoftwareId(values[2]);
  662.                 softwareRecord.setTrackingSoftwares(COMMA.split(values[3]));
  663.                 softwareRecord.setTrackingSoftwareVersions(COMMA.split(values[4]));
  664.                 softwareRecord.setProcessingSoftwares(COMMA.split(values[5]));
  665.                 softwareRecord.setProcessingSoftwareVersions(COMMA.split(values[6]));

  667.                 // Set the software configuration record
  668.                 pi.configurationRecords.setSoftwareRecord(softwareRecord);

  670.             }

  672.             /** {@inheritDoc} */
  673.             @Override
  674.             public Stream<LineParser> allowedNext() {
  675.                 return Stream.of(C6, C7, TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  676.             }

  678.         },

  680.         /** Meteorological instrumentation configuration record. */
  681.         C6("C6", "c6") {

  683.             /** {@inheritDoc} */
  684.             @Override
  685.             public void parse(final String line, final ParseInfo pi) {

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

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

  693.                 // Fill values
  694.                 meteoRecord.setMeteorologicalId(values[2]);
  695.                 meteoRecord.setPressSensorManufacturer(values[3]);
  696.                 meteoRecord.setPressSensorModel(values[4]);
  697.                 meteoRecord.setPressSensorSerialNumber(values[5]);
  698.                 meteoRecord.setTempSensorManufacturer(values[6]);
  699.                 meteoRecord.setTempSensorModel(values[7]);
  700.                 meteoRecord.setTempSensorSerialNumber(values[8]);
  701.                 meteoRecord.setHumiSensorManufacturer(values[9]);
  702.                 meteoRecord.setHumiSensorModel(values[10]);
  703.                 meteoRecord.setHumiSensorSerialNumber(values[11]);

  705.                 // Set the meteorological configuration record
  706.                 pi.configurationRecords.setMeteorologicalRecord(meteoRecord);

  708.             }

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

  716.         },

  718.         /** Calibration Target configuration record. */
  719.         C7("C7", "c7") {

  721.             /** {@inheritDoc} */
  722.             @Override
  723.             public void parse(final String line, final ParseInfo pi) {
  724.                 // Not implemented yet
  725.             }

  727.             /** {@inheritDoc} */
  728.             @Override
  729.             public Stream<LineParser> allowedNext() {
  730.                 return Stream.of(TEN, ELEVEN, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  731.             }

  733.         },

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

  738.             /** {@inheritDoc} */
  739.             @Override
  740.             public void parse(final String line, final ParseInfo pi) {

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

  745.                 // Read data
  746.                 final double secOfDay     = Double.parseDouble(values[1]);
  747.                 final double timeOfFlight = Double.parseDouble(values[2]);
  748.                 final int    epochEvent   = Integer.parseInt(values[4]);

  750.                 // Initialise a new Range measurement
  751.                 final AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  752.                 final RangeMeasurement range = new RangeMeasurement(epoch, timeOfFlight, epochEvent);
  753.                 pi.dataBlock.addRangeData(range);

  755.             }

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

  763.         },

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

  768.             /** {@inheritDoc} */
  769.             @Override
  770.             public void parse(final String line, final ParseInfo pi) {

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

  775.                 // Read data
  776.                 final double secOfDay     = Double.parseDouble(values[1]);
  777.                 final double timeOfFlight = Double.parseDouble(values[2]);
  778.                 final int    epochEvent   = Integer.parseInt(values[4]);
  779.                 final double snr          = (pi.version == 2) ? Double.parseDouble(values[13]) : Double.NaN;

  781.                 // Initialise a new Range measurement
  782.                 final AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  783.                 final RangeMeasurement range = new RangeMeasurement(epoch, timeOfFlight, epochEvent, snr);
  784.                 pi.dataBlock.addRangeData(range);

  786.             }

  788.             /** {@inheritDoc} */
  789.             @Override
  790.             public Stream<LineParser> allowedNext() {
  791.                 return Stream.of(H8, ELEVEN, TWELVE, METEO, ANGLES, CALIB, STAT, COMPATIBILITY);
  792.             }

  794.         },

  796.         /** Range Supplement Record. */
  797.         TWELVE("12") {

  799.             /** {@inheritDoc} */
  800.             @Override
  801.             public void parse(final String line, final ParseInfo pi) {
  802.                 // Not implemented yet
  803.             }

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

  811.         },

  813.         /** Meteorological record. */
  814.         METEO("20") {

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

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

  823.                 // Read data
  824.                 final double secOfDay    = Double.parseDouble(values[1]);
  825.                 final double pressure    = Double.parseDouble(values[2]) * MILLI_TO_NONE;
  826.                 final double temperature = Double.parseDouble(values[3]);
  827.                 final double humidity    = Double.parseDouble(values[4]);

  829.                 // Initialise a new meteorological measurement
  830.                 final AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  831.                 final MeteorologicalMeasurement meteo = new MeteorologicalMeasurement(epoch, pressure,
  832.                                                                                       temperature, humidity);
  833.                 pi.dataBlock.addMeteoData(meteo);

  835.             }

  837.             /** {@inheritDoc} */
  838.             @Override
  839.             public Stream<LineParser> allowedNext() {
  840.                 return Stream.of(H8, METEO, METEO_SUPP, TEN, ELEVEN, TWELVE, ANGLES, CALIB, STAT, COMPATIBILITY);
  841.             }

  843.         },

  845.         /** Meteorological Supplement record. */
  846.         METEO_SUPP("21") {

  848.             /** {@inheritDoc} */
  849.             @Override
  850.             public void parse(final String line, final ParseInfo pi) {
  851.                 // Not implemented yet
  852.             }

  854.             /** {@inheritDoc} */
  855.             @Override
  856.             public Stream<LineParser> allowedNext() {
  857.                 return Stream.of(H8, METEO, METEO_SUPP, TEN, ELEVEN, TWELVE, ANGLES, CALIB, STAT, COMPATIBILITY);
  858.             }

  860.         },

  862.         /** Pointing Angle Record. */
  863.         ANGLES("30") {

  865.             /** {@inheritDoc} */
  866.             @Override
  867.             public void parse(final String line, final ParseInfo pi) {

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

  872.                 // Read data
  873.                 final double  secOfDay              = Double.parseDouble(values[1]);
  874.                 final double  azmiuth               = FastMath.toRadians(Double.parseDouble(values[2]));
  875.                 final double  elevation             = FastMath.toRadians(Double.parseDouble(values[3]));
  876.                 final int     directionFlag         = Integer.parseInt(values[4]);
  877.                 final int     orginFlag             = Integer.parseInt(values[5]);
  878.                 final boolean isRefractionCorrected = readBoolean(values[6]);


  881.                 // Angles rates
  882.                 double azimuthRate   = Double.NaN;
  883.                 double elevationRate = Double.NaN;
  884.                 if (pi.version == 2) {
  885.                     azimuthRate   = readDoubleWithNaN(values[7]);
  886.                     elevationRate = readDoubleWithNaN(values[8]);
  887.                 }

  889.                 // Initialise a new angles measurement
  890.                 final AbsoluteDate epoch = new AbsoluteDate(pi.startEpoch, new TimeComponents(secOfDay), pi.timeScale);
  891.                 final AnglesMeasurement angles = new AnglesMeasurement(epoch, azmiuth, elevation,
  892.                                                                        directionFlag, orginFlag,
  893.                                                                        isRefractionCorrected,
  894.                                                                        azimuthRate, elevationRate);
  895.                 pi.dataBlock.addAnglesData(angles);

  897.             }

  899.             /** {@inheritDoc} */
  900.             @Override
  901.             public Stream<LineParser> allowedNext() {
  902.                 return Stream.of(H8, METEO, TEN, ELEVEN, ANGLES, CALIB, STAT, COMPATIBILITY);
  903.             }

  905.         },

  907.         /** Calibration Record. */
  908.         CALIB("40") {

  910.             /** {@inheritDoc} */
  911.             @Override
  912.             public void parse(final String line, final ParseInfo pi) {
  913.                 // Not implemented yet
  914.             }

  916.             /** {@inheritDoc} */
  917.             @Override
  918.             public Stream<LineParser> allowedNext() {
  919.                 return Stream.of(H8, METEO, CALIB, CALIB_DETAILS, CALIB_SHOT, TEN, ELEVEN, TWELVE, ANGLES, STAT, COMPATIBILITY);
  920.             }

  922.         },

  924.         /** Calibration Details Record. */
  925.         CALIB_DETAILS("41") {

  927.             /** {@inheritDoc} */
  928.             @Override
  929.             public void parse(final String line, final ParseInfo pi) {
  930.                 // Not implemented yet
  931.             }

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

  939.         },

  941.         /** Calibration "Shot" Record. */
  942.         CALIB_SHOT("42") {

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

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

  956.         },

  958.         /** Session (Pass) Statistics Record. */
  959.         STAT("50") {

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

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

  973.         },

  975.         /** Compatibility record. */
  976.         COMPATIBILITY("60") {

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

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

  990.         },

  992.         /** Comments. */
  993.         COMMENTS("00") {

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

  999.                 // Comment
  1000.                 final String comment = line.split(getFirstIdentifier())[1].trim();
  1001.                 pi.file.getComments().add(comment);

  1003.             }

  1005.             /** {@inheritDoc} */
  1006.             @Override
  1007.             public Stream<LineParser> allowedNext() {
  1008.                 return Stream.of(H1, H2, H3, H4, H5, H8, C0, C1, C2, C3, C4, C5, C6, C7);
  1009.             }

  1011.         },

  1013.         /** End of data block. */
  1014.         H8("H8", "h8") {

  1016.             /** {@inheritDoc} */
  1017.             @Override
  1018.             public void parse(final String line, final ParseInfo pi) {

  1020.                 // Fill data block
  1021.                 pi.dataBlock.setHeader(pi.header);
  1022.                 pi.dataBlock.setConfigurationRecords(pi.configurationRecords);

  1024.                 // Add the data block to the CRD file
  1025.                 pi.file.addDataBlock(pi.dataBlock);

  1027.                 // Initialize a new empty containers
  1028.                 pi.startEpoch           = DateComponents.J2000_EPOCH;
  1029.                 pi.header               = new CRDHeader();
  1030.                 pi.configurationRecords = new CRDConfiguration();
  1031.                 pi.dataBlock            = new CRDDataBlock();

  1033.             }

  1035.             /** {@inheritDoc} */
  1036.             @Override
  1037.             public Stream<LineParser> allowedNext() {
  1038.                 return Stream.of(H1, H9);
  1039.             }

  1041.         },

  1043.         /** Last record in file. */
  1044.         H9("H9", "h9") {

  1046.             /** {@inheritDoc} */
  1047.             @Override
  1048.             public void parse(final String line, final ParseInfo pi) {
  1049.                 pi.done = true;
  1050.             }

  1052.             /** {@inheritDoc} */
  1053.             @Override
  1054.             public Stream<LineParser> allowedNext() {
  1055.                 return Stream.of(H9);
  1056.             }

  1058.         };

  1060.         /** Patterns for identifying line. */
  1061.         private final Pattern[] patterns;

  1063.         /** Identifiers. */
  1064.         private final String[] identifiers;

  1066.         /** Simple constructor.
  1067.          * @param identifier regular expression for identifying line (i.e. first element)
  1068.          */
  1069.         LineParser(final String... identifier) {
  1070.             this.identifiers = identifier;
  1071.             // Initialise patterns
  1072.             this.patterns    = new Pattern[identifiers.length];
  1073.             for (int index = 0; index < patterns.length; index++) {
  1074.                 patterns[index] = Pattern.compile(identifiers[index]);
  1075.             }
  1076.         }

  1078.         /**
  1079.          * Get the regular expression for identifying line.
  1080.          * @return the regular expression for identifying line
  1081.          */
  1082.         public String getFirstIdentifier() {
  1083.             return identifiers[0];
  1084.         }

  1086.         /** Parse a line.
  1087.          * @param line line to parse
  1088.          * @param pi holder for transient data
  1089.          */
  1090.         public abstract void parse(String line, ParseInfo pi);

  1092.         /** Get the allowed parsers for next line.
  1093.          * @return allowed parsers for next line
  1094.          */
  1095.         public abstract Stream<LineParser> allowedNext();

  1097.         /** Check if parser can handle line.
  1098.          * @param line line to parse
  1099.          * @return true if parser can handle the specified line
  1100.          */
  1101.         public boolean canHandle(final String line) {
  1102.             // Line identifier
  1103.             final String lineId = SEPARATOR.split(line)[0];
  1104.             // Loop on patterns
  1105.             for (Pattern pattern : patterns) {
  1106.                 if (pattern.matcher(lineId).matches()) {
  1107.                     return true;
  1108.                 }
  1109.             }
  1110.             // No match
  1111.             return false;
  1112.         }

  1114.         /**
  1115.          * Read a boolean from a string value.
  1116.          * @param value input value
  1117.          * @return the correspondin boolean
  1118.          */
  1119.         private static boolean readBoolean(final String value) {
  1120.             return Integer.parseInt(value) == 1;
  1121.         }

  1123.         /**
  1124.          * Read a double value taking into consideration a possible "na".
  1125.          * @param value input string
  1126.          * @return the corresponding double value
  1127.          */
  1128.         private static double readDoubleWithNaN(final String value) {
  1129.             return "na".equals(value) ? Double.NaN : Double.parseDouble(value);
  1130.         }

  1132.     }

  1134. }
Created with JaCoCo 0.8.6.202009150832