RinexNavigationParser.java

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

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.Reader;
  22. import java.util.Arrays;
  23. import java.util.HashMap;
  24. import java.util.InputMismatchException;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.Optional;
  28. import java.util.regex.Pattern;
  29. import java.util.stream.Stream;

  31. import org.orekit.annotation.DefaultDataContext;
  32. import org.orekit.data.DataContext;
  33. import org.orekit.data.DataSource;
  34. import org.orekit.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;
  36. import org.orekit.gnss.SatelliteSystem;
  37. import org.orekit.gnss.TimeSystem;
  38. import org.orekit.gnss.navigation.RinexNavigation.TimeSystemCorrection;
  39. import org.orekit.propagation.analytical.gnss.data.BeidouNavigationMessage;
  40. import org.orekit.propagation.analytical.gnss.data.GLONASSNavigationMessage;
  41. import org.orekit.propagation.analytical.gnss.data.GPSNavigationMessage;
  42. import org.orekit.propagation.analytical.gnss.data.GalileoNavigationMessage;
  43. import org.orekit.propagation.analytical.gnss.data.IRNSSNavigationMessage;
  44. import org.orekit.propagation.analytical.gnss.data.QZSSNavigationMessage;
  45. import org.orekit.propagation.analytical.gnss.data.SBASNavigationMessage;
  46. import org.orekit.time.AbsoluteDate;
  47. import org.orekit.time.DateComponents;
  48. import org.orekit.time.GNSSDate;
  49. import org.orekit.time.TimeComponents;
  50. import org.orekit.time.TimeScale;
  51. import org.orekit.time.TimeScales;
  52. import org.orekit.utils.Constants;

  54. /**
  55.  * Parser for RINEX navigation messages files.
  56.  * <p>
  57.  * This parser handles RINEX version from 3.01 to 3.05. It is not adapted for RINEX 2.10 and 2.11 versions.
  58.  * </p>
  59.  * @see <a href="https://files.igs.org/pub/data/format/rinex301.pdf"> 3.01 navigation messages file format</a>
  60.  * @see <a href="https://files.igs.org/pub/data/format/rinex302.pdf"> 3.02 navigation messages file format</a>
  61.  * @see <a href="https://files.igs.org/pub/data/format/rinex303.pdf"> 3.03 navigation messages file format</a>
  62.  * @see <a href="https://files.igs.org/pub/data/format/rinex304.pdf"> 3.04 navigation messages file format</a>
  63.  * @see <a href="https://files.igs.org/pub/data/format/rinex305.pdf"> 3.05 navigation messages file format</a>
  64.  *
  65.  * @author Bryan Cazabonne
  66.  * @since 11.0
  67.  *
  68.  */
  69. public class RinexNavigationParser {

  71.     /** Handled clock file format versions. */
  72.     private static final List<Double> HANDLED_VERSIONS = Arrays.asList(3.01, 3.02, 3.03, 3.04, 3.05);

  74.     /** File Type. */
  75.     private static final String FILE_TYPE = "N";

  77.     /** Seconds to milliseconds converter. */
  78.     private static final Double SEC_TO_MILLI = 1000.0;

  80.     /** Kilometer to meters converter. */
  81.     private static final Double KM_TO_M = 1000.0;

  83.     /** Set of time scales. */
  84.     private final TimeScales timeScales;

  86.     /**
  87.      * Constructor.
  88.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.</p>
  89.      * @see #RinexNavigationParser(TimeScales)
  90.      *
  91.      */
  92.     @DefaultDataContext
  93.     public RinexNavigationParser() {
  94.         this(DataContext.getDefault().getTimeScales());
  95.     }

  97.     /**
  98.      * Constructor.
  99.      * @param timeScales the set of time scales used for parsing dates.
  100.      */
  101.     public RinexNavigationParser(final TimeScales timeScales) {
  102.         this.timeScales = timeScales;
  103.     }

  105.     /**
  106.      * Parse RINEX navigation messages.
  107.      * @param source source providing the data to parse
  108.      * @return a parsed  RINEX navigation messages file
  109.      * @throws IOException if {@code reader} throws one
  110.      */
  111.     public RinexNavigation parse(final DataSource source) throws IOException {

  113.         // initialize internal data structures
  114.         final ParseInfo pi = new ParseInfo();

  116.         int lineNumber = 0;
  117.         Stream<LineParser> candidateParsers = Stream.of(LineParser.HEADER_VERSION);
  118.         try (Reader reader = source.getOpener().openReaderOnce();
  119.              BufferedReader br = new BufferedReader(reader)) {
  120.             for (String line = br.readLine(); line != null; line = br.readLine()) {
  121.                 ++lineNumber;
  122.                 final String l = line;
  123.                 final Optional<LineParser> selected = candidateParsers.filter(p -> p.canHandle(l)).findFirst();
  124.                 if (selected.isPresent()) {
  125.                     try {
  126.                         selected.get().parse(line, pi);
  127.                     } catch (StringIndexOutOfBoundsException | NumberFormatException | InputMismatchException e) {
  128.                         throw new OrekitException(e,
  129.                                                   OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  130.                                                   lineNumber, source.getName(), line);
  131.                     }
  132.                     candidateParsers = selected.get().allowedNext();
  133.                 } else {
  134.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  135.                                               lineNumber, source.getName(), line);
  136.                 }
  137.             }
  138.         }

  140.         return pi.file;

  142.     }

  144.     /**
  145.      * Parse a double value.
  146.      * @param line line to parse
  147.      * @param startIndex start index
  148.      * @param size size of the value
  149.      * @return the parsed value
  150.      */
  151.     private static double parseDouble(final String line, final int startIndex, final int size) {
  152.         return Double.parseDouble(line.substring(startIndex, startIndex + size).replace('D', 'E').trim());
  153.     }

  155.     /**
  156.      * Parse an integer value.
  157.      * @param line line to parse
  158.      * @param startIndex start index
  159.      * @param size size of the value
  160.      * @return the parsed value
  161.      */
  162.     private static int parseInt(final String line, final int startIndex, final int size) {
  163.         return Integer.parseInt(line.substring(startIndex, startIndex + size).trim());
  164.     }

  166.     /**
  167.      * Parse a string value.
  168.      * @param line line to parse
  169.      * @param startIndex start index
  170.      * @param size size of the value
  171.      * @return the parsed value
  172.      */
  173.     private static String parseString(final String line, final int startIndex, final int size) {
  174.         return line.substring(startIndex, startIndex + size).trim();
  175.     }

  177.     /** Transient data used for parsing a RINEX navigation messages file. */
  178.     private class ParseInfo {

  180.         /** Set of time scales for parsing dates. */
  181.         private final TimeScales timeScales;

  183.         /** The corresponding navigation messages file object. */
  184.         private RinexNavigation file;

  186.         /** The version of the navigation file. */
  187.         private double version;

  189.         /** Flag indicating the distinction between "alpha" and "beta" ionospheric coefficients. */
  190.         private boolean isIonosphereAlphaInitialized;

  192.         /** Satellite system line parser. */
  193.         private SatelliteSystemLineParser systemLineParser;

  195.         /** Current line number of the navigation message. */
  196.         private int lineNumber;

  198.         /** Container for GPS navigation message. */
  199.         private GPSNavigationMessage gpsNav;

  201.         /** Container for Galileo navigation message. */
  202.         private GalileoNavigationMessage galileoNav;

  204.         /** Container for Beidou navigation message. */
  205.         private BeidouNavigationMessage beidouNav;

  207.         /** Container for QZSS navigation message. */
  208.         private QZSSNavigationMessage qzssNav;

  210.         /** Container for IRNSS navigation message. */
  211.         private IRNSSNavigationMessage irnssNav;

  213.         /** Container for GLONASS navigation message. */
  214.         private GLONASSNavigationMessage glonassNav;

  216.         /** Container for SBAS navigation message. */
  217.         private SBASNavigationMessage sbasNav;

  219.         /** Constructor, build the ParseInfo object. */
  220.         ParseInfo() {
  221.             // Initialize default values for fields
  222.             this.timeScales                   = RinexNavigationParser.this.timeScales;
  223.             this.version                      = 1.0;
  224.             this.isIonosphereAlphaInitialized = false;
  225.             this.file                         = new RinexNavigation();
  226.             this.systemLineParser             = SatelliteSystemLineParser.GPS;
  227.             this.lineNumber                   = 0;
  228.             this.gpsNav                       = new GPSNavigationMessage();
  229.             this.galileoNav                   = new GalileoNavigationMessage();
  230.             this.beidouNav                    = new BeidouNavigationMessage();
  231.             this.qzssNav                      = new QZSSNavigationMessage();
  232.             this.irnssNav                     = new IRNSSNavigationMessage();
  233.             this.glonassNav                   = new GLONASSNavigationMessage();
  234.             this.sbasNav                      = new SBASNavigationMessage();
  235.         }

  237.     }

  239.     /** Parsers for specific lines. */
  240.     private enum LineParser {

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

  245.             /** {@inheritDoc} */
  246.             @Override
  247.             public void parse(final String line, final ParseInfo pi) {

  249.                 // Rinex version
  250.                 pi.version = parseDouble(line, 0, 9);

  252.                 // Throw exception if format version is not handled
  253.                 if (!HANDLED_VERSIONS.contains(pi.version)) {
  254.                     throw new OrekitException(OrekitMessages.NAVIGATION_FILE_UNSUPPORTED_VERSION, pi.version);
  255.                 }
  256.                 pi.file.setFormatVersion(pi.version);

  258.                 // File type
  259.                 pi.file.setFileType(FILE_TYPE);

  261.                 // Satellite system
  262.                 final SatelliteSystem system = SatelliteSystem.parseSatelliteSystem(parseString(line, 40, 1));
  263.                 pi.file.setSatelliteSystem(system);

  265.             }

  267.             /** {@inheritDoc} */
  268.             @Override
  269.             public Stream<LineParser> allowedNext() {
  270.                 return Stream.of(HEADER_PROGRAM);
  271.             }

  273.         },

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

  278.             /** {@inheritDoc} */
  279.             @Override
  280.             public void parse(final String line, final ParseInfo pi) {

  282.                 // Name of the generating program
  283.                 final String programName = parseString(line, 0, 20);
  284.                 pi.file.setProgramName(programName);

  286.                 // Name of the emiting agency
  287.                 final String agencyName = parseString(line, 20, 20);
  288.                 pi.file.setAgencyName(agencyName);

  290.                 // Date and time of file creation
  291.                 final String date     = parseString(line, 40, 8);
  292.                 final String time     = parseString(line, 49, 6);
  293.                 final String timeZone = parseString(line, 56, 4);
  294.                 pi.file.setCreationDateString(date);
  295.                 pi.file.setCreationTimeString(time);
  296.                 pi.file.setCreationTimeZoneString(timeZone);

  298.                 // Convert date and time to an Orekit absolute date
  299.                 final DateComponents dateComponents = new DateComponents(parseInt(date, 0, 4),
  300.                                                                          parseInt(date, 4, 2),
  301.                                                                          parseInt(date, 6, 2));
  302.                 final TimeComponents timeComponents = new TimeComponents(parseInt(time, 0, 2),
  303.                                                                          parseInt(time, 2, 2),
  304.                                                                          parseInt(time, 4, 2));
  305.                 pi.file.setCreationDate(new AbsoluteDate(dateComponents,
  306.                                                          timeComponents,
  307.                                                          TimeSystem.parseTimeSystem(timeZone).getTimeScale(pi.timeScales)));

  309.             }

  311.             /** {@inheritDoc} */
  312.             @Override
  313.             public Stream<LineParser> allowedNext() {
  314.                 return Stream.of(HEADER_COMMENT, HEADER_IONOSPHERIC, HEADER_TIME, HEADER_LEAP_SECONDS, HEADER_END);
  315.             }

  317.         },

  319.         /** Parser for comments. */
  320.         HEADER_COMMENT("^.+COMMENT( )*$") {

  322.             /** {@inheritDoc} */
  323.             @Override
  324.             public void parse(final String line, final ParseInfo pi) {
  325.                 pi.file.addComment(parseString(line, 0, 60));
  326.             }

  328.             /** {@inheritDoc} */
  329.             @Override
  330.             public Stream<LineParser> allowedNext() {
  331.                 return Stream.of(HEADER_COMMENT, HEADER_IONOSPHERIC, HEADER_TIME, HEADER_LEAP_SECONDS, HEADER_END);
  332.             }

  334.         },

  336.         /** Parser for ionospheric correction parameters. */
  337.         HEADER_IONOSPHERIC("^.+IONOSPHERIC CORR( )*$") {

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

  343.                 // Satellite system
  344.                 final String ionoType = parseString(line, 0, 3);
  345.                 pi.file.setIonosphericCorrectionType(ionoType);

  347.                 // Read coefficients
  348.                 final double[] parameters = new double[4];
  349.                 parameters[0] = parseDouble(line, 5,  12);
  350.                 parameters[1] = parseDouble(line, 17, 12);
  351.                 parameters[2] = parseDouble(line, 29, 12);
  352.                 parameters[3] = parseDouble(line, 41, 12);

  354.                 // Verify if we are parsing Galileo ionospheric parameters
  355.                 if ("GAL".equals(ionoType)) {

  357.                     // We are parsing Galileo ionospheric parameters
  358.                     pi.file.setNeQuickAlpha(parameters);

  360.                 } else {
  361.                     // We are parsing Klobuchar ionospheric parameters

  363.                     // Verify if we are parsing "alpha" or "beta" ionospheric parameters
  364.                     if (pi.isIonosphereAlphaInitialized) {

  366.                         // Ionospheric "beta" parameters
  367.                         pi.file.setKlobucharBeta(parameters);

  369.                     } else {

  371.                         // Ionospheric "alpha" parameters
  372.                         pi.file.setKlobucharAlpha(parameters);

  374.                         // Set the flag to true
  375.                         pi.isIonosphereAlphaInitialized = true;

  377.                     }

  379.                 }

  381.             }

  383.             /** {@inheritDoc} */
  384.             @Override
  385.             public Stream<LineParser> allowedNext() {
  386.                 return Stream.of(HEADER_COMMENT, HEADER_IONOSPHERIC, HEADER_TIME, HEADER_LEAP_SECONDS, HEADER_END);
  387.             }

  389.         },

  391.         /** Parser for corrections to transform the system time to UTC or to other time systems. */
  392.         HEADER_TIME("^.+TIME SYSTEM CORR( )*$") {

  394.             /** {@inheritDoc} */
  395.             @Override
  396.             public void parse(final String line, final ParseInfo pi) {

  398.                 // Read fields
  399.                 final String type    = parseString(line, 0,  4);
  400.                 final double a0      = parseDouble(line, 5,  17);
  401.                 final double a1      = parseDouble(line, 22, 16);
  402.                 final int    refTime = parseInt(line, 38, 7);
  403.                 final int    refWeek = parseInt(line, 46, 5);

  405.                 // Add to the list
  406.                 final TimeSystemCorrection tsc = new TimeSystemCorrection(type, a0, a1, refTime, refWeek);
  407.                 pi.file.addTimeSystemCorrections(tsc);

  409.             }

  411.             /** {@inheritDoc} */
  412.             @Override
  413.             public Stream<LineParser> allowedNext() {
  414.                 return Stream.of(HEADER_COMMENT, HEADER_TIME, HEADER_LEAP_SECONDS, HEADER_END);
  415.             }

  417.         },

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

  422.             /** {@inheritDoc} */
  423.             @Override
  424.             public void parse(final String line, final ParseInfo pi) {
  425.                 // Current number of leap seconds
  426.                 pi.file.setNumberOfLeapSeconds(parseInt(line, 0, 6));
  427.             }

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

  435.         },

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

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

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

  452.         },

  454.         /** Parser for navigation message first data line. */
  455.         NAVIGATION_MESSAGE_FIRST("(^G|^R|^E|^C|^I|^J|^S).+$") {

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

  461.                 // Set the line number to 0
  462.                 pi.lineNumber = 0;

  464.                 // Current satellite system
  465.                 final String key = parseString(line, 0, 1);

  467.                 // Initialize parser
  468.                 pi.systemLineParser = SatelliteSystemLineParser.getSatelliteSystemLineParser(key);

  470.                 // Read first line
  471.                 pi.systemLineParser.parseFirstLine(line, pi);

  473.             }

  475.             /** {@inheritDoc} */
  476.             @Override
  477.             public Stream<LineParser> allowedNext() {
  478.                 return Stream.of(NAVIGATION_BROADCAST_ORBIT);
  479.             }

  481.         },

  483.         /** Parser for broadcast orbit. */
  484.         NAVIGATION_BROADCAST_ORBIT("^    .+") {

  486.             /** {@inheritDoc} */
  487.             @Override
  488.             public void parse(final String line, final ParseInfo pi) {

  490.                 // Increment the line number
  491.                 pi.lineNumber++;

  493.                 // Read the corresponding line
  494.                 if (pi.lineNumber == 1) {
  495.                     // BROADCAST ORBIT – 1
  496.                     pi.systemLineParser.parseFirstBroadcastOrbit(line, pi);
  497.                 } else if (pi.lineNumber == 2) {
  498.                     // BROADCAST ORBIT – 2
  499.                     pi.systemLineParser.parseSecondBroadcastOrbit(line, pi);
  500.                 } else if (pi.lineNumber == 3) {
  501.                     // BROADCAST ORBIT – 3
  502.                     pi.systemLineParser.parseThirdBroadcastOrbit(line, pi);
  503.                 } else if (pi.lineNumber == 4) {
  504.                     // BROADCAST ORBIT – 4
  505.                     pi.systemLineParser.parseFourthBroadcastOrbit(line, pi);
  506.                 } else if (pi.lineNumber == 5) {
  507.                     // BROADCAST ORBIT – 5
  508.                     pi.systemLineParser.parseFifthBroadcastOrbit(line, pi);
  509.                 } else if (pi.lineNumber == 6) {
  510.                     // BROADCAST ORBIT – 6
  511.                     pi.systemLineParser.parseSixthBroadcastOrbit(line, pi);
  512.                 } else {
  513.                     // BROADCAST ORBIT – 7
  514.                     pi.systemLineParser.parseSeventhBroadcastOrbit(line, pi);
  515.                 }

  517.             }

  519.             /** {@inheritDoc} */
  520.             @Override
  521.             public Stream<LineParser> allowedNext() {
  522.                 return Stream.of(NAVIGATION_MESSAGE_FIRST, NAVIGATION_BROADCAST_ORBIT);
  523.             }

  525.         };

  527.         /** Pattern for identifying line. */
  528.         private final Pattern pattern;

  530.         /** Simple constructor.
  531.          * @param lineRegexp regular expression for identifying line
  532.          */
  533.         LineParser(final String lineRegexp) {
  534.             pattern = Pattern.compile(lineRegexp);
  535.         }

  537.         /** Parse a line.
  538.          * @param line line to parse
  539.          * @param pi holder for transient data
  540.          */
  541.         public abstract void parse(String line, ParseInfo pi);

  543.         /** Get the allowed parsers for next line.
  544.          * @return allowed parsers for next line
  545.          */
  546.         public abstract Stream<LineParser> allowedNext();

  548.         /** Check if parser can handle line.
  549.          * @param line line to parse
  550.          * @return true if parser can handle the specified line
  551.          */
  552.         public boolean canHandle(final String line) {
  553.             return pattern.matcher(line).matches();
  554.         }

  556.     }

  558.     /** Parsers for satellite system specific lines. */
  559.     private enum SatelliteSystemLineParser {

  561.         /** GPS. */
  562.         GPS("G") {

  564.             /** {@inheritDoc} */
  565.             @Override
  566.             public void parseFirstLine(final String line, final ParseInfo pi) {
  567.                 // PRN
  568.                 pi.gpsNav.setPRN(parseInt(line, 1, 2));

  570.                 // Toc
  571.                 final int gpsTocYear  = parseInt(line, 4, 4);
  572.                 final int gpsTocMonth = parseInt(line, 9, 2);
  573.                 final int gpsTocDay   = parseInt(line, 12, 2);
  574.                 final int gpsTocHours = parseInt(line, 15, 2);
  575.                 final int gpsTocMin   = parseInt(line, 18, 2);
  576.                 final int gpsTocSec   = parseInt(line, 21, 2);
  577.                 pi.gpsNav.setEpochToc(new AbsoluteDate(gpsTocYear, gpsTocMonth, gpsTocDay, gpsTocHours,
  578.                                                        gpsTocMin, gpsTocSec, pi.timeScales.getGPS()));

  580.                 // Af0, Af1, and Af2
  581.                 pi.gpsNav.setAf0(parseDouble(line, 23, 19));
  582.                 pi.gpsNav.setAf1(parseDouble(line, 42, 19));
  583.                 pi.gpsNav.setAf2(parseDouble(line, 61, 19));
  584.             }

  586.             /** {@inheritDoc} */
  587.             @Override
  588.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  589.                 // IODE
  590.                 pi.gpsNav.setIODE(parseDouble(line, 4, 19));
  591.                 // Crs
  592.                 pi.gpsNav.setCrs(parseDouble(line, 23, 19));
  593.                 // Delta n
  594.                 pi.gpsNav.setDeltaN(parseDouble(line, 42, 19));
  595.                 // M0
  596.                 pi.gpsNav.setM0(parseDouble(line, 61, 19));
  597.             }

  599.             /** {@inheritDoc} */
  600.             @Override
  601.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  602.                 // Cuc
  603.                 pi.gpsNav.setCuc(parseDouble(line, 4, 19));
  604.                 // e
  605.                 pi.gpsNav.setE(parseDouble(line, 23, 19));
  606.                 // Cus
  607.                 pi.gpsNav.setCus(parseDouble(line, 42, 19));
  608.                 // sqrt(A)
  609.                 pi.gpsNav.setSqrtA(parseDouble(line, 61, 19));
  610.             }

  612.             /** {@inheritDoc} */
  613.             @Override
  614.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  615.                 // Toe
  616.                 pi.gpsNav.setTime(parseDouble(line, 4, 19));
  617.                 // Cic
  618.                 pi.gpsNav.setCic(parseDouble(line, 23, 19));
  619.                 // Omega0
  620.                 pi.gpsNav.setOmega0(parseDouble(line, 42, 19));
  621.                 // Cis
  622.                 pi.gpsNav.setCis(parseDouble(line, 61, 19));
  623.             }

  625.             /** {@inheritDoc} */
  626.             @Override
  627.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  628.                 // i0
  629.                 pi.gpsNav.setI0(parseDouble(line, 4, 19));
  630.                 // Crc
  631.                 pi.gpsNav.setCrc(parseDouble(line, 23, 19));
  632.                 // omega
  633.                 pi.gpsNav.setPa(parseDouble(line, 42, 19));
  634.                 // OMEGA DOT
  635.                 pi.gpsNav.setOmegaDot(parseDouble(line, 61, 19));
  636.             }

  638.             /** {@inheritDoc} */
  639.             @Override
  640.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  641.                 // iDot
  642.                 pi.gpsNav.setIDot(parseDouble(line, 4, 19));
  643.                 // Codes on L2 channel (ignored)
  644.                 // parseDouble(line, 23, 19)
  645.                 // GPS week (to go with Toe)
  646.                 pi.gpsNav.setWeek((int) parseDouble(line, 42, 19));
  647.                 pi.gpsNav.setDate(new GNSSDate(pi.gpsNav.getWeek(),
  648.                                                SEC_TO_MILLI * pi.gpsNav.getTime(),
  649.                                                SatelliteSystem.GPS,
  650.                                                pi.timeScales).getDate());
  651.             }

  653.             /** {@inheritDoc} */
  654.             @Override
  655.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  656.                 // SV accuracy
  657.                 pi.gpsNav.setSvAccuracy(parseDouble(line, 4, 19));
  658.                 // Health
  659.                 pi.gpsNav.setSvHealth(parseDouble(line, 23, 19));
  660.                 // TGD
  661.                 pi.gpsNav.setTGD(parseDouble(line, 42, 19));
  662.                 // IODC
  663.                 pi.gpsNav.setIODC(parseDouble(line, 61, 19));
  664.             }

  666.             /** {@inheritDoc} */
  667.             @Override
  668.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  669.                 // Add the navigation message to the file
  670.                 pi.file.addGPSNavigationMessage(pi.gpsNav);
  671.                 // Reinitialized the container for navigation data
  672.                 pi.gpsNav = new GPSNavigationMessage();
  673.             }

  675.         },

  677.         /** Galileo. */
  678.         GALILEO("E") {

  680.             /** {@inheritDoc} */
  681.             @Override
  682.             public void parseFirstLine(final String line, final ParseInfo pi) {
  683.                 // PRN
  684.                 pi.galileoNav.setPRN(parseInt(line, 1, 2));

  686.                 // Toc
  687.                 final int galileoTocYear  = parseInt(line, 4, 4);
  688.                 final int galileoTocMonth = parseInt(line, 9, 2);
  689.                 final int galileoTocDay   = parseInt(line, 12, 2);
  690.                 final int galileoTocHours = parseInt(line, 15, 2);
  691.                 final int galileoTocMin   = parseInt(line, 18, 2);
  692.                 final int galileoTocSec   = parseInt(line, 21, 2);
  693.                 pi.galileoNav.setEpochToc(new AbsoluteDate(galileoTocYear, galileoTocMonth, galileoTocDay, galileoTocHours,
  694.                                                        galileoTocMin, galileoTocSec, pi.timeScales.getGST()));

  696.                 // Af0, Af1, and Af2
  697.                 pi.galileoNav.setAf0(parseDouble(line, 23, 19));
  698.                 pi.galileoNav.setAf1(parseDouble(line, 42, 19));
  699.                 pi.galileoNav.setAf2(parseDouble(line, 61, 19));
  700.             }

  702.             /** {@inheritDoc} */
  703.             @Override
  704.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  705.                 // IODNav
  706.                 pi.galileoNav.setIODNav(parseDouble(line, 4, 19));
  707.                 // Crs
  708.                 pi.galileoNav.setCrs(parseDouble(line, 23, 19));
  709.                 // Delta n
  710.                 pi.galileoNav.setDeltaN(parseDouble(line, 42, 19));
  711.                 // M0
  712.                 pi.galileoNav.setM0(parseDouble(line, 61, 19));
  713.             }

  715.             /** {@inheritDoc} */
  716.             @Override
  717.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  718.                 // Cuc
  719.                 pi.galileoNav.setCuc(parseDouble(line, 4, 19));
  720.                 // e
  721.                 pi.galileoNav.setE(parseDouble(line, 23, 19));
  722.                 // Cus
  723.                 pi.galileoNav.setCus(parseDouble(line, 42, 19));
  724.                 // sqrt(A)
  725.                 pi.galileoNav.setSqrtA(parseDouble(line, 61, 19));
  726.             }

  728.             /** {@inheritDoc} */
  729.             @Override
  730.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  731.                 // Toe
  732.                 pi.galileoNav.setTime(parseDouble(line, 4, 19));
  733.                 // Cic
  734.                 pi.galileoNav.setCic(parseDouble(line, 23, 19));
  735.                 // Omega0
  736.                 pi.galileoNav.setOmega0(parseDouble(line, 42, 19));
  737.                 // Cis
  738.                 pi.galileoNav.setCis(parseDouble(line, 61, 19));
  739.             }

  741.             /** {@inheritDoc} */
  742.             @Override
  743.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  744.                 // i0
  745.                 pi.galileoNav.setI0(parseDouble(line, 4, 19));
  746.                 // Crc
  747.                 pi.galileoNav.setCrc(parseDouble(line, 23, 19));
  748.                 // omega
  749.                 pi.galileoNav.setPa(parseDouble(line, 42, 19));
  750.                 // OMEGA DOT
  751.                 pi.galileoNav.setOmegaDot(parseDouble(line, 61, 19));
  752.             }

  754.             /** {@inheritDoc} */
  755.             @Override
  756.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  757.                 // iDot
  758.                 pi.galileoNav.setIDot(parseDouble(line, 4, 19));
  759.                 // Data sources (ignored)
  760.                 // parseDouble(line, 23, 19)
  761.                 // GAL week (to go with Toe)
  762.                 pi.galileoNav.setWeek((int) parseDouble(line, 42, 19));
  763.                 pi.galileoNav.setDate(new GNSSDate(pi.galileoNav.getWeek(),
  764.                                                    SEC_TO_MILLI * pi.galileoNav.getTime(),
  765.                                                    SatelliteSystem.GPS, // in Rinex files, week number is aligned to GPS week!
  766.                                                    pi.timeScales).getDate());
  767.             }

  769.             /** {@inheritDoc} */
  770.             @Override
  771.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  772.                 // SISA
  773.                 pi.galileoNav.setSisa(parseDouble(line, 4, 19));
  774.                 // Health
  775.                 pi.galileoNav.setSvHealth(parseDouble(line, 23, 19));
  776.                 // E5a/E1 BGD
  777.                 pi.galileoNav.setBGDE1E5a(parseDouble(line, 42, 19));
  778.                 // E5b/E1 BGD
  779.                 pi.galileoNav.setBGDE5bE1(parseDouble(line, 61, 19));
  780.             }

  782.             /** {@inheritDoc} */
  783.             @Override
  784.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  785.                 // Add the navigation message to the file
  786.                 pi.file.addGalileoNavigationMessage(pi.galileoNav);
  787.                 // Reinitialized the container for navigation data
  788.                 pi.galileoNav = new GalileoNavigationMessage();
  789.             }

  791.         },

  793.         /** Beidou. */
  794.         BEIDOU("C") {

  796.             /** {@inheritDoc} */
  797.             @Override
  798.             public void parseFirstLine(final String line, final ParseInfo pi) {
  799.                 // PRN
  800.                 pi.beidouNav.setPRN(parseInt(line, 1, 2));

  802.                 // Toc
  803.                 final int beidouTocYear  = parseInt(line, 4, 4);
  804.                 final int beidouTocMonth = parseInt(line, 9, 2);
  805.                 final int beidouTocDay   = parseInt(line, 12, 2);
  806.                 final int beidouTocHours = parseInt(line, 15, 2);
  807.                 final int beidouTocMin   = parseInt(line, 18, 2);
  808.                 final int beidouTocSec   = parseInt(line, 21, 2);
  809.                 pi.beidouNav.setEpochToc(new AbsoluteDate(beidouTocYear, beidouTocMonth, beidouTocDay, beidouTocHours,
  810.                                                        beidouTocMin, beidouTocSec, pi.timeScales.getBDT()));

  812.                 // Af0, Af1, and Af2
  813.                 pi.beidouNav.setAf0(parseDouble(line, 23, 19));
  814.                 pi.beidouNav.setAf1(parseDouble(line, 42, 19));
  815.                 pi.beidouNav.setAf2(parseDouble(line, 61, 19));
  816.             }

  818.             /** {@inheritDoc} */
  819.             @Override
  820.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  821.                 // AODE
  822.                 pi.beidouNav.setAODE(parseDouble(line, 4, 19));
  823.                 // Crs
  824.                 pi.beidouNav.setCrs(parseDouble(line, 23, 19));
  825.                 // Delta n
  826.                 pi.beidouNav.setDeltaN(parseDouble(line, 42, 19));
  827.                 // M0
  828.                 pi.beidouNav.setM0(parseDouble(line, 61, 19));
  829.             }

  831.             /** {@inheritDoc} */
  832.             @Override
  833.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  834.                 // Cuc
  835.                 pi.beidouNav.setCuc(parseDouble(line, 4, 19));
  836.                 // e
  837.                 pi.beidouNav.setE(parseDouble(line, 23, 19));
  838.                 // Cus
  839.                 pi.beidouNav.setCus(parseDouble(line, 42, 19));
  840.                 // sqrt(A)
  841.                 pi.beidouNav.setSqrtA(parseDouble(line, 61, 19));
  842.             }

  844.             /** {@inheritDoc} */
  845.             @Override
  846.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  847.                 // Toe
  848.                 pi.beidouNav.setTime(parseDouble(line, 4, 19));
  849.                 // Cic
  850.                 pi.beidouNav.setCic(parseDouble(line, 23, 19));
  851.                 // Omega0
  852.                 pi.beidouNav.setOmega0(parseDouble(line, 42, 19));
  853.                 // Cis
  854.                 pi.beidouNav.setCis(parseDouble(line, 61, 19));
  855.             }

  857.             /** {@inheritDoc} */
  858.             @Override
  859.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  860.                 // i0
  861.                 pi.beidouNav.setI0(parseDouble(line, 4, 19));
  862.                 // Crc
  863.                 pi.beidouNav.setCrc(parseDouble(line, 23, 19));
  864.                 // omega
  865.                 pi.beidouNav.setPa(parseDouble(line, 42, 19));
  866.                 // OMEGA DOT
  867.                 pi.beidouNav.setOmegaDot(parseDouble(line, 61, 19));
  868.             }

  870.             /** {@inheritDoc} */
  871.             @Override
  872.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  873.                 // iDot
  874.                 pi.beidouNav.setIDot(parseDouble(line, 4, 19));
  875.                 // BDT week (to go with Toe)
  876.                 pi.beidouNav.setWeek((int) parseDouble(line, 42, 19));
  877.                 pi.beidouNav.setDate(new GNSSDate(pi.beidouNav.getWeek(),
  878.                                                   SEC_TO_MILLI * pi.beidouNav.getTime(),
  879.                                                   SatelliteSystem.BEIDOU,
  880.                                                   pi.timeScales).getDate());
  881.             }

  883.             /** {@inheritDoc} */
  884.             @Override
  885.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  886.                 // SV accuracy
  887.                 pi.beidouNav.setSvAccuracy(parseDouble(line, 4, 19));
  888.                 // SatH1 (ignored)
  889.                 // parseDouble(line, 23, 19)
  890.                 // TGD1
  891.                 pi.beidouNav.setTGD1(parseDouble(line, 42, 19));
  892.                 // TGD2
  893.                 pi.beidouNav.setTGD2(parseDouble(line, 61, 19));
  894.             }

  896.             /** {@inheritDoc} */
  897.             @Override
  898.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  899.                 // Transmission time of message (ignored)
  900.                 // parseDouble(line, 4, 19);
  901.                 // AODC
  902.                 pi.beidouNav.setAODC(parseDouble(line, 23, 19));
  903.                 // Add the navigation message to the file
  904.                 pi.file.addBeidouNavigationMessage(pi.beidouNav);
  905.                 // Reinitialized the container for navigation data
  906.                 pi.beidouNav = new BeidouNavigationMessage();

  908.             }

  910.         },

  912.         /** QZSS. */
  913.         QZSS("J") {

  915.             /** {@inheritDoc} */
  916.             @Override
  917.             public void parseFirstLine(final String line, final ParseInfo pi) {
  918.                 // PRN
  919.                 pi.qzssNav.setPRN(parseInt(line, 1, 2));

  921.                 // Toc
  922.                 final int qzssTocYear  = parseInt(line, 4, 4);
  923.                 final int qzssTocMonth = parseInt(line, 9, 2);
  924.                 final int qzssTocDay   = parseInt(line, 12, 2);
  925.                 final int qzssTocHours = parseInt(line, 15, 2);
  926.                 final int qzssTocMin   = parseInt(line, 18, 2);
  927.                 final int qzssTocSec   = parseInt(line, 21, 2);
  928.                 pi.qzssNav.setEpochToc(new AbsoluteDate(qzssTocYear, qzssTocMonth, qzssTocDay, qzssTocHours,
  929.                                                        qzssTocMin, qzssTocSec, pi.timeScales.getQZSS()));

  931.                 // Af0, Af1, and Af2
  932.                 pi.qzssNav.setAf0(parseDouble(line, 23, 19));
  933.                 pi.qzssNav.setAf1(parseDouble(line, 42, 19));
  934.                 pi.qzssNav.setAf2(parseDouble(line, 61, 19));
  935.             }

  937.             /** {@inheritDoc} */
  938.             @Override
  939.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  940.                 // IODE
  941.                 pi.qzssNav.setIODE(parseDouble(line, 4, 19));
  942.                 // Crs
  943.                 pi.qzssNav.setCrs(parseDouble(line, 23, 19));
  944.                 // Delta n
  945.                 pi.qzssNav.setDeltaN(parseDouble(line, 42, 19));
  946.                 // M0
  947.                 pi.qzssNav.setM0(parseDouble(line, 61, 19));
  948.             }

  950.             /** {@inheritDoc} */
  951.             @Override
  952.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  953.                 // Cuc
  954.                 pi.qzssNav.setCuc(parseDouble(line, 4, 19));
  955.                 // e
  956.                 pi.qzssNav.setE(parseDouble(line, 23, 19));
  957.                 // Cus
  958.                 pi.qzssNav.setCus(parseDouble(line, 42, 19));
  959.                 // sqrt(A)
  960.                 pi.qzssNav.setSqrtA(parseDouble(line, 61, 19));
  961.             }

  963.             /** {@inheritDoc} */
  964.             @Override
  965.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  966.                 // Toe
  967.                 pi.qzssNav.setTime(parseDouble(line, 4, 19));
  968.                 // Cic
  969.                 pi.qzssNav.setCic(parseDouble(line, 23, 19));
  970.                 // Omega0
  971.                 pi.qzssNav.setOmega0(parseDouble(line, 42, 19));
  972.                 // Cis
  973.                 pi.qzssNav.setCis(parseDouble(line, 61, 19));
  974.             }

  976.             /** {@inheritDoc} */
  977.             @Override
  978.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  979.                 // i0
  980.                 pi.qzssNav.setI0(parseDouble(line, 4, 19));
  981.                 // Crc
  982.                 pi.qzssNav.setCrc(parseDouble(line, 23, 19));
  983.                 // omega
  984.                 pi.qzssNav.setPa(parseDouble(line, 42, 19));
  985.                 // OMEGA DOT
  986.                 pi.qzssNav.setOmegaDot(parseDouble(line, 61, 19));
  987.             }

  989.             /** {@inheritDoc} */
  990.             @Override
  991.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  992.                 // iDot
  993.                 pi.qzssNav.setIDot(parseDouble(line, 4, 19));
  994.                 // Codes on L2 channel (ignored)
  995.                 // parseDouble(line, 23, 19)
  996.                 // GPS week (to go with Toe)
  997.                 pi.qzssNav.setWeek((int) parseDouble(line, 42, 19));
  998.                 pi.qzssNav.setDate(new GNSSDate(pi.qzssNav.getWeek(),
  999.                                                 SEC_TO_MILLI * pi.qzssNav.getTime(),
  1000.                                                 SatelliteSystem.GPS, // in Rinex files, week number is aligned to GPS week!
  1001.                                                 pi.timeScales).getDate());
  1002.             }

  1004.             /** {@inheritDoc} */
  1005.             @Override
  1006.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  1007.                 // SV accuracy
  1008.                 pi.qzssNav.setSvAccuracy(parseDouble(line, 4, 19));
  1009.                 // Health
  1010.                 pi.qzssNav.setSvHealth(parseDouble(line, 23, 19));
  1011.                 // TGD
  1012.                 pi.qzssNav.setTGD(parseDouble(line, 42, 19));
  1013.                 // IODC
  1014.                 pi.qzssNav.setIODC(parseDouble(line, 61, 19));
  1015.             }

  1017.             /** {@inheritDoc} */
  1018.             @Override
  1019.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  1020.                 // Add the navigation message to the file
  1021.                 pi.file.addQZSSNavigationMessage(pi.qzssNav);
  1022.                 // Reinitialized the container for navigation data
  1023.                 pi.qzssNav = new QZSSNavigationMessage();
  1024.             }

  1026.         },

  1028.         /** IRNSS. */
  1029.         IRNSS("I") {

  1031.             /** {@inheritDoc} */
  1032.             @Override
  1033.             public void parseFirstLine(final String line, final ParseInfo pi) {
  1034.                 // PRN
  1035.                 pi.irnssNav.setPRN(parseInt(line, 1, 2));

  1037.                 // Toc
  1038.                 final int irnssTocYear  = parseInt(line, 4, 4);
  1039.                 final int irnssTocMonth = parseInt(line, 9, 2);
  1040.                 final int irnssTocDay   = parseInt(line, 12, 2);
  1041.                 final int irnssTocHours = parseInt(line, 15, 2);
  1042.                 final int irnssTocMin   = parseInt(line, 18, 2);
  1043.                 final int irnssTocSec   = parseInt(line, 21, 2);
  1044.                 pi.irnssNav.setEpochToc(new AbsoluteDate(irnssTocYear, irnssTocMonth, irnssTocDay, irnssTocHours,
  1045.                                                          irnssTocMin, irnssTocSec, pi.timeScales.getIRNSS()));

  1047.                 // Af0, Af1, and Af2
  1048.                 pi.irnssNav.setAf0(parseDouble(line, 23, 19));
  1049.                 pi.irnssNav.setAf1(parseDouble(line, 42, 19));
  1050.                 pi.irnssNav.setAf2(parseDouble(line, 61, 19));
  1051.             }

  1053.             /** {@inheritDoc} */
  1054.             @Override
  1055.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  1056.                 // IODEC
  1057.                 pi.irnssNav.setIODEC(parseDouble(line, 4, 19));
  1058.                 // Crs
  1059.                 pi.irnssNav.setCrs(parseDouble(line, 23, 19));
  1060.                 // Delta n
  1061.                 pi.irnssNav.setDeltaN(parseDouble(line, 42, 19));
  1062.                 // M0
  1063.                 pi.irnssNav.setM0(parseDouble(line, 61, 19));
  1064.             }

  1066.             /** {@inheritDoc} */
  1067.             @Override
  1068.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  1069.                 // Cuc
  1070.                 pi.irnssNav.setCuc(parseDouble(line, 4, 19));
  1071.                 // e
  1072.                 pi.irnssNav.setE(parseDouble(line, 23, 19));
  1073.                 // Cus
  1074.                 pi.irnssNav.setCus(parseDouble(line, 42, 19));
  1075.                 // sqrt(A)
  1076.                 pi.irnssNav.setSqrtA(parseDouble(line, 61, 19));
  1077.             }

  1079.             /** {@inheritDoc} */
  1080.             @Override
  1081.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  1082.                 // Toe
  1083.                 pi.irnssNav.setTime(parseDouble(line, 4, 19));
  1084.                 // Cic
  1085.                 pi.irnssNav.setCic(parseDouble(line, 23, 19));
  1086.                 // Omega0
  1087.                 pi.irnssNav.setOmega0(parseDouble(line, 42, 19));
  1088.                 // Cis
  1089.                 pi.irnssNav.setCis(parseDouble(line, 61, 19));
  1090.             }

  1092.             /** {@inheritDoc} */
  1093.             @Override
  1094.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  1095.                 // i0
  1096.                 pi.irnssNav.setI0(parseDouble(line, 4, 19));
  1097.                 // Crc
  1098.                 pi.irnssNav.setCrc(parseDouble(line, 23, 19));
  1099.                 // omega
  1100.                 pi.irnssNav.setPa(parseDouble(line, 42, 19));
  1101.                 // OMEGA DOT
  1102.                 pi.irnssNav.setOmegaDot(parseDouble(line, 61, 19));
  1103.             }

  1105.             /** {@inheritDoc} */
  1106.             @Override
  1107.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  1108.                 // iDot
  1109.                 pi.irnssNav.setIDot(parseDouble(line, 4, 19));
  1110.                 // IRNSS week (to go with Toe)
  1111.                 pi.irnssNav.setWeek((int) parseDouble(line, 42, 19));
  1112.                 pi.irnssNav.setDate(new GNSSDate(pi.irnssNav.getWeek(),
  1113.                                                  SEC_TO_MILLI * pi.irnssNav.getTime(),
  1114.                                                  SatelliteSystem.GPS, // in Rinex files, week number is aligned to GPS week!
  1115.                                                  pi.timeScales).getDate());
  1116.             }

  1118.             /** {@inheritDoc} */
  1119.             @Override
  1120.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  1121.                 // SV accuracy
  1122.                 pi.irnssNav.setURA(parseDouble(line, 4, 19));
  1123.                 // Health
  1124.                 pi.irnssNav.setSvHealth(parseDouble(line, 23, 19));
  1125.                 // TGD
  1126.                 pi.irnssNav.setTGD(parseDouble(line, 42, 19));
  1127.             }

  1129.             /** {@inheritDoc} */
  1130.             @Override
  1131.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  1132.                 // Add the navigation message to the file
  1133.                 pi.file.addIRNSSNavigationMessage(pi.irnssNav);
  1134.                 // Reinitialized the container for navigation data
  1135.                 pi.irnssNav = new IRNSSNavigationMessage();

  1137.             }

  1139.         },

  1141.         /** Glonass. */
  1142.         GLONASS("R") {

  1144.             /** {@inheritDoc} */
  1145.             @Override
  1146.             public void parseFirstLine(final String line, final ParseInfo pi) {
  1147.                 // PRN
  1148.                 pi.glonassNav.setPRN(parseInt(line, 1, 2));

  1150.                 // Toc
  1151.                 final int glonassTocYear  = parseInt(line, 4, 4);
  1152.                 final int glonassTocMonth = parseInt(line, 9, 2);
  1153.                 final int glonassTocDay   = parseInt(line, 12, 2);
  1154.                 final int glonassTocHours = parseInt(line, 15, 2);
  1155.                 final int glonassTocMin   = parseInt(line, 18, 2);
  1156.                 final int glonassTocSec   = parseInt(line, 21, 2);
  1157.                 final AbsoluteDate date = new AbsoluteDate(glonassTocYear, glonassTocMonth, glonassTocDay, glonassTocHours, glonassTocMin, glonassTocSec, pi.timeScales.getUTC());

  1159.                 pi.glonassNav.setEpochToc(date);

  1161.                 // TauN (we read -TauN) and GammaN
  1162.                 pi.glonassNav.setTauN(-parseDouble(line, 23, 19));
  1163.                 pi.glonassNav.setGammaN(parseDouble(line, 42, 19));

  1165.                 // Date
  1166.                 pi.glonassNav.setDate(date.getDate());

  1168.                 // Time
  1169.                 pi.glonassNav.setTime(fmod(parseDouble(line, 61, 19), Constants.JULIAN_DAY));

  1171.             }

  1173.             /** {@inheritDoc} */
  1174.             @Override
  1175.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  1176.                 // X
  1177.                 pi.glonassNav.setX(parseDouble(line, 4, 19) * KM_TO_M);
  1178.                 // Vx
  1179.                 pi.glonassNav.setXDot(parseDouble(line, 23, 19) * KM_TO_M);
  1180.                 // Ax
  1181.                 pi.glonassNav.setXDotDot(parseDouble(line, 42, 19) * KM_TO_M);
  1182.                 // Health
  1183.                 pi.glonassNav.setHealth(parseDouble(line, 61, 19));
  1184.             }

  1186.             /** {@inheritDoc} */
  1187.             @Override
  1188.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  1189.                 // Y
  1190.                 pi.glonassNav.setY(parseDouble(line, 4, 19) * KM_TO_M);
  1191.                 // Vy
  1192.                 pi.glonassNav.setYDot(parseDouble(line, 23, 19) * KM_TO_M);
  1193.                 // Ay
  1194.                 pi.glonassNav.setYDotDot(parseDouble(line, 42, 19) * KM_TO_M);
  1195.                 // Frequency number
  1196.                 pi.glonassNav.setFrequencyNumber(parseDouble(line, 61, 19));
  1197.             }

  1199.             /** {@inheritDoc} */
  1200.             @Override
  1201.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  1202.                 // Z
  1203.                 pi.glonassNav.setZ(parseDouble(line, 4, 19) * KM_TO_M);
  1204.                 // Vz
  1205.                 pi.glonassNav.setZDot(parseDouble(line, 23, 19) * KM_TO_M);
  1206.                 // Az
  1207.                 pi.glonassNav.setZDotDot(parseDouble(line, 42, 19) * KM_TO_M);

  1209.                 // Add the navigation message to the file
  1210.                 pi.file.addGlonassNavigationMessage(pi.glonassNav);
  1211.                 // Reinitialized the container for navigation data
  1212.                 pi.glonassNav = new GLONASSNavigationMessage();
  1213.             }

  1215.             /** {@inheritDoc} */
  1216.             @Override
  1217.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  1218.                 // Nothing to do for GLONASS
  1219.             }

  1221.             /** {@inheritDoc} */
  1222.             @Override
  1223.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  1224.                 // Nothing to do for GLONASS
  1225.             }

  1227.             /** {@inheritDoc} */
  1228.             @Override
  1229.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  1230.                 // Nothing to do for GLONASS
  1231.             }

  1233.             /** {@inheritDoc} */
  1234.             @Override
  1235.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  1236.                 // Nothing to do for GLONASS
  1237.             }

  1239.         },

  1241.         /** SBAS. */
  1242.         SBAS("S") {

  1244.             /** {@inheritDoc} */
  1245.             @Override
  1246.             public void parseFirstLine(final String line, final ParseInfo pi) {
  1247.                 // PRN
  1248.                 pi.sbasNav.setPRN(parseInt(line, 1, 2));

  1250.                 // Toc
  1251.                 final int sbasTocYear  = parseInt(line, 4, 4);
  1252.                 final int sbasTocMonth = parseInt(line, 9, 2);
  1253.                 final int sbasTocDay   = parseInt(line, 12, 2);
  1254.                 final int sbasTocHours = parseInt(line, 15, 2);
  1255.                 final int sbasTocMin   = parseInt(line, 18, 2);
  1256.                 final int sbasTocSec   = parseInt(line, 21, 2);
  1257.                 // Time scale (UTC for Rinex 3.01 and GPS for other RINEX versions)
  1258.                 final TimeScale    timeScale = ((int) pi.version * 100 == 301) ? pi.timeScales.getUTC() : pi.timeScales.getGPS();
  1259.                 final AbsoluteDate refEpoch   = new AbsoluteDate(sbasTocYear, sbasTocMonth, sbasTocDay, sbasTocHours,
  1260.                                                                  sbasTocMin, sbasTocSec, timeScale);
  1261.                 pi.sbasNav.setEpochToc(refEpoch);

  1263.                 // AGf0 and AGf1
  1264.                 pi.sbasNav.setAGf0(parseDouble(line, 23, 19));
  1265.                 pi.sbasNav.setAGf1(parseDouble(line, 42, 19));
  1266.                 pi.sbasNav.setTime(parseDouble(line, 61, 19));

  1268.                 // Set the ephemeris epoch (same as time of clock epoch)
  1269.                 pi.sbasNav.setDate(refEpoch);
  1270.             }

  1272.             /** {@inheritDoc} */
  1273.             @Override
  1274.             public void parseFirstBroadcastOrbit(final String line, final ParseInfo pi) {
  1275.                 // X
  1276.                 pi.sbasNav.setX(parseDouble(line, 4, 19) * KM_TO_M);
  1277.                 // Vx
  1278.                 pi.sbasNav.setXDot(parseDouble(line, 23, 19) * KM_TO_M);
  1279.                 // Ax
  1280.                 pi.sbasNav.setXDotDot(parseDouble(line, 42, 19) * KM_TO_M);
  1281.                 // Health
  1282.                 pi.sbasNav.setHealth(parseDouble(line, 61, 19));
  1283.             }

  1285.             /** {@inheritDoc} */
  1286.             @Override
  1287.             public void parseSecondBroadcastOrbit(final String line, final ParseInfo pi) {
  1288.                 // Y
  1289.                 pi.sbasNav.setY(parseDouble(line, 4, 19) * KM_TO_M);
  1290.                 // Vy
  1291.                 pi.sbasNav.setYDot(parseDouble(line, 23, 19) * KM_TO_M);
  1292.                 // Ay
  1293.                 pi.sbasNav.setYDotDot(parseDouble(line, 42, 19) * KM_TO_M);
  1294.                 // URA
  1295.                 pi.sbasNav.setURA(parseDouble(line, 61, 19));
  1296.             }

  1298.             /** {@inheritDoc} */
  1299.             @Override
  1300.             public void parseThirdBroadcastOrbit(final String line, final ParseInfo pi) {
  1301.                 // Z
  1302.                 pi.sbasNav.setZ(parseDouble(line, 4, 19) * KM_TO_M);
  1303.                 // Vz
  1304.                 pi.sbasNav.setZDot(parseDouble(line, 23, 19) * KM_TO_M);
  1305.                 // Az
  1306.                 pi.sbasNav.setZDotDot(parseDouble(line, 42, 19) * KM_TO_M);
  1307.                 // IODN
  1308.                 pi.sbasNav.setIODN(parseDouble(line, 61, 19));

  1310.                 // Add the navigation message to the file
  1311.                 pi.file.addSBASNavigationMessage(pi.sbasNav);

  1313.                 // Reinitialized the container for navigation data
  1314.                 pi.sbasNav = new SBASNavigationMessage();

  1316.             }

  1318.             /** {@inheritDoc} */
  1319.             @Override
  1320.             public void parseFourthBroadcastOrbit(final String line, final ParseInfo pi) {
  1321.                 // Nothing to do for SBAS
  1322.             }

  1324.             /** {@inheritDoc} */
  1325.             @Override
  1326.             public void parseFifthBroadcastOrbit(final String line, final ParseInfo pi) {
  1327.                 // Nothing to do for SBAS
  1328.             }

  1330.             /** {@inheritDoc} */
  1331.             @Override
  1332.             public void parseSixthBroadcastOrbit(final String line, final ParseInfo pi) {
  1333.                 // Nothing to do for SBAS
  1334.             }

  1336.             /** {@inheritDoc} */
  1337.             @Override
  1338.             public void parseSeventhBroadcastOrbit(final String line, final ParseInfo pi) {
  1339.                 // Nothing to do for SBAS
  1340.             }

  1342.         };

  1344.         /** Parsing map. */
  1345.         private static final Map<String, SatelliteSystemLineParser> KEYS_MAP = new HashMap<>();
  1346.         static {
  1347.             for (final SatelliteSystemLineParser satelliteSystem : values()) {
  1348.                 KEYS_MAP.put(satelliteSystem.getKey(), satelliteSystem);
  1349.             }
  1350.         }

  1352.         /** Satellite system key. */
  1353.         private String key;

  1355.         /**
  1356.          * Constructor.
  1357.          * @param key satellite system key
  1358.          */
  1359.         SatelliteSystemLineParser(final String key) {
  1360.             this.key = key;
  1361.         }

  1363.         /**
  1364.          * Getter for the satellite system key.
  1365.          * @return the satellite system key
  1366.          */
  1367.         public String getKey() {
  1368.             return key;
  1369.         }

  1371.         /** Parse a string to get the satellite system.
  1372.          * <p>
  1373.          * The string first character must be the satellite system.
  1374.          * </p>
  1375.          * @param s string to parse
  1376.          * @return the satellite system
  1377.          */
  1378.         public static SatelliteSystemLineParser getSatelliteSystemLineParser(final String s) {
  1379.             return KEYS_MAP.get(s);
  1380.         }

  1382.         /**
  1383.          * Parse the first line of the navigation message.
  1384.          * @param line line to read
  1385.          * @param pi holder for transient data
  1386.          */
  1387.         public abstract void parseFirstLine(String line, ParseInfo pi);

  1389.         /**
  1390.          * Parse the "BROADCASTORBIT - 1" line.
  1391.          * @param line line to read
  1392.          * @param pi holder for transient data
  1393.          */
  1394.         public abstract void parseFirstBroadcastOrbit(String line, ParseInfo pi);

  1396.         /**
  1397.          * Parse the "BROADCASTORBIT - 2" line.
  1398.          * @param line line to read
  1399.          * @param pi holder for transient data
  1400.          */
  1401.         public abstract void parseSecondBroadcastOrbit(String line, ParseInfo pi);

  1403.         /**
  1404.          * Parse the "BROADCASTORBIT - 3" line.
  1405.          * @param line line to read
  1406.          * @param pi holder for transient data
  1407.          */
  1408.         public abstract void parseThirdBroadcastOrbit(String line, ParseInfo pi);

  1410.         /**
  1411.          * Parse the "BROADCASTORBIT - 4" line.
  1412.          * @param line line to read
  1413.          * @param pi holder for transient data
  1414.          */
  1415.         public abstract void parseFourthBroadcastOrbit(String line, ParseInfo pi);

  1417.         /**
  1418.          * Parse the "BROADCASTORBIT - 5" line.
  1419.          * @param line line to read
  1420.          * @param pi holder for transient data
  1421.          */
  1422.         public abstract void parseFifthBroadcastOrbit(String line, ParseInfo pi);

  1424.         /**
  1425.          * Parse the "BROADCASTORBIT - 6" line.
  1426.          * @param line line to read
  1427.          * @param pi holder for transient data
  1428.          */
  1429.         public abstract void parseSixthBroadcastOrbit(String line, ParseInfo pi);

  1431.         /**
  1432.          * Parse the "BROADCASTORBIT - 7" line.
  1433.          * @param line line to read
  1434.          * @param pi holder for transient data
  1435.          */
  1436.         public abstract void parseSeventhBroadcastOrbit(String line, ParseInfo pi);

  1438.         /**
  1439.          * Calculates the floating-point remainder of a / b.
  1440.          * <p>
  1441.          * fmod = a - x * b
  1442.          * where x = (int) a / b
  1443.          * </p>
  1444.          * @param a numerator
  1445.          * @param b denominator
  1446.          * @return the floating-point remainder of a / b
  1447.          */
  1448.         private static double fmod(final double a, final double b) {
  1449.             final double x = (int) (a / b);
  1450.             return a - x * b;
  1451.         }

  1453.     }

  1455. }
Created with JaCoCo 0.8.8.202204050719