RinexClockParser.java

  1. /* Copyright 2002-2023 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.rinex.clock;

  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.ArrayList;
  27. import java.util.Arrays;
  28. import java.util.Collections;
  29. import java.util.InputMismatchException;
  30. import java.util.List;
  31. import java.util.Locale;
  32. import java.util.Scanner;
  33. import java.util.function.Function;
  34. import java.util.regex.Pattern;

  36. import org.orekit.annotation.DefaultDataContext;
  37. import org.orekit.data.DataContext;
  38. import org.orekit.errors.OrekitException;
  39. import org.orekit.errors.OrekitMessages;
  40. import org.orekit.files.rinex.AppliedDCBS;
  41. import org.orekit.files.rinex.AppliedPCVS;
  42. import org.orekit.files.rinex.clock.RinexClock.ClockDataType;
  43. import org.orekit.files.rinex.clock.RinexClock.Receiver;
  44. import org.orekit.files.rinex.clock.RinexClock.ReferenceClock;
  45. import org.orekit.frames.Frame;
  46. import org.orekit.gnss.ObservationType;
  47. import org.orekit.gnss.SatelliteSystem;
  48. import org.orekit.gnss.TimeSystem;
  49. import org.orekit.time.AbsoluteDate;
  50. import org.orekit.time.DateComponents;
  51. import org.orekit.time.TimeComponents;
  52. import org.orekit.time.TimeScale;
  53. import org.orekit.time.TimeScales;
  54. import org.orekit.utils.IERSConventions;

  56. /** A parser for the clock file from the IGS.
  57.  * This parser handles versions 2.0 to 3.04 of the RINEX clock files.
  58.  * <p> It is able to manage some mistakes in file writing and format compliance such as wrong date format,
  59.  * misplaced header blocks or missing information. </p>
  60.  * <p> A time system should be specified in the file. However, if it is not, default time system will be chosen
  61.  * regarding the satellite system. If it is mixed or not specified, default time system will be UTC. </p>
  62.  * <p> Caution, files with missing information in header can lead to wrong data dates and station positions.
  63.  * It is advised to check the correctness and format compliance of the clock file to be parsed. </p>
  64.  * @see <a href="https://files.igs.org/pub/data/format/rinex_clock300.txt"> 3.00 clock file format</a>
  65.  * @see <a href="https://files.igs.org/pub/data/format/rinex_clock302.txt"> 3.02 clock file format</a>
  66.  * @see <a href="https://files.igs.org/pub/data/format/rinex_clock304.txt"> 3.04 clock file format</a>
  67.  *
  68.  * @author Thomas Paulet
  69.  * @since 11.0
  70.  */
  71. public class RinexClockParser {

  73.     /** Handled clock file format versions. */
  74.     private static final List<Double> HANDLED_VERSIONS = Arrays.asList(2.00, 3.00, 3.01, 3.02, 3.04);

  76.     /** Pattern for date format yyyy-mm-dd hh:mm. */
  77.     private static final Pattern DATE_PATTERN_1 = Pattern.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}.*$");;

  79.     /** Pattern for date format yyyymmdd hhmmss zone or YYYYMMDD  HHMMSS zone. */
  80.     private static final Pattern DATE_PATTERN_2 = Pattern.compile("^[0-9]{8}\\s{1,2}[0-9]{6}.*$");

  82.     /** Pattern for date format dd-MONTH-yyyy hh:mm zone or d-MONTH-yyyy hh:mm zone. */
  83.     private static final Pattern DATE_PATTERN_3 = Pattern.compile("^[0-9]{1,2}-[a-z,A-Z]{3}-[0-9]{4} [0-9]{2}:[0-9]{2}.*$");

  85.     /** Pattern for date format dd-MONTH-yy hh:mm zone or d-MONTH-yy hh:mm zone. */
  86.     private static final Pattern DATE_PATTERN_4 = Pattern.compile("^[0-9]{1,2}-[a-z,A-Z]{3}-[0-9]{2} [0-9]{2}:[0-9]{2}.*$");

  88.     /** Pattern for date format yyyy MONTH dd hh:mm:ss or yyyy MONTH d hh:mm:ss. */
  89.     private static final Pattern DATE_PATTERN_5 = Pattern.compile("^[0-9]{4} [a-z,A-Z]{3} [0-9]{1,2} [0-9]{2}:[0-9]{2}:[0-9]{2}.*$");

  91.     /** Spaces delimiters. */
  92.     private static final String SPACES = "\\s+";

  94.     /** SYS string for line browsing stop. */
  95.     private static final String SYS = "SYS";

  97.     /** One millimeter, in meters. */
  98.     private static final double MILLIMETER = 1.0e-3;

  100.     /** Mapping from frame identifier in the file to a {@link Frame}. */
  101.     private final Function<? super String, ? extends Frame> frameBuilder;

  103.     /** Set of time scales. */
  104.     private final TimeScales timeScales;

  106.     /**
  107.      * Create an clock file parser using default values.
  108.      *
  109.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  110.      *
  111.      * @see #RinexClockParser(Function)
  112.      */
  113.     @DefaultDataContext
  114.     public RinexClockParser() {
  115.         this(RinexClockParser::guessFrame);
  116.     }

  118.     /**
  119.      * Create a clock file parser and specify the frame builder.
  120.      *
  121.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  122.      *
  123.      * @param frameBuilder is a function that can construct a frame from a clock file
  124.      *                     coordinate system string. The coordinate system can be
  125.      *                     any 5 character string e.g. ITR92, IGb08.
  126.      * @see #RinexClockParser(Function, TimeScales)
  127.      */
  128.     @DefaultDataContext
  129.     public RinexClockParser(final Function<? super String, ? extends Frame> frameBuilder) {
  130.         this(frameBuilder, DataContext.getDefault().getTimeScales());
  131.     }

  133.     /** Constructor, build the IGS clock file parser.
  134.      * @param frameBuilder is a function that can construct a frame from a clock file
  135.      *                     coordinate system string. The coordinate system can be
  136.      *                     any 5 character string e.g. ITR92, IGb08.
  137.      * @param timeScales   the set of time scales used for parsing dates.
  138.      */
  139.     public RinexClockParser(final Function<? super String, ? extends Frame> frameBuilder,
  140.                            final TimeScales timeScales) {

  142.         this.frameBuilder = frameBuilder;
  143.         this.timeScales   = timeScales;
  144.     }

  146.     /**
  147.      * Default string to {@link Frame} conversion for {@link #CLockFileParser()}.
  148.      *
  149.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  150.      *
  151.      * @param name of the frame.
  152.      * @return by default, return ITRF based on 2010 conventions,
  153.      *         with tidal effects considered during EOP interpolation.
  154.      * <p>If String matches to other already recorded frames, it will return the corresponding frame.</p>
  155.      * Already embedded frames are:
  156.      * <p> - ITRF96
  157.      */
  158.     @DefaultDataContext
  159.     private static Frame guessFrame(final String name) {
  160.         if (name.equals("ITRF96")) {
  161.             return DataContext.getDefault().getFrames()
  162.                               .getITRF(IERSConventions.IERS_1996, false);
  163.         } else {
  164.             return DataContext.getDefault().getFrames()
  165.                               .getITRF(IERSConventions.IERS_2010, false);
  166.         }
  167.     }

  169.     /**
  170.      * Parse an IGS clock file from an input stream using the UTF-8 charset.
  171.      *
  172.      * <p> This method creates a {@link BufferedReader} from the stream and as such this
  173.      * method may read more data than necessary from {@code stream} and the additional
  174.      * data will be lost. The other parse methods do not have this issue.
  175.      *
  176.      * @param stream to read the IGS clock file from
  177.      * @return a parsed IGS clock file
  178.      * @throws IOException if {@code stream} throws one
  179.      * @see #parse(String)
  180.      * @see #parse(BufferedReader, String)
  181.      */
  182.     public RinexClock parse(final InputStream stream) throws IOException {
  183.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  184.             return parse(reader, stream.toString());
  185.         }
  186.     }

  188.     /**
  189.      * Parse an IGS clock file from a file on the local file system.
  190.      * @param fileName file name
  191.      * @return a parsed IGS clock file
  192.      * @throws IOException if one is thrown while opening or reading from {@code fileName}
  193.      * @see #parse(InputStream)
  194.      * @see #parse(BufferedReader, String)
  195.      */
  196.     public RinexClock parse(final String fileName) throws IOException {
  197.         try (BufferedReader reader = Files.newBufferedReader(Paths.get(fileName),
  198.                                                              StandardCharsets.UTF_8)) {
  199.             return parse(reader, fileName);
  200.         }
  201.     }

  203.     /**
  204.      * Parse an IGS clock file from a stream.
  205.      * @param reader containing the clock file
  206.      * @param fileName file name
  207.      * @return a parsed IGS clock file
  208.      * @throws IOException if {@code reader} throws one
  209.      * @see #parse(InputStream)
  210.      * @see #parse(String)
  211.      */
  212.     public RinexClock parse(final BufferedReader reader,
  213.                            final String fileName) throws IOException {

  215.         // initialize internal data structures
  216.         final ParseInfo pi = new ParseInfo();

  218.         int lineNumber = 0;
  219.         Iterable<LineParser> candidateParsers = Collections.singleton(LineParser.HEADER_VERSION);
  220.         nextLine:
  221.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  222.             ++lineNumber;
  223.             for (final LineParser candidate : candidateParsers) {
  224.                 if (candidate.canHandle(line)) {
  225.                     try {
  226.                         candidate.parse(line, pi);
  227.                         candidateParsers = candidate.allowedNext();
  228.                         continue nextLine;
  229.                     } catch (StringIndexOutOfBoundsException | NumberFormatException | InputMismatchException e) {
  230.                         throw new OrekitException(e,
  231.                                                   OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  232.                                                   lineNumber, fileName, line);
  233.                     }
  234.                 }
  235.             }

  237.             // no parsers found for this line
  238.             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  239.                                       lineNumber, fileName, line);

  241.         }

  243.         return pi.file;

  245.     }

  247.     /** Transient data used for parsing a clock file. */
  248.     private class ParseInfo {

  250.         /** Set of time scales for parsing dates. */
  251.         private final TimeScales timeScales;

  253.         /** The corresponding clock file object. */
  254.         private RinexClock file;

  256.         /** Current satellite system for observation type parsing. */
  257.         private SatelliteSystem currentSatelliteSystem;

  259.         /** Current start date for reference clocks. */
  260.         private AbsoluteDate referenceClockStartDate;

  262.         /** Current end date for reference clocks. */
  263.         private AbsoluteDate referenceClockEndDate;

  265.         /** Current reference clock list. */
  266.         private List<ReferenceClock> currentReferenceClocks;

  268.         /** Current clock data type. */
  269.         private ClockDataType currentDataType;

  271.         /** Current receiver/satellite name. */
  272.         private String currentName;

  274.         /** Current data date components. */
  275.         private DateComponents currentDateComponents;

  277.         /** Current data time components. */
  278.         private TimeComponents currentTimeComponents;

  280.         /** Current data number of data values to follow. */
  281.         private int currentNumberOfValues;

  283.         /** Current data values. */
  284.         private double[] currentDataValues;

  286.         /** Constructor, build the ParseInfo object. */
  287.         protected ParseInfo () {
  288.             this.timeScales = RinexClockParser.this.timeScales;
  289.             this.file = new RinexClock(frameBuilder);
  290.         }
  291.     }


  294.     /** Parsers for specific lines. */
  295.     private enum LineParser {

  297.         /** Parser for version, file type and satellite system. */
  298.         HEADER_VERSION("^.+RINEX VERSION / TYPE( )*$") {

  300.             /** {@inheritDoc} */
  301.             @Override
  302.             public void parse(final String line, final ParseInfo pi) {
  303.                 try (Scanner s1      = new Scanner(line);
  304.                      Scanner s2      = s1.useDelimiter(SPACES);
  305.                      Scanner scanner = s2.useLocale(Locale.US)) {

  307.                     // First element of the line is format version
  308.                     final double version = scanner.nextDouble();

  310.                     // Throw exception if format version is not handled
  311.                     if (!HANDLED_VERSIONS.contains(version)) {
  312.                         throw new OrekitException(OrekitMessages.CLOCK_FILE_UNSUPPORTED_VERSION, version);
  313.                     }

  315.                     pi.file.setFormatVersion(version);

  317.                     // Second element is clock file indicator, not used here

  319.                     // Last element is the satellite system, might be missing
  320.                     final String satelliteSystemString = line.substring(40, 45).trim();

  322.                     // Check satellite if system is recorded
  323.                     if (!satelliteSystemString.equals("")) {
  324.                         // Record satellite system and default time system in clock file object
  325.                         final SatelliteSystem satelliteSystem = SatelliteSystem.parseSatelliteSystem(satelliteSystemString);
  326.                         pi.file.setSatelliteSystem(satelliteSystem);
  327.                         pi.file.setTimeScale(satelliteSystem.getObservationTimeScale().getTimeScale(pi.timeScales));
  328.                     }
  329.                     // Set time scale to UTC by default
  330.                     if (pi.file.getTimeScale() == null) {
  331.                         pi.file.setTimeScale(pi.timeScales.getUTC());
  332.                     }
  333.                 }
  334.             }

  336.         },

  338.         /** Parser for generating program and emiting agency. */
  339.         HEADER_PROGRAM("^.+PGM / RUN BY / DATE( )*$") {

  341.             /** {@inheritDoc} */
  342.             @Override
  343.             public void parse(final String line, final ParseInfo pi) {

  345.                 // First element of the name of the generating program
  346.                 final String programName = line.substring(0, 20).trim();
  347.                 pi.file.setProgramName(programName);

  349.                 // Second element is the name of the emiting agency
  350.                 final String agencyName = line.substring(20, 40).trim();
  351.                 pi.file.setAgencyName(agencyName);

  353.                 // Third element is date
  354.                 String dateString = "";

  356.                 if (pi.file.getFormatVersion() < 3.04) {

  358.                     // Date string location before 3.04 format version
  359.                     dateString = line.substring(40, 60);

  361.                 } else {

  363.                     // Date string location after 3.04 format version
  364.                     dateString = line.substring(42, 65);

  366.                 }

  368.                 parseDateTimeZone(dateString, pi);

  370.             }

  372.         },

  374.         /** Parser for comments. */
  375.         HEADER_COMMENT("^.+COMMENT( )*$") {

  377.             /** {@inheritDoc} */
  378.             @Override
  379.             public void parse(final String line, final ParseInfo pi) {

  381.                 if (pi.file.getFormatVersion() < 3.04) {
  382.                     pi.file.addComment(line.substring(0, 60).trim());
  383.                 } else {
  384.                     pi.file.addComment(line.substring(0, 65).trim());
  385.                 }
  386.             }

  388.         },

  390.         /** Parser for satellite system and related observation types. */
  391.         HEADER_SYSTEM_OBS("^[A-Z] .*SYS / # / OBS TYPES( )*$") {

  393.             /** {@inheritDoc} */
  394.             @Override
  395.             public void parse(final String line, final ParseInfo pi) {
  396.                 try (Scanner s1      = new Scanner(line);
  397.                      Scanner s2      = s1.useDelimiter(SPACES);
  398.                      Scanner scanner = s2.useLocale(Locale.US)) {

  400.                     // First element of the line is satellite system code
  401.                     final SatelliteSystem satelliteSystem = SatelliteSystem.parseSatelliteSystem(scanner.next());
  402.                     pi.currentSatelliteSystem = satelliteSystem;

  404.                     // Second element is the number of different observation types
  405.                     scanner.nextInt();

  407.                     // Parse all observation types
  408.                     String currentObsType = scanner.next();
  409.                     while (!currentObsType.equals(SYS)) {
  410.                         final ObservationType obsType = ObservationType.valueOf(currentObsType);
  411.                         pi.file.addSystemObservationType(satelliteSystem, obsType);
  412.                         currentObsType = scanner.next();
  413.                     }
  414.                 }
  415.             }

  417.         },

  419.         /** Parser for continuation of satellite system and related observation types. */
  420.         HEADER_SYSTEM_OBS_CONTINUATION("^ .*SYS / # / OBS TYPES( )*$") {

  422.             /** {@inheritDoc} */
  423.             @Override
  424.             public void parse(final String line, final ParseInfo pi) {
  425.                 try (Scanner s1      = new Scanner(line);
  426.                      Scanner s2      = s1.useDelimiter(SPACES);
  427.                      Scanner scanner = s2.useLocale(Locale.US)) {

  429.                     // This is a continuation line, there are only observation types
  430.                     // Parse all observation types
  431.                     String currentObsType = scanner.next();
  432.                     while (!currentObsType.equals(SYS)) {
  433.                         final ObservationType obsType = ObservationType.valueOf(currentObsType);
  434.                         pi.file.addSystemObservationType(pi.currentSatelliteSystem, obsType);
  435.                         currentObsType = scanner.next();
  436.                     }
  437.                 }
  438.             }

  440.         },

  442.         /** Parser for data time system. */
  443.         HEADER_TIME_SYSTEM("^.+TIME SYSTEM ID( )*$") {

  445.             /** {@inheritDoc} */
  446.             @Override
  447.             public void parse(final String line, final ParseInfo pi) {
  448.                 try (Scanner s1      = new Scanner(line);
  449.                      Scanner s2      = s1.useDelimiter(SPACES);
  450.                      Scanner scanner = s2.useLocale(Locale.US)) {

  452.                     // Only element is the time system code
  453.                     final TimeSystem timeSystem = TimeSystem.parseTimeSystem(scanner.next());
  454.                     final TimeScale timeScale = timeSystem.getTimeScale(pi.timeScales);
  455.                     pi.file.setTimeSystem(timeSystem);
  456.                     pi.file.setTimeScale(timeScale);
  457.                 }
  458.             }

  460.         },

  462.         /** Parser for leap seconds. */
  463.         HEADER_LEAP_SECONDS("^.+LEAP SECONDS( )*$") {

  465.             /** {@inheritDoc} */
  466.             @Override
  467.             public void parse(final String line, final ParseInfo pi) {
  468.                 try (Scanner s1      = new Scanner(line);
  469.                      Scanner s2      = s1.useDelimiter(SPACES);
  470.                      Scanner scanner = s2.useLocale(Locale.US)) {

  472.                     // Only element is the number of leap seconds
  473.                     final int numberOfLeapSeconds = scanner.nextInt();
  474.                     pi.file.setNumberOfLeapSeconds(numberOfLeapSeconds);
  475.                 }
  476.             }

  478.         },

  480.         /** Parser for leap seconds GNSS. */
  481.         HEADER_LEAP_SECONDS_GNSS("^.+LEAP SECONDS GNSS( )*$") {

  483.             /** {@inheritDoc} */
  484.             @Override
  485.             public void parse(final String line, final ParseInfo pi) {
  486.                 try (Scanner s1      = new Scanner(line);
  487.                      Scanner s2      = s1.useDelimiter(SPACES);
  488.                      Scanner scanner = s2.useLocale(Locale.US)) {

  490.                     // Only element is the number of leap seconds GNSS
  491.                     final int numberOfLeapSecondsGNSS = scanner.nextInt();
  492.                     pi.file.setNumberOfLeapSecondsGNSS(numberOfLeapSecondsGNSS);
  493.                 }
  494.             }

  496.         },

  498.         /** Parser for applied differencial code bias corrections. */
  499.         HEADER_DCBS("^.+SYS / DCBS APPLIED( )*$") {

  501.             /** {@inheritDoc} */
  502.             @Override
  503.             public void parse(final String line, final ParseInfo pi) {

  505.                 // First element is the related satellite system
  506.                 final SatelliteSystem satelliteSystem = SatelliteSystem.parseSatelliteSystem(line.substring(0, 1));

  508.                 // Second element is the program name
  509.                 final String progDCBS = line.substring(2, 20).trim();

  511.                 // Third element is the source of the corrections
  512.                 String sourceDCBS = "";
  513.                 if (pi.file.getFormatVersion() < 3.04) {
  514.                     sourceDCBS = line.substring(19, 60).trim();
  515.                 } else {
  516.                     sourceDCBS = line.substring(22, 65).trim();
  517.                 }

  519.                 // Check if sought fields were not actually blanks
  520.                 if (!progDCBS.equals("")) {
  521.                     pi.file.addAppliedDCBS(new AppliedDCBS(satelliteSystem, progDCBS, sourceDCBS));
  522.                 }
  523.             }

  525.         },

  527.         /** Parser for applied phase center variation corrections. */
  528.         HEADER_PCVS("^.+SYS / PCVS APPLIED( )*$") {

  530.             /** {@inheritDoc} */
  531.             @Override
  532.             public void parse(final String line, final ParseInfo pi) {

  534.                 // First element is the related satellite system
  535.                 final SatelliteSystem satelliteSystem = SatelliteSystem.parseSatelliteSystem(line.substring(0, 1));

  537.                 // Second element is the program name
  538.                 final String progPCVS = line.substring(2, 20).trim();

  540.                 // Third element is the source of the corrections
  541.                 String sourcePCVS = "";
  542.                 if (pi.file.getFormatVersion() < 3.04) {
  543.                     sourcePCVS = line.substring(19, 60).trim();
  544.                 } else {
  545.                     sourcePCVS = line.substring(22, 65).trim();
  546.                 }

  548.                 // Check if sought fields were not actually blanks
  549.                 if (!progPCVS.equals("") || !sourcePCVS.equals("")) {
  550.                     pi.file.addAppliedPCVS(new AppliedPCVS(satelliteSystem, progPCVS, sourcePCVS));
  551.                 }
  552.             }

  554.         },

  556.         /** Parser for the different clock data types that are stored in the file. */
  557.         HEADER_TYPES_OF_DATA("^.+# / TYPES OF DATA( )*$") {

  559.             /** {@inheritDoc} */
  560.             @Override
  561.             public void parse(final String line, final ParseInfo pi) {
  562.                 try (Scanner s1      = new Scanner(line);
  563.                      Scanner s2      = s1.useDelimiter(SPACES);
  564.                      Scanner scanner = s2.useLocale(Locale.US)) {

  566.                     // First element is the number of different types of data
  567.                     final int numberOfDifferentDataTypes = scanner.nextInt();

  569.                     // Loop over data types
  570.                     for (int i = 0; i < numberOfDifferentDataTypes; i++) {
  571.                         final ClockDataType dataType = ClockDataType.parseClockDataType(scanner.next());
  572.                         pi.file.addClockDataType(dataType);
  573.                     }
  574.                 }
  575.             }

  577.         },

  579.         /** Parser for the station with reference clock. */
  580.         HEADER_STATIONS_NAME("^.+STATION NAME / NUM( )*$") {

  582.             /** {@inheritDoc} */
  583.             @Override
  584.             public void parse(final String line, final ParseInfo pi) {
  585.                 try (Scanner s1      = new Scanner(line);
  586.                      Scanner s2      = s1.useDelimiter(SPACES);
  587.                      Scanner scanner = s2.useLocale(Locale.US)) {

  589.                     // First element is the station clock reference ID
  590.                     final String stationName = scanner.next();
  591.                     pi.file.setStationName(stationName);

  593.                     // Second element is the station clock reference identifier
  594.                     final String stationIdentifier = scanner.next();
  595.                     pi.file.setStationIdentifier(stationIdentifier);
  596.                 }
  597.             }

  599.         },

  601.         /** Parser for the reference clock in case of calibration data. */
  602.         HEADER_STATION_CLOCK_REF("^.+STATION CLK REF( )*$") {

  604.             /** {@inheritDoc} */
  605.             @Override
  606.             public void parse(final String line, final ParseInfo pi) {
  607.                 if (pi.file.getFormatVersion() < 3.04) {
  608.                     pi.file.setExternalClockReference(line.substring(0, 60).trim());
  609.                 } else {
  610.                     pi.file.setExternalClockReference(line.substring(0, 65).trim());
  611.                 }
  612.             }

  614.         },

  616.         /** Parser for the analysis center. */
  617.         HEADER_ANALYSIS_CENTER("^.+ANALYSIS CENTER( )*$") {

  619.             /** {@inheritDoc} */
  620.             @Override
  621.             public void parse(final String line, final ParseInfo pi) {

  623.                 // First element is IGS AC designator
  624.                 final String analysisCenterID = line.substring(0, 3).trim();
  625.                 pi.file.setAnalysisCenterID(analysisCenterID);

  627.                 // Then, the full name of the analysis center
  628.                 String analysisCenterName = "";
  629.                 if (pi.file.getFormatVersion() < 3.04) {
  630.                     analysisCenterName = line.substring(5, 60).trim();
  631.                 } else {
  632.                     analysisCenterName = line.substring(5, 65).trim();
  633.                 }
  634.                 pi.file.setAnalysisCenterName(analysisCenterName);
  635.             }

  637.         },

  639.         /** Parser for the number of reference clocks over a period. */
  640.         HEADER_NUMBER_OF_CLOCK_REF("^.+# OF CLK REF( )*$") {

  642.             /** {@inheritDoc} */
  643.             @Override
  644.             public void parse(final String line, final ParseInfo pi) {
  645.                 try (Scanner s1      = new Scanner(line);
  646.                      Scanner s2      = s1.useDelimiter(SPACES);
  647.                      Scanner scanner = s2.useLocale(Locale.US)) {

  649.                     // Initialize current reference clock list corresponding to the period
  650.                     pi.currentReferenceClocks = new ArrayList<ReferenceClock>();

  652.                     // First element is the number of reference clocks corresponding to the period
  653.                     scanner.nextInt();

  655.                     if (scanner.hasNextInt()) {
  656.                         // Second element is the start epoch of the period
  657.                         final int startYear   = scanner.nextInt();
  658.                         final int startMonth  = scanner.nextInt();
  659.                         final int startDay    = scanner.nextInt();
  660.                         final int startHour   = scanner.nextInt();
  661.                         final int startMin    = scanner.nextInt();
  662.                         final double startSec = scanner.nextDouble();
  663.                         final AbsoluteDate startEpoch = new AbsoluteDate(startYear, startMonth, startDay,
  664.                                                                          startHour, startMin, startSec,
  665.                                                                          pi.file.getTimeScale());
  666.                         pi.referenceClockStartDate = startEpoch;

  668.                         // Third element is the end epoch of the period
  669.                         final int endYear   = scanner.nextInt();
  670.                         final int endMonth  = scanner.nextInt();
  671.                         final int endDay    = scanner.nextInt();
  672.                         final int endHour   = scanner.nextInt();
  673.                         final int endMin    = scanner.nextInt();
  674.                         double endSec       = 0.0;
  675.                         if (pi.file.getFormatVersion() < 3.04) {
  676.                             endSec = Double.parseDouble(line.substring(51, 60));
  677.                         } else {
  678.                             endSec = scanner.nextDouble();
  679.                         }
  680.                         final AbsoluteDate endEpoch = new AbsoluteDate(endYear, endMonth, endDay,
  681.                                                                        endHour, endMin, endSec,
  682.                                                                        pi.file.getTimeScale());
  683.                         pi.referenceClockEndDate = endEpoch;
  684.                     } else {
  685.                         pi.referenceClockStartDate = AbsoluteDate.PAST_INFINITY;
  686.                         pi.referenceClockEndDate = AbsoluteDate.FUTURE_INFINITY;
  687.                     }
  688.                 }
  689.             }

  691.         },

  693.         /** Parser for the reference clock over a period. */
  694.         HEADER_ANALYSIS_CLOCK_REF("^.+ANALYSIS CLK REF( )*$") {

  696.             /** {@inheritDoc} */
  697.             @Override
  698.             public void parse(final String line, final ParseInfo pi) {
  699.                 try (Scanner s1      = new Scanner(line);
  700.                      Scanner s2      = s1.useDelimiter(SPACES);
  701.                      Scanner scanner = s2.useLocale(Locale.US)) {

  703.                     // First element is the name of the receiver/satellite embedding the reference clock
  704.                     final String referenceName = scanner.next();

  706.                     // Second element is the reference clock ID
  707.                     final String clockID = scanner.next();

  709.                     // Optionally, third element is an a priori clock constraint, by default equal to zero
  710.                     double clockConstraint = 0.0;
  711.                     if (scanner.hasNextDouble()) {
  712.                         clockConstraint = scanner.nextDouble();
  713.                     }

  715.                     // Add reference clock to current reference clock list
  716.                     final ReferenceClock referenceClock = new ReferenceClock(referenceName, clockID, clockConstraint,
  717.                                                                              pi.referenceClockStartDate, pi.referenceClockEndDate);
  718.                     pi.currentReferenceClocks.add(referenceClock);

  720.                     // Modify time span map of the reference clocks to accept the new reference clock
  721.                     pi.file.addReferenceClockList(pi.currentReferenceClocks, pi.referenceClockStartDate);
  722.                 }
  723.             }

  725.         },

  727.         /** Parser for the number of stations embedded in the file and the related frame. */
  728.         HEADER_NUMBER_OF_SOLN_STATIONS("^.+SOLN STA / TRF( )*$") {

  730.             /** {@inheritDoc} */
  731.             @Override
  732.             public void parse(final String line, final ParseInfo pi) {
  733.                 try (Scanner s1      = new Scanner(line);
  734.                      Scanner s2      = s1.useDelimiter(SPACES);
  735.                      Scanner scanner = s2.useLocale(Locale.US)) {

  737.                     // First element is the number of receivers embedded in the file
  738.                     scanner.nextInt();

  740.                     // Second element is the frame linked to given receiver positions
  741.                     final String frameString = scanner.next();
  742.                     pi.file.setFrameName(frameString);
  743.                 }
  744.             }

  746.         },

  748.         /** Parser for the stations embedded in the file and the related positions. */
  749.         HEADER_SOLN_STATIONS("^.+SOLN STA NAME / NUM( )*$") {

  751.             /** {@inheritDoc} */
  752.             @Override
  753.             public void parse(final String line, final ParseInfo pi) {

  755.                 // First element is the receiver designator
  756.                 String designator = line.substring(0, 10).trim();

  758.                 // Second element is the receiver identifier
  759.                 String receiverIdentifier = line.substring(10, 30).trim();

  761.                 // Third element if X coordinates, in millimeters in the file frame.
  762.                 String xString = "";

  764.                 // Fourth element if Y coordinates, in millimeters in the file frame.
  765.                 String yString = "";

  767.                 // Fifth element if Z coordinates, in millimeters in the file frame.
  768.                 String zString = "";

  770.                 if (pi.file.getFormatVersion() < 3.04) {
  771.                     designator = line.substring(0, 4).trim();
  772.                     receiverIdentifier = line.substring(5, 25).trim();
  773.                     xString = line.substring(25, 36).trim();
  774.                     yString = line.substring(37, 48).trim();
  775.                     zString = line.substring(49, 60).trim();
  776.                 } else {
  777.                     designator = line.substring(0, 10).trim();
  778.                     receiverIdentifier = line.substring(10, 30).trim();
  779.                     xString = line.substring(30, 41).trim();
  780.                     yString = line.substring(42, 53).trim();
  781.                     zString = line.substring(54, 65).trim();
  782.                 }

  784.                 final double x = MILLIMETER * Double.parseDouble(xString);
  785.                 final double y = MILLIMETER * Double.parseDouble(yString);
  786.                 final double z = MILLIMETER * Double.parseDouble(zString);

  788.                 final Receiver receiver = new Receiver(designator, receiverIdentifier, x, y, z);
  789.                 pi.file.addReceiver(receiver);

  791.             }

  793.         },

  795.         /** Parser for the number of satellites embedded in the file. */
  796.         HEADER_NUMBER_OF_SOLN_SATS("^.+# OF SOLN SATS( )*$") {

  798.             /** {@inheritDoc} */
  799.             @Override
  800.             public void parse(final String line, final ParseInfo pi) {

  802.                     // Only element in the line is number of satellites, not used here.
  803.                     // Do nothing...
  804.             }

  806.         },

  808.         /** Parser for the satellites embedded in the file. */
  809.         HEADER_PRN_LIST("^.+PRN LIST( )*$") {

  811.             /** {@inheritDoc} */
  812.             @Override
  813.             public void parse(final String line, final ParseInfo pi) {
  814.                 try (Scanner s1      = new Scanner(line);
  815.                      Scanner s2      = s1.useDelimiter(SPACES);
  816.                      Scanner scanner = s2.useLocale(Locale.US)) {

  818.                     // Only PRN numbers are stored in these lines
  819.                     // Initialize first PRN number
  820.                     String prn = scanner.next();

  822.                     // Browse the line until its end
  823.                     while (!prn.equals("PRN")) {
  824.                         pi.file.addSatellite(prn);
  825.                         prn = scanner.next();
  826.                     }
  827.                 }
  828.             }

  830.         },

  832.         /** Parser for the end of header. */
  833.         HEADER_END("^.+END OF HEADER( )*$") {

  835.             /** {@inheritDoc} */
  836.             @Override
  837.             public void parse(final String line, final ParseInfo pi) {
  838.                 // do nothing...
  839.             }

  841.             /** {@inheritDoc} */
  842.             @Override
  843.             public Iterable<LineParser> allowedNext() {
  844.                 return Collections.singleton(CLOCK_DATA);
  845.             }
  846.         },

  848.         /** Parser for a clock data line. */
  849.         CLOCK_DATA("(^AR |^AS |^CR |^DR |^MS ).+$") {

  851.             /** {@inheritDoc} */
  852.             @Override
  853.             public void parse(final String line, final ParseInfo pi) {
  854.                 try (Scanner s1      = new Scanner(line);
  855.                      Scanner s2      = s1.useDelimiter(SPACES);
  856.                      Scanner scanner = s2.useLocale(Locale.US)) {

  858.                     // Initialise current values
  859.                     pi.currentDataValues = new double[6];

  861.                     // First element is clock data type
  862.                     pi.currentDataType = ClockDataType.parseClockDataType(scanner.next());

  864.                     // Second element is receiver/satellite name
  865.                     pi.currentName = scanner.next();

  867.                     // Third element is data epoch
  868.                     final int year   = scanner.nextInt();
  869.                     final int month  = scanner.nextInt();
  870.                     final int day    = scanner.nextInt();
  871.                     final int hour   = scanner.nextInt();
  872.                     final int min    = scanner.nextInt();
  873.                     final double sec = scanner.nextDouble();
  874.                     pi.currentDateComponents = new DateComponents(year, month, day);
  875.                     pi.currentTimeComponents = new TimeComponents(hour, min, sec);

  877.                     // Fourth element is number of data values
  878.                     pi.currentNumberOfValues = scanner.nextInt();

  880.                     // Get the values in this line, there are at most 2.
  881.                     // Some entries claim less values than there actually are.
  882.                     // All values are added to the set, regardless of their claimed number.
  883.                     int i = 0;
  884.                     while (scanner.hasNextDouble()) {
  885.                         pi.currentDataValues[i++] = scanner.nextDouble();
  886.                     }

  888.                     // Check if continuation line is required
  889.                     if (pi.currentNumberOfValues <= 2) {
  890.                         // No continuation line is required
  891.                         pi.file.addClockData(pi.currentName, pi.file.new ClockDataLine(pi.currentDataType,
  892.                                                                                        pi.currentName,
  893.                                                                                        pi.currentDateComponents,
  894.                                                                                        pi.currentTimeComponents,
  895.                                                                                        pi.currentNumberOfValues,
  896.                                                                                        pi.currentDataValues[0],
  897.                                                                                        pi.currentDataValues[1],
  898.                                                                                        0.0, 0.0, 0.0, 0.0));
  899.                     }
  900.                 }
  901.             }

  903.             /** {@inheritDoc} */
  904.             @Override
  905.             public Iterable<LineParser> allowedNext() {
  906.                 return Arrays.asList(CLOCK_DATA, CLOCK_DATA_CONTINUATION);
  907.             }
  908.         },

  910.         /** Parser for a continuation clock data line. */
  911.         CLOCK_DATA_CONTINUATION("^   .+") {

  913.             /** {@inheritDoc} */
  914.             @Override
  915.             public void parse(final String line, final ParseInfo pi) {
  916.                 try (Scanner s1      = new Scanner(line);
  917.                      Scanner s2      = s1.useDelimiter(SPACES);
  918.                      Scanner scanner = s2.useLocale(Locale.US)) {

  920.                     // Get the values in this continuation line.
  921.                     // Some entries claim less values than there actually are.
  922.                     // All values are added to the set, regardless of their claimed number.
  923.                     int i = 2;
  924.                     while (scanner.hasNextDouble()) {
  925.                         pi.currentDataValues[i++] = scanner.nextDouble();
  926.                     }

  928.                     // Add clock data line
  929.                     pi.file.addClockData(pi.currentName, pi.file.new ClockDataLine(pi.currentDataType,
  930.                                                                                    pi.currentName,
  931.                                                                                    pi.currentDateComponents,
  932.                                                                                    pi.currentTimeComponents,
  933.                                                                                    pi.currentNumberOfValues,
  934.                                                                                    pi.currentDataValues[0],
  935.                                                                                    pi.currentDataValues[1],
  936.                                                                                    pi.currentDataValues[2],
  937.                                                                                    pi.currentDataValues[3],
  938.                                                                                    pi.currentDataValues[4],
  939.                                                                                    pi.currentDataValues[5]));

  941.                 }
  942.             }

  944.             /** {@inheritDoc} */
  945.             @Override
  946.             public Iterable<LineParser> allowedNext() {
  947.                 return Collections.singleton(CLOCK_DATA);
  948.             }
  949.         };

  951.         /** Pattern for identifying line. */
  952.         private final Pattern pattern;

  954.         /** Simple constructor.
  955.          * @param lineRegexp regular expression for identifying line
  956.          */
  957.         LineParser(final String lineRegexp) {
  958.             pattern = Pattern.compile(lineRegexp);
  959.         }

  961.         /** Parse a line.
  962.          * @param line line to parse
  963.          * @param pi holder for transient data
  964.          */
  965.         public abstract void parse(String line, ParseInfo pi);

  967.         /** Get the allowed parsers for next line.
  968.          * <p>
  969.          * Because the standard only recommends an order for header keys,
  970.          * the default implementation of the method returns all the
  971.          * header keys. Specific implementations must overrides the method.
  972.          * </p>
  973.          * @return allowed parsers for next line
  974.          */
  975.         public Iterable<LineParser> allowedNext() {
  976.             return Arrays.asList(HEADER_PROGRAM, HEADER_COMMENT, HEADER_SYSTEM_OBS, HEADER_SYSTEM_OBS_CONTINUATION, HEADER_TIME_SYSTEM, HEADER_LEAP_SECONDS,
  977.                                  HEADER_LEAP_SECONDS_GNSS, HEADER_DCBS, HEADER_PCVS, HEADER_TYPES_OF_DATA, HEADER_STATIONS_NAME, HEADER_STATION_CLOCK_REF,
  978.                                  HEADER_ANALYSIS_CENTER, HEADER_NUMBER_OF_CLOCK_REF, HEADER_ANALYSIS_CLOCK_REF, HEADER_NUMBER_OF_SOLN_STATIONS,
  979.                                  HEADER_SOLN_STATIONS, HEADER_NUMBER_OF_SOLN_SATS, HEADER_PRN_LIST, HEADER_END);
  980.         }

  982.         /** Check if parser can handle line.
  983.          * @param line line to parse
  984.          * @return true if parser can handle the specified line
  985.          */
  986.         public boolean canHandle(final String line) {
  987.             return pattern.matcher(line).matches();
  988.         }

  990.         /** Parse existing date - time - zone formats.
  991.          * If zone field is not missing, a proper Orekit date can be created and set into clock file object.
  992.          * This feature depends on the date format.
  993.          * @param dateString the whole date - time - zone string
  994.          * @param pi holder for transient data
  995.          */
  996.         private static void parseDateTimeZone(final String dateString, final ParseInfo pi) {

  998.             String date = "";
  999.             String time = "";
  1000.             String zone = "";
  1001.             DateComponents dateComponents = null;
  1002.             TimeComponents timeComponents = null;

  1004.             if (DATE_PATTERN_1.matcher(dateString).matches()) {

  1006.                 date = dateString.substring(0, 10).trim();
  1007.                 time = dateString.substring(11, 16).trim();
  1008.                 zone = dateString.substring(16).trim();

  1010.             } else if (DATE_PATTERN_2.matcher(dateString).matches()) {

  1012.                 date = dateString.substring(0, 8).trim();
  1013.                 time = dateString.substring(9, 16).trim();
  1014.                 zone = dateString.substring(16).trim();

  1016.                 if (!zone.equals("")) {
  1017.                     // Get date and time components
  1018.                     dateComponents = new DateComponents(Integer.parseInt(date.substring(0, 4)),
  1019.                                                         Integer.parseInt(date.substring(4, 6)),
  1020.                                                         Integer.parseInt(date.substring(6, 8)));
  1021.                     timeComponents = new TimeComponents(Integer.parseInt(time.substring(0, 2)),
  1022.                                                         Integer.parseInt(time.substring(2, 4)),
  1023.                                                         Integer.parseInt(time.substring(4, 6)));

  1025.                 }

  1027.             } else if (DATE_PATTERN_3.matcher(dateString).matches()) {

  1029.                 date = dateString.substring(0, 11).trim();
  1030.                 time = dateString.substring(11, 17).trim();
  1031.                 zone = dateString.substring(17).trim();

  1033.             } else if (DATE_PATTERN_4.matcher(dateString).matches()) {

  1035.                 date = dateString.substring(0, 9).trim();
  1036.                 time = dateString.substring(9, 15).trim();
  1037.                 zone = dateString.substring(15).trim();

  1039.             } else if (DATE_PATTERN_5.matcher(dateString).matches()) {

  1041.                 date = dateString.substring(0, 11).trim();
  1042.                 time = dateString.substring(11, 20).trim();

  1044.             } else {
  1045.                 // Format is not handled or date is missing. Do nothing...
  1046.             }

  1048.             pi.file.setCreationDateString(date);
  1049.             pi.file.setCreationTimeString(time);
  1050.             pi.file.setCreationTimeZoneString(zone);

  1052.             if (dateComponents != null) {
  1053.                 pi.file.setCreationDate(new AbsoluteDate(dateComponents,
  1054.                                                          timeComponents,
  1055.                                                          TimeSystem.parseTimeSystem(zone).getTimeScale(pi.timeScales)));
  1056.             }
  1057.         }
  1058.     }

  1060. }
Created with JaCoCo 0.8.11.202310140853