RinexLoader.java

  1. /* Copyright 2002-2019 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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;
  18. import java.io.BufferedReader;
  19. import java.io.IOException;
  20. import java.io.InputStream;
  21. import java.io.InputStreamReader;
  22. import java.util.ArrayList;
  23. import java.util.Collections;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;

  28. import org.hipparchus.exception.DummyLocalizable;
  29. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  30. import org.hipparchus.geometry.euclidean.twod.Vector2D;
  31. import org.hipparchus.util.FastMath;
  32. import org.orekit.data.DataLoader;
  33. import org.orekit.data.DataProvidersManager;
  34. import org.orekit.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.time.TimeScale;
  38. import org.orekit.time.TimeScalesFactory;

  40. /** Loader for Rinex measurements files.
  41.  * <p>
  42.  * Supported versions are: 2.00, 2.10, 2.11, 2.12 (unofficial), 2.20 (unofficial),
  43.  * 3.00, 3.01, 3.02, and 3.03.
  44.  * </p>
  45.  * @see <a href="ftp://igs.org/pub/data/format/rinex2.txt">rinex 2.0</a>
  46.  * @see <a href="ftp://igs.org/pub/data/forma/rinex210.txt">rinex 2.10</a>
  47.  * @see <a href="ftp://igs.org/pub/data/forma/rinex211.txt">rinex 2.11</a>
  48.  * @see <a href="http://www.aiub.unibe.ch/download/rinex/rinex212.txt">unofficial rinex 2.12</a>
  49.  * @see <a href="http://www.aiub.unibe.ch/download/rinex/rnx_leo.txt">unofficial rinex 2.20</a>
  50.  * @see <a href="ftp://igs.org/pub/data/format/rinex300.pdf">rinex 3.00</a>
  51.  * @see <a href="ftp://igs.org/pub/data/format/rinex301.pdf">rinex 3.01</a>
  52.  * @see <a href="ftp://igs.org/pub/data/format/rinex302.pdf">rinex 3.02</a>
  53.  * @see <a href="ftp://igs.org/pub/data/format/rinex303.pdf">rinex 3.03</a>
  54.  * @since 9.2
  55.  */
  56. public class RinexLoader {

  58.     /** Default supported files name pattern for rinex 2 observation files. */
  59.     public static final String DEFAULT_RINEX_2_SUPPORTED_NAMES = "^\\w{4}\\d{3}[0a-x](?:\\d{2})?\\.\\d{2}[oO]$";

  61.     /** Default supported files name pattern for rinex 3 observation files. */
  62.     public static final String DEFAULT_RINEX_3_SUPPORTED_NAMES = "^\\w{9}_\\w{1}_\\d{11}_\\d{2}\\w_\\d{2}\\w{1}_\\w{2}\\.rnx$";

  64.     // CHECKSTYLE: stop JavadocVariable check
  65.     private static final String RINEX_VERSION_TYPE   = "RINEX VERSION / TYPE";
  66.     private static final String COMMENT              = "COMMENT";
  67.     private static final String PGM_RUN_BY_DATE      = "PGM / RUN BY / DATE";
  68.     private static final String MARKER_NAME          = "MARKER NAME";
  69.     private static final String MARKER_NUMBER        = "MARKER NUMBER";
  70.     private static final String MARKER_TYPE          = "MARKER TYPE";
  71.     private static final String OBSERVER_AGENCY      = "OBSERVER / AGENCY";
  72.     private static final String REC_NB_TYPE_VERS     = "REC # / TYPE / VERS";
  73.     private static final String ANT_NB_TYPE          = "ANT # / TYPE";
  74.     private static final String APPROX_POSITION_XYZ  = "APPROX POSITION XYZ";
  75.     private static final String ANTENNA_DELTA_H_E_N  = "ANTENNA: DELTA H/E/N";
  76.     private static final String ANTENNA_DELTA_X_Y_Z  = "ANTENNA: DELTA X/Y/Z";
  77.     private static final String ANTENNA_PHASECENTER  = "ANTENNA: PHASECENTER";
  78.     private static final String ANTENNA_B_SIGHT_XYZ  = "ANTENNA: B.SIGHT XYZ";
  79.     private static final String ANTENNA_ZERODIR_AZI  = "ANTENNA: ZERODIR AZI";
  80.     private static final String ANTENNA_ZERODIR_XYZ  = "ANTENNA: ZERODIR XYZ";
  81.     private static final String NB_OF_SATELLITES     = "# OF SATELLITES";
  82.     private static final String WAVELENGTH_FACT_L1_2 = "WAVELENGTH FACT L1/2";
  83.     private static final String RCV_CLOCK_OFFS_APPL  = "RCV CLOCK OFFS APPL";
  84.     private static final String INTERVAL             = "INTERVAL";
  85.     private static final String TIME_OF_FIRST_OBS    = "TIME OF FIRST OBS";
  86.     private static final String TIME_OF_LAST_OBS     = "TIME OF LAST OBS";
  87.     private static final String LEAP_SECONDS         = "LEAP SECONDS";
  88.     private static final String PRN_NB_OF_OBS        = "PRN / # OF OBS";
  89.     private static final String NB_TYPES_OF_OBSERV   = "# / TYPES OF OBSERV";
  90.     private static final String END_OF_HEADER        = "END OF HEADER";
  91.     private static final String CENTER_OF_MASS_XYZ   = "CENTER OF MASS: XYZ";
  92.     private static final String SIGNAL_STRENGTH_UNIT = "SIGNAL STRENGTH UNIT";
  93.     private static final String SYS_NB_OBS_TYPES     = "SYS / # / OBS TYPES";
  94.     private static final String SYS_DCBS_APPLIED     = "SYS / DCBS APPLIED";
  95.     private static final String SYS_PCVS_APPLIED     = "SYS / PCVS APPLIED";
  96.     private static final String SYS_SCALE_FACTOR     = "SYS / SCALE FACTOR";
  97.     private static final String SYS_PHASE_SHIFT      = "SYS / PHASE SHIFT";
  98.     private static final String GLONASS_SLOT_FRQ_NB  = "GLONASS SLOT / FRQ #";
  99.     private static final String GLONASS_COD_PHS_BIS  = "GLONASS COD/PHS/BIS";
  100.     private static final String OBS_SCALE_FACTOR     = "OBS SCALE FACTOR";

  102.     private static final String GPS                  = "GPS";
  103.     private static final String GAL                  = "GAL";
  104.     private static final String GLO                  = "GLO";
  105.     private static final String QZS                  = "QZS";
  106.     private static final String BDT                  = "BDT";
  107.     private static final String IRN                  = "IRN";
  108.     // CHECKSTYLE: resume JavadocVariable check

  110.     /** Rinex Observations. */
  111.     private final List<ObservationDataSet> observationDataSets;

  113.     /** Simple constructor.
  114.      * <p>
  115.      * This constructor is used when the rinex files are managed by the
  116.      * global {@link DataProvidersManager DataProvidersManager}.
  117.      * </p>
  118.      * @param supportedNames regular expression for supported files names
  119.      */
  120.     public RinexLoader(final String supportedNames) {
  121.         observationDataSets = new ArrayList<>();
  122.         DataProvidersManager.getInstance().feed(supportedNames, new Parser());
  123.     }

  125.     /** Simple constructor.
  126.      * @param input data input stream
  127.      * @param name name of the file (or zip entry)
  128.      */
  129.     public RinexLoader(final InputStream input, final String name) {
  130.         try {
  131.             observationDataSets = new ArrayList<>();
  132.             new Parser().loadData(input, name);
  133.         } catch (IOException ioe) {
  134.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  135.         }
  136.     }

  138.     /** Get parsed rinex observations.
  139.      * @return unmodifiable view of parsed rinex observations
  140.      * @deprecated as of 9.3 replaced by {@link #getObservationDataSets()}
  141.      */
  142.     @Deprecated
  143.     public Map<RinexHeader, List<ObservationDataSet>> getObservations() {
  144.         final Map<RinexHeader, List<ObservationDataSet>> map = new HashMap<>();
  145.         for (final ObservationDataSet dataSet : observationDataSets) {
  146.             List<ObservationDataSet> l = map.get(dataSet.getHeader());
  147.             if (l == null) {
  148.                 // first time we see this header
  149.                 l = new ArrayList<>();
  150.                 map.put(dataSet.getHeader(), l);
  151.             }
  152.             l.add(dataSet);
  153.         }
  154.         return map;
  155.     }

  157.     /** Get parsed rinex observations data sets.
  158.      * @return unmodifiable view of parsed rinex observations
  159.      * @since 9.3
  160.      */
  161.     public List<ObservationDataSet> getObservationDataSets() {
  162.         return Collections.unmodifiableList(observationDataSets);
  163.     }

  165.     /** Parser for rinex files.
  166.      */
  167.     public class Parser implements DataLoader {

  169.         /** Index of label in data lines. */
  170.         private static final int LABEL_START = 60;

  172.         /** File type accepted (only Observation Data). */
  173.         private static final String FILE_TYPE = "O"; //Only Observation Data files

  175.         /** {@inheritDoc} */
  176.         @Override
  177.         public boolean stillAcceptsData() {
  178.             // we load all rinex files we can find
  179.             return true;
  180.         }

  182.         /** {@inheritDoc} */
  183.         @Override
  184.         public void loadData(final InputStream input, final String name)
  185.             throws IOException, OrekitException {

  187.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"))) {

  189.                 // placeholders for parsed data
  190.                 SatelliteSystem                  satelliteSystem        = null;
  191.                 double                           formatVersion          = Double.NaN;
  192.                 boolean                          inRinexVersion         = false;
  193.                 int                              lineNumber             = 0;
  194.                 SatelliteSystem                  obsTypesSystem         = null;
  195.                 String                           markerName             = null;
  196.                 String                           markerNumber           = null;
  197.                 String                           markerType             = null;
  198.                 String                           observerName           = null;
  199.                 String                           agencyName             = null;
  200.                 String                           receiverNumber         = null;
  201.                 String                           receiverType           = null;
  202.                 String                           receiverVersion        = null;
  203.                 String                           antennaNumber          = null;
  204.                 String                           antennaType            = null;
  205.                 Vector3D                         approxPos              = null;
  206.                 Vector3D                         antRefPoint            = null;
  207.                 String                           obsCode                = null;
  208.                 Vector3D                         antPhaseCenter         = null;
  209.                 Vector3D                         antBSight              = null;
  210.                 double                           antAzi                 = Double.NaN;
  211.                 Vector3D                         antZeroDir             = null;
  212.                 Vector3D                         centerMass             = null;
  213.                 double                           antHeight              = Double.NaN;
  214.                 Vector2D                         eccentricities         = Vector2D.ZERO;
  215.                 int                              clkOffset              = -1;
  216.                 int                              nbTypes                = -1;
  217.                 int                              nbSat                  = -1;
  218.                 double                           interval               = Double.NaN;
  219.                 AbsoluteDate                     tFirstObs              = AbsoluteDate.PAST_INFINITY;
  220.                 AbsoluteDate                     tLastObs               = AbsoluteDate.FUTURE_INFINITY;
  221.                 TimeScale                        timeScale              = null;
  222.                 String                           timeScaleStr           = null;
  223.                 int                              leapSeconds            = 0;
  224.                 AbsoluteDate                     tObs                   = AbsoluteDate.PAST_INFINITY;
  225.                 String[]                         satsObsList            = null;
  226.                 String                           strYear                = null;
  227.                 int                              eventFlag              = -1;
  228.                 int                              nbSatObs               = -1;
  229.                 int                              nbLinesSat             = -1;
  230.                 double                           rcvrClkOffset          = 0;
  231.                 boolean                          inRunBy                = false;
  232.                 boolean                          inMarkerName           = false;
  233.                 boolean                          inMarkerType           = false;
  234.                 boolean                          inObserver             = false;
  235.                 boolean                          inRecType              = false;
  236.                 boolean                          inAntType              = false;
  237.                 boolean                          inAproxPos             = false;
  238.                 boolean                          inAntDelta             = false;
  239.                 boolean                          inTypesObs             = false;
  240.                 boolean                          inFirstObs             = false;
  241.                 boolean                          inPhaseShift           = false;
  242.                 boolean                          inGlonassSlot          = false;
  243.                 boolean                          inGlonassCOD           = false;
  244.                 RinexHeader                      rinexHeader            = null;
  245.                 int                               scaleFactor            = 1;
  246.                 int                               nbObsScaleFactor       = 0;
  247.                 final List<ScaleFactorCorrection> scaleFactorCorrections = new ArrayList<>();
  248.                 final Map<SatelliteSystem, List<ObservationType>> listTypeObs = new HashMap<>();

  250.                 //First line must  always contain Rinex Version, File Type and Satellite Systems Observed
  251.                 String line = reader.readLine();
  252.                 lineNumber++;
  253.                 formatVersion = parseDouble(line, 0, 9);
  254.                 int format100 = (int) FastMath.rint(100 * formatVersion);

  256.                 if ((format100 != 200) && (format100 != 210) && (format100 != 211) &&
  257.                     (format100 != 212) && (format100 != 220) && (format100 != 300) &&
  258.                     (format100 != 301) && (format100 != 302) && (format100 != 303)) {
  259.                     throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  260.                 }

  262.                 //File Type must be Observation_Data
  263.                 if (!(parseString(line, 20, 1)).equals(FILE_TYPE)) {
  264.                     throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  265.                 }
  266.                 satelliteSystem = SatelliteSystem.parseSatelliteSystem(parseString(line, 40, 1));
  267.                 inRinexVersion = true;

  269.                 switch (format100 / 100) {
  270.                     case 2: {

  272.                         final int                   MAX_OBS_TYPES_PER_LINE_RNX2 = 9;
  273.                         final int                   MAX_N_SAT_OBSERVATION       = 12;
  274.                         final int                   MAX_N_TYPES_OBSERVATION     = 5;
  275.                         final int                   MAX_OBS_TYPES_SCALE_FACTOR  = 8;
  276.                         final List<ObservationType> typesObs = new ArrayList<>();

  278.                         for (line = reader.readLine(); line != null; line = reader.readLine()) {
  279.                             ++lineNumber;

  281.                             if (rinexHeader == null) {
  282.                                 switch(line.substring(LABEL_START).trim()) {
  283.                                     case RINEX_VERSION_TYPE :

  285.                                         formatVersion = parseDouble(line, 0, 9);
  286.                                         //File Type must be Observation_Data
  287.                                         if (!(parseString(line, 20, 1)).equals(FILE_TYPE)) {
  288.                                             throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  289.                                         }
  290.                                         satelliteSystem = SatelliteSystem.parseSatelliteSystem(parseString(line, 40, 1));
  291.                                         inRinexVersion = true;
  292.                                         break;
  293.                                     case COMMENT :
  294.                                         // nothing to do
  295.                                         break;
  296.                                     case PGM_RUN_BY_DATE :
  297.                                         inRunBy = true;
  298.                                         break;
  299.                                     case MARKER_NAME :
  300.                                         markerName = parseString(line, 0, 60);
  301.                                         inMarkerName = true;
  302.                                         break;
  303.                                     case MARKER_NUMBER :
  304.                                         markerNumber = parseString(line, 0, 20);
  305.                                         break;
  306.                                     case MARKER_TYPE :
  307.                                         markerType = parseString(line, 0, 20);
  308.                                         break;
  309.                                     case OBSERVER_AGENCY :
  310.                                         observerName = parseString(line, 0, 20);
  311.                                         agencyName   = parseString(line, 20, 40);
  312.                                         inObserver = true;
  313.                                         break;
  314.                                     case REC_NB_TYPE_VERS :
  315.                                         receiverNumber  = parseString(line, 0, 20);
  316.                                         receiverType    = parseString(line, 20, 20);
  317.                                         receiverVersion = parseString(line, 40, 20);
  318.                                         inRecType = true;
  319.                                         break;
  320.                                     case ANT_NB_TYPE :
  321.                                         antennaNumber = parseString(line, 0, 20);
  322.                                         antennaType   = parseString(line, 20, 20);
  323.                                         inAntType = true;
  324.                                         break;
  325.                                     case APPROX_POSITION_XYZ :
  326.                                         approxPos = new Vector3D(parseDouble(line, 0, 14), parseDouble(line, 14, 14),
  327.                                                                  parseDouble(line, 28, 14));
  328.                                         inAproxPos = true;
  329.                                         break;
  330.                                     case ANTENNA_DELTA_H_E_N :
  331.                                         antHeight = parseDouble(line, 0, 14);
  332.                                         eccentricities = new Vector2D(parseDouble(line, 14, 14), parseDouble(line, 28, 14));
  333.                                         inAntDelta = true;
  334.                                         break;
  335.                                     case ANTENNA_DELTA_X_Y_Z :
  336.                                         antRefPoint = new Vector3D(parseDouble(line, 0, 14),
  337.                                                                    parseDouble(line, 14, 14),
  338.                                                                    parseDouble(line, 28, 14));
  339.                                         break;
  340.                                     case ANTENNA_B_SIGHT_XYZ :
  341.                                         antBSight = new Vector3D(parseDouble(line, 0, 14),
  342.                                                                  parseDouble(line, 14, 14),
  343.                                                                  parseDouble(line, 28, 14));
  344.                                         break;
  345.                                     case CENTER_OF_MASS_XYZ :
  346.                                         centerMass = new Vector3D(parseDouble(line, 0, 14),
  347.                                                                   parseDouble(line, 14, 14),
  348.                                                                   parseDouble(line, 28, 14));
  349.                                         break;
  350.                                     case NB_OF_SATELLITES :
  351.                                         nbSat = parseInt(line, 0, 6);
  352.                                         break;
  353.                                     case WAVELENGTH_FACT_L1_2 :
  354.                                         //Optional line in header
  355.                                         //Not stored for now
  356.                                         break;
  357.                                     case RCV_CLOCK_OFFS_APPL :
  358.                                         clkOffset = parseInt(line, 0, 6);
  359.                                         break;
  360.                                     case INTERVAL :
  361.                                         interval = parseDouble(line, 0, 10);
  362.                                         break;
  363.                                     case TIME_OF_FIRST_OBS :
  364.                                         switch (satelliteSystem) {
  365.                                             case GPS:
  366.                                                 timeScale = TimeScalesFactory.getGPS();
  367.                                                 break;
  368.                                             case GALILEO:
  369.                                                 timeScale = TimeScalesFactory.getGST();
  370.                                                 break;
  371.                                             case GLONASS:
  372.                                                 timeScale = TimeScalesFactory.getGLONASS();
  373.                                                 break;
  374.                                             case MIXED:
  375.                                                 //in Case of Mixed data, Timescale must be specified in the Time of First line
  376.                                                 timeScaleStr = parseString(line, 48, 3);

  378.                                                 if (timeScaleStr.equals(GPS)) {
  379.                                                     timeScale = TimeScalesFactory.getGPS();
  380.                                                 } else if (timeScaleStr.equals(GAL)) {
  381.                                                     timeScale = TimeScalesFactory.getGST();
  382.                                                 } else if (timeScaleStr.equals(GLO)) {
  383.                                                     timeScale = TimeScalesFactory.getGLONASS();
  384.                                                 } else {
  385.                                                     throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  386.                                                 }
  387.                                                 break;
  388.                                             default :
  389.                                                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  390.                                                                           lineNumber, name, line);
  391.                                         }

  393.                                         tFirstObs = new AbsoluteDate(parseInt(line, 0, 6),
  394.                                                                      parseInt(line, 6, 6),
  395.                                                                      parseInt(line, 12, 6),
  396.                                                                      parseInt(line, 18, 6),
  397.                                                                      parseInt(line, 24, 6),
  398.                                                                      parseDouble(line, 30, 13), timeScale);
  399.                                         inFirstObs = true;
  400.                                         break;
  401.                                     case TIME_OF_LAST_OBS :
  402.                                         tLastObs = new AbsoluteDate(parseInt(line, 0, 6),
  403.                                                                     parseInt(line, 6, 6),
  404.                                                                     parseInt(line, 12, 6),
  405.                                                                     parseInt(line, 18, 6),
  406.                                                                     parseInt(line, 24, 6),
  407.                                                                     parseDouble(line, 30, 13), timeScale);
  408.                                         break;
  409.                                     case LEAP_SECONDS :
  410.                                         leapSeconds = parseInt(line, 0, 6);
  411.                                         break;
  412.                                     case PRN_NB_OF_OBS :
  413.                                         //Optional line in header, indicates number of Observations par Satellite
  414.                                         //Not stored for now
  415.                                         break;
  416.                                     case NB_TYPES_OF_OBSERV :
  417.                                         nbTypes = parseInt(line, 0, 6);
  418.                                         final int nbLinesTypesObs = (nbTypes + MAX_OBS_TYPES_PER_LINE_RNX2 - 1 ) / MAX_OBS_TYPES_PER_LINE_RNX2;

  420.                                         for (int j = 0; j < nbLinesTypesObs; j++) {
  421.                                             if (j > 0) {
  422.                                                 line = reader.readLine(); //Next line
  423.                                                 lineNumber++;
  424.                                             }
  425.                                             final int iMax = FastMath.min(MAX_OBS_TYPES_PER_LINE_RNX2, nbTypes - typesObs.size());
  426.                                             for (int i = 0; i < iMax; i++) {
  427.                                                 try {
  428.                                                     typesObs.add(ObservationType.valueOf(parseString(line, 10 + (6 * i), 2)));
  429.                                                 } catch (IllegalArgumentException iae) {
  430.                                                     throw new OrekitException(OrekitMessages.UNKNOWN_RINEX_FREQUENCY,
  431.                                                                               parseString(line, 10 + (6 * i), 2), name, lineNumber);
  432.                                                 }
  433.                                             }
  434.                                         }
  435.                                         inTypesObs = true;
  436.                                         break;
  437.                                     case OBS_SCALE_FACTOR :
  438.                                         scaleFactor      = FastMath.max(1, parseInt(line, 0,  6));
  439.                                         nbObsScaleFactor = parseInt(line, 6, 6);
  440.                                         if (nbObsScaleFactor > MAX_OBS_TYPES_SCALE_FACTOR) {
  441.                                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  442.                                                                       lineNumber, name, line);
  443.                                         }
  444.                                         final List<ObservationType> typesObsScaleFactor = new ArrayList<>(nbObsScaleFactor);
  445.                                         for (int i = 0; i < nbObsScaleFactor; i++) {
  446.                                             typesObsScaleFactor.add(ObservationType.valueOf(parseString(line, 16 + (6 * i), 2)));
  447.                                         }
  448.                                         scaleFactorCorrections.add(new ScaleFactorCorrection(satelliteSystem,
  449.                                                                                              scaleFactor, typesObsScaleFactor));
  450.                                         break;
  451.                                     case END_OF_HEADER :
  452.                                         //We make sure that we have read all the mandatory fields inside the header of the Rinex
  453.                                         if (!inRinexVersion || !inRunBy || !inMarkerName ||
  454.                                             !inObserver || !inRecType || !inAntType ||
  455.                                             (formatVersion < 2.20 && !inAproxPos) ||
  456.                                             (formatVersion < 2.20 && !inAntDelta) ||
  457.                                             !inTypesObs || !inFirstObs) {
  458.                                             throw new OrekitException(OrekitMessages.INCOMPLETE_HEADER, name);
  459.                                         }

  461.                                         //Header information gathered
  462.                                         rinexHeader = new RinexHeader(formatVersion, satelliteSystem,
  463.                                                                       markerName, markerNumber, markerType, observerName,
  464.                                                                       agencyName, receiverNumber, receiverType,
  465.                                                                       receiverVersion, antennaNumber, antennaType,
  466.                                                                       approxPos, antHeight, eccentricities,
  467.                                                                       antRefPoint, antBSight, centerMass, interval,
  468.                                                                       tFirstObs, tLastObs, clkOffset, leapSeconds);
  469.                                         break;
  470.                                     default :
  471.                                         if (rinexHeader == null) {
  472.                                             //There must be an error due to an unknown Label inside the Header
  473.                                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  474.                                                                       lineNumber, name, line);
  475.                                         }
  476.                                 }
  477.                             } else {

  479.                                 //Start of a new Observation
  480.                                 rcvrClkOffset     =  0;
  481.                                 nbLinesSat        = -1;
  482.                                 eventFlag         = -1;
  483.                                 nbSatObs          = -1;
  484.                                 satsObsList       = null;
  485.                                 tObs              = null;
  486.                                 strYear           = null;

  488.                                 eventFlag = parseInt(line, 28, 1);
  489.                                 //If eventFlag>1, we skip the corresponding lines to the next observation
  490.                                 if (eventFlag != 0) {
  491.                                     if (eventFlag == 6) {
  492.                                         nbSatObs  = parseInt(line, 29, 3);
  493.                                         nbLinesSat = (nbSatObs + 12 - 1) / 12;
  494.                                         final int nbLinesObs = (nbTypes + 5 - 1) / 5;
  495.                                         final int nbLinesSkip = (nbLinesSat - 1) + nbSatObs * nbLinesObs;
  496.                                         for (int i = 0; i < nbLinesSkip; i++) {
  497.                                             line = reader.readLine(); //Next line
  498.                                             lineNumber++;
  499.                                         }
  500.                                     } else {
  501.                                         final int nbLinesSkip = parseInt(line, 29, 3);
  502.                                         for (int i = 0; i < nbLinesSkip; i++) {
  503.                                             line = reader.readLine(); //Next line
  504.                                             lineNumber++;
  505.                                         }
  506.                                     }
  507.                                 } else {

  509.                                     final int y = Integer.parseInt(parseString(line, 0, 3));
  510.                                     if (79 < y && y <= 99) {
  511.                                         strYear = "19" + y;
  512.                                     } else if (0 <= y && y <= 79) {
  513.                                         strYear = "20" + parseString(line, 0, 3);
  514.                                     }
  515.                                     tObs = new AbsoluteDate(Integer.parseInt(strYear),
  516.                                                             parseInt(line, 3, 3),
  517.                                                             parseInt(line, 6, 3),
  518.                                                             parseInt(line, 9, 3),
  519.                                                             parseInt(line, 12, 3),
  520.                                                             parseDouble(line, 15, 11), timeScale);

  522.                                     nbSatObs  = parseInt(line, 29, 3);
  523.                                     satsObsList   = new String[nbSatObs];
  524.                                     //If the total number of satellites was indicated in the Header
  525.                                     if (nbSat != -1 && nbSatObs > nbSat) {
  526.                                         //we check that the number of Sat in the observation is consistent
  527.                                         throw new OrekitException(OrekitMessages.INCONSISTENT_NUMBER_OF_SATS,
  528.                                                                   lineNumber, name, nbSatObs, nbSat);
  529.                                     }

  531.                                     nbLinesSat = (nbSatObs + MAX_N_SAT_OBSERVATION - 1) / MAX_N_SAT_OBSERVATION;
  532.                                     for (int j = 0; j < nbLinesSat; j++) {
  533.                                         if (j > 0) {
  534.                                             line = reader.readLine(); //Next line
  535.                                             lineNumber++;
  536.                                         }
  537.                                         final int iMax = FastMath.min(MAX_N_SAT_OBSERVATION, nbSatObs  - j * MAX_N_SAT_OBSERVATION);
  538.                                         for (int i = 0; i < iMax; i++) {
  539.                                             satsObsList[i + MAX_N_SAT_OBSERVATION * j] = parseString(line, 32 + 3 * i, 3);
  540.                                         }

  542.                                         //Read the Receiver Clock offset, if present
  543.                                         rcvrClkOffset = parseDouble(line, 68, 12);
  544.                                         if (Double.isNaN(rcvrClkOffset)) {
  545.                                             rcvrClkOffset = 0.0;
  546.                                         }

  548.                                     }

  550.                                     //For each one of the Satellites in this observation
  551.                                     final int nbLinesObs = (nbTypes + MAX_N_TYPES_OBSERVATION - 1) / MAX_N_TYPES_OBSERVATION;
  552.                                     for (int k = 0; k < nbSatObs; k++) {


  555.                                         //Once the Date and Satellites list is read:
  556.                                         //  - to read the Data for each satellite
  557.                                         //  - 5 Observations per line
  558.                                         final List<ObservationData> observationData = new ArrayList<>(nbSatObs);
  559.                                         for (int j = 0; j < nbLinesObs; j++) {
  560.                                             line = reader.readLine(); //Next line
  561.                                             lineNumber++;
  562.                                             final int iMax = FastMath.min(MAX_N_TYPES_OBSERVATION, nbTypes - observationData.size());
  563.                                             for (int i = 0; i < iMax; i++) {
  564.                                                 final ObservationType type = typesObs.get(observationData.size());
  565.                                                 double value = parseDouble(line, 16 * i, 14);
  566.                                                 boolean scaleFactorFound = false;
  567.                                                 //We look for the lines of ScaledFactorCorrections
  568.                                                 for (int l = 0; l < scaleFactorCorrections.size() && !scaleFactorFound; ++l) {
  569.                                                     //We check if the next Observation Type to read needs to be scaled
  570.                                                     if (scaleFactorCorrections.get(l).getTypesObsScaled().contains(type)) {
  571.                                                         value /= scaleFactorCorrections.get(l).getCorrection();
  572.                                                         scaleFactorFound = true;
  573.                                                     }
  574.                                                 }
  575.                                                 observationData.add(new ObservationData(type,
  576.                                                                                         value,
  577.                                                                                         parseInt(line, 14 + 16 * i, 1),
  578.                                                                                         parseInt(line, 15 + 16 * i, 1)));
  579.                                             }
  580.                                         }

  582.                                         //We check that the Satellite type is consistent with Satellite System in the top of the file
  583.                                         final SatelliteSystem satelliteSystemSat;
  584.                                         final int id;
  585.                                         if (satsObsList[k].length() < 3) {
  586.                                             // missing satellite system, we use the global one
  587.                                             satelliteSystemSat = satelliteSystem;
  588.                                             id                 = Integer.parseInt(satsObsList[k]);
  589.                                         } else {
  590.                                             satelliteSystemSat = SatelliteSystem.parseSatelliteSystem(satsObsList[k]);
  591.                                             id                 = Integer.parseInt(satsObsList[k].substring(1, 3).trim());
  592.                                         }
  593.                                         if (!satelliteSystem.equals(SatelliteSystem.MIXED)) {
  594.                                             if (!satelliteSystemSat.equals(satelliteSystem)) {
  595.                                                 throw new OrekitException(OrekitMessages.INCONSISTENT_SATELLITE_SYSTEM,
  596.                                                                           lineNumber, name, satelliteSystem, satelliteSystemSat);
  597.                                             }
  598.                                         }

  600.                                         final int prnNumber;
  601.                                         switch (satelliteSystemSat) {
  602.                                             case GPS:
  603.                                             case GLONASS:
  604.                                             case GALILEO:
  605.                                                 prnNumber = id;
  606.                                                 break;
  607.                                             case SBAS:
  608.                                                 prnNumber = id + 100;
  609.                                                 break;
  610.                                             default:
  611.                                                 // MIXED satellite system is not allowed here
  612.                                                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  613.                                                                           lineNumber, name, line);
  614.                                         }

  616.                                         observationDataSets.add(new ObservationDataSet(rinexHeader, satelliteSystemSat, prnNumber,
  617.                                                                                        tObs, rcvrClkOffset, observationData));

  619.                                     }
  620.                                 }
  621.                             }
  622.                         }
  623.                         break;
  624.                     }
  625.                     case 3: {

  627.                         final int                   MAX_OBS_TYPES_PER_LINE_RNX3 = 13;
  628.                         final int           MAX_OBS_TYPES_SCALE_FACTOR_PER_LINE = 12;
  629.                         final int                    MAX_N_SAT_PHSHIFT_PER_LINE = 10;

  631.                         final List<ObservationType>                       typeObs                = new ArrayList<>();
  632.                         String                                            sigStrengthUnit        = null;
  633.                         int                                               leapSecondsFuture      = 0;
  634.                         int                                               leapSecondsWeekNum     = 0;
  635.                         int                                               leapSecondsDayNum      = 0;
  636.                         final List<AppliedDCBS>                           listAppliedDCBs        = new ArrayList<>();
  637.                         final List<AppliedPCVS>                           listAppliedPCVS        = new ArrayList<>();
  638.                         SatelliteSystem                                   satSystemScaleFactor   = null;
  639.                         String[]                                          satsPhaseShift         = null;
  640.                         int                                               nbSatPhaseShift        = 0;
  641.                         SatelliteSystem                                   satSystemPhaseShift    = null;
  642.                         double                                            corrPhaseShift         = 0.0;
  643.                         final List<PhaseShiftCorrection>                  phaseShiftCorrections  = new ArrayList<>();
  644.                         ObservationType                                   phaseShiftTypeObs      = null;


  647.                         for (line = reader.readLine(); line != null; line = reader.readLine()) {
  648.                             ++lineNumber;
  649.                             if (rinexHeader == null) {
  650.                                 switch(line.substring(LABEL_START).trim()) {
  651.                                     case RINEX_VERSION_TYPE : {
  652.                                         formatVersion = parseDouble(line, 0, 9);
  653.                                         format100     = (int) FastMath.rint(100 * formatVersion);
  654.                                         if ((format100 != 300) && (format100 != 301) && (format100 != 302) && (format100 != 303)) {
  655.                                             throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  656.                                         }
  657.                                         //File Type must be Observation_Data
  658.                                         if (!(parseString(line, 20, 1)).equals(FILE_TYPE)) {
  659.                                             throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  660.                                         }
  661.                                         satelliteSystem = SatelliteSystem.parseSatelliteSystem(parseString(line, 40, 1));
  662.                                         inRinexVersion = true;
  663.                                     }
  664.                                         break;
  665.                                     case COMMENT :
  666.                                         // nothing to do
  667.                                         break;
  668.                                     case PGM_RUN_BY_DATE :
  669.                                         inRunBy = true;
  670.                                         break;
  671.                                     case MARKER_NAME :
  672.                                         markerName = parseString(line, 0, 60);
  673.                                         inMarkerName = true;
  674.                                         break;
  675.                                     case MARKER_NUMBER :
  676.                                         markerNumber = parseString(line, 0, 20);
  677.                                         break;
  678.                                     case MARKER_TYPE :
  679.                                         markerType = parseString(line, 0, 20);
  680.                                         inMarkerType = true;
  681.                                         //Could be done with an Enumeration
  682.                                         break;
  683.                                     case OBSERVER_AGENCY :
  684.                                         observerName = parseString(line, 0, 20);
  685.                                         agencyName   = parseString(line, 20, 40);
  686.                                         inObserver = true;
  687.                                         break;
  688.                                     case REC_NB_TYPE_VERS :
  689.                                         receiverNumber  = parseString(line, 0, 20);
  690.                                         receiverType    = parseString(line, 20, 20);
  691.                                         receiverVersion = parseString(line, 40, 20);
  692.                                         inRecType = true;
  693.                                         break;
  694.                                     case ANT_NB_TYPE :
  695.                                         antennaNumber = parseString(line, 0, 20);
  696.                                         antennaType   = parseString(line, 20, 20);
  697.                                         inAntType = true;
  698.                                         break;
  699.                                     case APPROX_POSITION_XYZ :
  700.                                         approxPos = new Vector3D(parseDouble(line, 0, 14),
  701.                                                                  parseDouble(line, 14, 14),
  702.                                                                  parseDouble(line, 28, 14));
  703.                                         inAproxPos = true;
  704.                                         break;
  705.                                     case ANTENNA_DELTA_H_E_N :
  706.                                         antHeight = parseDouble(line, 0, 14);
  707.                                         eccentricities = new Vector2D(parseDouble(line, 14, 14),
  708.                                                                       parseDouble(line, 28, 14));
  709.                                         inAntDelta = true;
  710.                                         break;
  711.                                     case ANTENNA_DELTA_X_Y_Z :
  712.                                         antRefPoint = new Vector3D(parseDouble(line, 0, 14),
  713.                                                                    parseDouble(line, 14, 14),
  714.                                                                    parseDouble(line, 28, 14));
  715.                                         break;
  716.                                     case ANTENNA_PHASECENTER :
  717.                                         obsCode = parseString(line, 2, 3);
  718.                                         antPhaseCenter = new Vector3D(parseDouble(line, 5, 9),
  719.                                                                       parseDouble(line, 14, 14),
  720.                                                                       parseDouble(line, 28, 14));
  721.                                         break;
  722.                                     case ANTENNA_B_SIGHT_XYZ :
  723.                                         antBSight = new Vector3D(parseDouble(line, 0, 14),
  724.                                                                  parseDouble(line, 14, 14),
  725.                                                                  parseDouble(line, 28, 14));
  726.                                         break;
  727.                                     case ANTENNA_ZERODIR_AZI :
  728.                                         antAzi = parseDouble(line, 0, 14);
  729.                                         break;
  730.                                     case ANTENNA_ZERODIR_XYZ :
  731.                                         antZeroDir = new Vector3D(parseDouble(line, 0, 14),
  732.                                                                   parseDouble(line, 14, 14),
  733.                                                                   parseDouble(line, 28, 14));
  734.                                         break;
  735.                                     case CENTER_OF_MASS_XYZ :
  736.                                         centerMass = new Vector3D(parseDouble(line, 0, 14),
  737.                                                                   parseDouble(line, 14, 14),
  738.                                                                   parseDouble(line, 28, 14));
  739.                                         break;
  740.                                     case NB_OF_SATELLITES :
  741.                                         nbSat = parseInt(line, 0, 6);
  742.                                         break;
  743.                                     case RCV_CLOCK_OFFS_APPL :
  744.                                         clkOffset = parseInt(line, 0, 6);
  745.                                         break;
  746.                                     case INTERVAL :
  747.                                         interval = parseDouble(line, 0, 10);
  748.                                         break;
  749.                                     case TIME_OF_FIRST_OBS :
  750.                                         switch(satelliteSystem) {
  751.                                             case GPS:
  752.                                                 timeScale = TimeScalesFactory.getGPS();
  753.                                                 break;
  754.                                             case GALILEO:
  755.                                                 timeScale = TimeScalesFactory.getGST();
  756.                                                 break;
  757.                                             case GLONASS:
  758.                                                 timeScale = TimeScalesFactory.getGLONASS();
  759.                                                 break;
  760.                                             case QZSS:
  761.                                                 timeScale = TimeScalesFactory.getQZSS();
  762.                                                 break;
  763.                                             case BEIDOU:
  764.                                                 timeScale = TimeScalesFactory.getBDT();
  765.                                                 break;
  766.                                             case IRNSS:
  767.                                                 timeScale = TimeScalesFactory.getIRNSS();
  768.                                                 break;
  769.                                             case MIXED:
  770.                                                 //in Case of Mixed data, Timescale must be specified in the Time of First line
  771.                                                 timeScaleStr = parseString(line, 48, 3);

  773.                                                 if (timeScaleStr.equals(GPS)) {
  774.                                                     timeScale = TimeScalesFactory.getGPS();
  775.                                                 } else if (timeScaleStr.equals(GAL)) {
  776.                                                     timeScale = TimeScalesFactory.getGST();
  777.                                                 } else if (timeScaleStr.equals(GLO)) {
  778.                                                     timeScale = TimeScalesFactory.getGLONASS();
  779.                                                 } else if (timeScaleStr.equals(QZS)) {
  780.                                                     timeScale = TimeScalesFactory.getQZSS();
  781.                                                 } else if (timeScaleStr.equals(BDT)) {
  782.                                                     timeScale = TimeScalesFactory.getBDT();
  783.                                                 } else if (timeScaleStr.equals(IRN)) {
  784.                                                     timeScale = TimeScalesFactory.getIRNSS();
  785.                                                 } else {
  786.                                                     throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  787.                                                 }
  788.                                                 break;
  789.                                             default :
  790.                                                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  791.                                                                           lineNumber, name, line);
  792.                                         }

  794.                                         tFirstObs = new AbsoluteDate(parseInt(line, 0, 6),
  795.                                                                      parseInt(line, 6, 6),
  796.                                                                      parseInt(line, 12, 6),
  797.                                                                      parseInt(line, 18, 6),
  798.                                                                      parseInt(line, 24, 6),
  799.                                                                      parseDouble(line, 30, 13), timeScale);
  800.                                         inFirstObs = true;
  801.                                         break;
  802.                                     case TIME_OF_LAST_OBS :
  803.                                         tLastObs = new AbsoluteDate(parseInt(line, 0, 6),
  804.                                                                     parseInt(line, 6, 6),
  805.                                                                     parseInt(line, 12, 6),
  806.                                                                     parseInt(line, 18, 6),
  807.                                                                     parseInt(line, 24, 6),
  808.                                                                     parseDouble(line, 30, 13), timeScale);
  809.                                         break;
  810.                                     case LEAP_SECONDS :
  811.                                         leapSeconds = parseInt(line, 0, 6);
  812.                                         leapSecondsFuture = parseInt(line, 6, 6);
  813.                                         leapSecondsWeekNum = parseInt(line, 12, 6);
  814.                                         leapSecondsDayNum = parseInt(line, 18, 6);
  815.                                         //Time System Identifier must be added, last A3 String
  816.                                         break;
  817.                                     case PRN_NB_OF_OBS :
  818.                                         //Optional line in header, indicates number of Observations par Satellite
  819.                                         //Not stored for now
  820.                                         break;
  821.                                     case SYS_NB_OBS_TYPES :
  822.                                         obsTypesSystem = null;
  823.                                         typeObs.clear();

  825.                                         obsTypesSystem = SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1));
  826.                                         nbTypes = parseInt(line, 3, 3);

  828.                                         final int nbLinesTypesObs = (nbTypes + MAX_OBS_TYPES_PER_LINE_RNX3 - 1) / MAX_OBS_TYPES_PER_LINE_RNX3;
  829.                                         for (int j = 0; j < nbLinesTypesObs; j++) {
  830.                                             if (j > 0) {
  831.                                                 line = reader.readLine(); //Next line
  832.                                                 lineNumber++;
  833.                                             }
  834.                                             final int iMax = FastMath.min(MAX_OBS_TYPES_PER_LINE_RNX3, nbTypes - typeObs.size());
  835.                                             for (int i = 0; i < iMax; i++) {
  836.                                                 try {
  837.                                                     typeObs.add(ObservationType.valueOf(parseString(line, 7 + (4 * i), 3)));
  838.                                                 } catch (IllegalArgumentException iae) {
  839.                                                     throw new OrekitException(OrekitMessages.UNKNOWN_RINEX_FREQUENCY,
  840.                                                                               parseString(line, 7 + (4 * i), 3), name, lineNumber);
  841.                                                 }
  842.                                             }
  843.                                         }
  844.                                         listTypeObs.put(obsTypesSystem, new ArrayList<>(typeObs));
  845.                                         inTypesObs = true;
  846.                                         break;
  847.                                     case SIGNAL_STRENGTH_UNIT :
  848.                                         sigStrengthUnit = parseString(line, 0, 20);
  849.                                         break;
  850.                                     case SYS_DCBS_APPLIED :

  852.                                         listAppliedDCBs.add(new AppliedDCBS(SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1)),
  853.                                                                             parseString(line, 2, 17), parseString(line, 20, 40)));
  854.                                         break;
  855.                                     case SYS_PCVS_APPLIED :

  857.                                         listAppliedPCVS.add(new AppliedPCVS(SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1)),
  858.                                                                             parseString(line, 2, 17), parseString(line, 20, 40)));
  859.                                         break;
  860.                                     case SYS_SCALE_FACTOR :
  861.                                         satSystemScaleFactor  = null;
  862.                                         scaleFactor           = 1;
  863.                                         nbObsScaleFactor      = 0;

  865.                                         satSystemScaleFactor = SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1));
  866.                                         scaleFactor          = parseInt(line, 2, 4);
  867.                                         nbObsScaleFactor     = parseInt(line, 8, 2);
  868.                                         final List<ObservationType> typesObsScaleFactor = new ArrayList<>(nbObsScaleFactor);

  870.                                         if (nbObsScaleFactor == 0) {
  871.                                             typesObsScaleFactor.addAll(listTypeObs.get(satSystemScaleFactor));
  872.                                         } else {
  873.                                             final int nbLinesTypesObsScaleFactor = (nbObsScaleFactor + MAX_OBS_TYPES_SCALE_FACTOR_PER_LINE - 1) /
  874.                                                                                    MAX_OBS_TYPES_SCALE_FACTOR_PER_LINE;
  875.                                             for (int j = 0; j < nbLinesTypesObsScaleFactor; j++) {
  876.                                                 if ( j > 0) {
  877.                                                     line = reader.readLine(); //Next line
  878.                                                     lineNumber++;
  879.                                                 }
  880.                                                 final int iMax = FastMath.min(MAX_OBS_TYPES_SCALE_FACTOR_PER_LINE, nbObsScaleFactor - typesObsScaleFactor.size());
  881.                                                 for (int i = 0; i < iMax; i++) {
  882.                                                     typesObsScaleFactor.add(ObservationType.valueOf(parseString(line, 11 + (4 * i), 3)));
  883.                                                 }
  884.                                             }
  885.                                         }

  887.                                         scaleFactorCorrections.add(new ScaleFactorCorrection(satSystemScaleFactor,
  888.                                                                                              scaleFactor, typesObsScaleFactor));
  889.                                         break;
  890.                                     case SYS_PHASE_SHIFT :

  892.                                         nbSatPhaseShift     = 0;
  893.                                         satsPhaseShift      = null;
  894.                                         corrPhaseShift      = 0.0;
  895.                                         phaseShiftTypeObs   = null;
  896.                                         satSystemPhaseShift = null;

  898.                                         satSystemPhaseShift = SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1));
  899.                                         phaseShiftTypeObs = ObservationType.valueOf(parseString(line, 2, 3));
  900.                                         nbSatPhaseShift = parseInt(line, 16, 2);
  901.                                         corrPhaseShift = parseDouble(line, 6, 8);

  903.                                         if (nbSatPhaseShift == 0) {
  904.                                             //If nbSat with Phase Shift is not indicated: all the satellites are affected for this Obs Type
  905.                                         } else {
  906.                                             satsPhaseShift = new String[nbSatPhaseShift];
  907.                                             final int nbLinesSatPhaseShift = (nbSatPhaseShift + MAX_N_SAT_PHSHIFT_PER_LINE - 1) / MAX_N_SAT_PHSHIFT_PER_LINE;
  908.                                             for (int j = 0; j < nbLinesSatPhaseShift; j++) {
  909.                                                 if (j > 0) {
  910.                                                     line = reader.readLine(); //Next line
  911.                                                     lineNumber++;
  912.                                                 }
  913.                                                 final int iMax = FastMath.min(MAX_N_SAT_PHSHIFT_PER_LINE, nbSatPhaseShift - j * MAX_N_SAT_PHSHIFT_PER_LINE);
  914.                                                 for (int i = 0; i < iMax; i++) {
  915.                                                     satsPhaseShift[i + 10 * j] = parseString(line, 19 + 4 * i, 3);
  916.                                                 }
  917.                                             }
  918.                                         }
  919.                                         phaseShiftCorrections.add(new PhaseShiftCorrection(satSystemPhaseShift,
  920.                                                                                            phaseShiftTypeObs,
  921.                                                                                            corrPhaseShift,
  922.                                                                                            satsPhaseShift));
  923.                                         inPhaseShift = true;
  924.                                         break;
  925.                                     case GLONASS_SLOT_FRQ_NB :
  926.                                         //Not defined yet
  927.                                         inGlonassSlot = true;
  928.                                         break;
  929.                                     case GLONASS_COD_PHS_BIS :
  930.                                         //Not defined yet
  931.                                         inGlonassCOD = true;
  932.                                         break;
  933.                                     case END_OF_HEADER :
  934.                                         //We make sure that we have read all the mandatory fields inside the header of the Rinex
  935.                                         if (!inRinexVersion || !inRunBy || !inMarkerName ||
  936.                                             !inMarkerType || !inObserver || !inRecType || !inAntType ||
  937.                                             !inAproxPos || !inAntDelta || !inTypesObs || !inFirstObs ||
  938.                                             (formatVersion >= 3.01 && !inPhaseShift) ||
  939.                                             (formatVersion >= 3.03 && (!inGlonassSlot || !inGlonassCOD))) {
  940.                                             throw new OrekitException(OrekitMessages.INCOMPLETE_HEADER, name);
  941.                                         }

  943.                                         //Header information gathered
  944.                                         rinexHeader = new RinexHeader(formatVersion, satelliteSystem,
  945.                                                                       markerName, markerNumber, markerType,
  946.                                                                       observerName, agencyName, receiverNumber,
  947.                                                                       receiverType, receiverVersion, antennaNumber,
  948.                                                                       antennaType, approxPos, antHeight, eccentricities,
  949.                                                                       antRefPoint, obsCode, antPhaseCenter, antBSight,
  950.                                                                       antAzi, antZeroDir, centerMass, sigStrengthUnit,
  951.                                                                       interval, tFirstObs, tLastObs, clkOffset, listAppliedDCBs,
  952.                                                                       listAppliedPCVS, phaseShiftCorrections, leapSeconds,
  953.                                                                       leapSecondsFuture, leapSecondsWeekNum, leapSecondsDayNum);
  954.                                         break;
  955.                                     default :
  956.                                         if (rinexHeader == null) {
  957.                                             //There must be an error due to an unknown Label inside the Header
  958.                                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  959.                                                                       lineNumber, name, line);
  960.                                         }
  961.                                 }
  962.                             } else {
  963.                                 //If End of Header

  965.                                 //Start of a new Observation
  966.                                 rcvrClkOffset     =  0;
  967.                                 eventFlag         = -1;
  968.                                 nbSatObs          = -1;
  969.                                 tObs              = null;

  971.                                 //A line that starts with ">" correspond to a new observation epoch
  972.                                 if (parseString(line, 0, 1).equals(">")) {

  974.                                     eventFlag = parseInt(line, 31, 1);
  975.                                     //If eventFlag>1, we skip the corresponding lines to the next observation
  976.                                     if (eventFlag != 0) {
  977.                                         final int nbLinesSkip = parseInt(line, 32, 3);
  978.                                         for (int i = 0; i < nbLinesSkip; i++) {
  979.                                             line = reader.readLine();
  980.                                             lineNumber++;
  981.                                         }
  982.                                     } else {

  984.                                         tObs = new AbsoluteDate(parseInt(line, 2, 4),
  985.                                                                 parseInt(line, 6, 3),
  986.                                                                 parseInt(line, 9, 3),
  987.                                                                 parseInt(line, 12, 3),
  988.                                                                 parseInt(line, 15, 3),
  989.                                                                 parseDouble(line, 18, 11), timeScale);

  991.                                         nbSatObs  = parseInt(line, 32, 3);
  992.                                         //If the total number of satellites was indicated in the Header
  993.                                         if (nbSat != -1 && nbSatObs > nbSat) {
  994.                                             //we check that the number of Sat in the observation is consistent
  995.                                             throw new OrekitException(OrekitMessages.INCONSISTENT_NUMBER_OF_SATS,
  996.                                                                       lineNumber, name, nbSatObs, nbSat);
  997.                                         }
  998.                                         //Read the Receiver Clock offset, if present
  999.                                         rcvrClkOffset = parseDouble(line, 41, 15);
  1000.                                         if (Double.isNaN(rcvrClkOffset)) {
  1001.                                             rcvrClkOffset = 0.0;
  1002.                                         }

  1004.                                         //For each one of the Satellites in this Observation
  1005.                                         for (int i = 0; i < nbSatObs; i++) {

  1007.                                             line = reader.readLine();
  1008.                                             lineNumber++;

  1010.                                             //We check that the Satellite type is consistent with Satellite System in the top of the file
  1011.                                             final SatelliteSystem satelliteSystemSat = SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1));
  1012.                                             if (!satelliteSystem.equals(SatelliteSystem.MIXED)) {
  1013.                                                 if (!satelliteSystemSat.equals(satelliteSystem)) {
  1014.                                                     throw new OrekitException(OrekitMessages.INCONSISTENT_SATELLITE_SYSTEM,
  1015.                                                                               lineNumber, name, satelliteSystem, satelliteSystemSat);
  1016.                                                 }
  1017.                                             }

  1019.                                             final int prn = parseInt(line, 1, 2);
  1020.                                             final int prnNumber;
  1021.                                             switch (satelliteSystemSat) {
  1022.                                                 case GPS:
  1023.                                                 case GLONASS:
  1024.                                                 case GALILEO:
  1025.                                                 case BEIDOU:
  1026.                                                 case IRNSS:
  1027.                                                     prnNumber = prn;
  1028.                                                     break;
  1029.                                                 case QZSS:
  1030.                                                     prnNumber = prn + 192;
  1031.                                                     break;
  1032.                                                 case SBAS:
  1033.                                                     prnNumber = prn + 100;
  1034.                                                     break;
  1035.                                                 default:
  1036.                                                     // MIXED satellite system is not allowed here
  1037.                                                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  1038.                                                                               lineNumber, name, line);
  1039.                                             }
  1040.                                             final List<ObservationData> observationData = new ArrayList<>(nbSatObs);
  1041.                                             for (int j = 0; j < listTypeObs.get(satelliteSystemSat).size(); j++) {
  1042.                                                 final ObservationType rf = listTypeObs.get(satelliteSystemSat).get(j);
  1043.                                                 boolean scaleFactorFound = false;
  1044.                                                 //We look for the lines of ScaledFactorCorrections that correspond to this SatSystem
  1045.                                                 int k = 0;
  1046.                                                 double value = parseDouble(line, 3 + j * 16, 14);
  1047.                                                 while (k < scaleFactorCorrections.size() && !scaleFactorFound) {
  1048.                                                     if (scaleFactorCorrections.get(k).getSatelliteSystem().equals(satelliteSystemSat)) {
  1049.                                                         //We check if the next Observation Type to read needs to be scaled
  1050.                                                         if (scaleFactorCorrections.get(k).getTypesObsScaled().contains(rf)) {
  1051.                                                             value /= scaleFactorCorrections.get(k).getCorrection();
  1052.                                                             scaleFactorFound = true;
  1053.                                                         }
  1054.                                                     }
  1055.                                                     k++;
  1056.                                                 }
  1057.                                                 observationData.add(new ObservationData(rf,
  1058.                                                                                         value,
  1059.                                                                                         parseInt(line, 17 + j * 16, 1),
  1060.                                                                                         parseInt(line, 18 + j * 16, 1)));
  1061.                                             }
  1062.                                             observationDataSets.add(new ObservationDataSet(rinexHeader, satelliteSystemSat, prnNumber,
  1063.                                                                                            tObs, rcvrClkOffset, observationData));

  1065.                                         }
  1066.                                     }
  1067.                                 }
  1068.                             }
  1069.                         }
  1070.                         break;
  1071.                     }
  1072.                     default:
  1073.                         //If RINEX Version is neither 2 nor 3
  1074.                         throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  1075.                 }
  1076.             }
  1077.         }


  1080.         /** Extract a string from a line.
  1081.          * @param line to parse
  1082.          * @param start start index of the string
  1083.          * @param length length of the string
  1084.          * @return parsed string
  1085.          */
  1086.         private String parseString(final String line, final int start, final int length) {
  1087.             if (line.length() > start) {
  1088.                 return line.substring(start, FastMath.min(line.length(), start + length)).trim();
  1089.             } else {
  1090.                 return null;
  1091.             }
  1092.         }

  1094.         /** Extract an integer from a line.
  1095.          * @param line to parse
  1096.          * @param start start index of the integer
  1097.          * @param length length of the integer
  1098.          * @return parsed integer
  1099.          */
  1100.         private int parseInt(final String line, final int start, final int length) {
  1101.             if (line.length() > start && !parseString(line, start, length).isEmpty()) {
  1102.                 return Integer.parseInt(parseString(line, start, length));
  1103.             } else {
  1104.                 return 0;
  1105.             }
  1106.         }

  1108.         /** Extract a double from a line.
  1109.          * @param line to parse
  1110.          * @param start start index of the real
  1111.          * @param length length of the real
  1112.          * @return parsed real, or {@code Double.NaN} if field was empty
  1113.          */
  1114.         private double parseDouble(final String line, final int start, final int length) {
  1115.             if (line.length() > start && !parseString(line, start, length).isEmpty()) {
  1116.                 return Double.parseDouble(parseString(line, start, length));
  1117.             } else {
  1118.                 return Double.NaN;
  1119.             }
  1120.         }

  1122.         /** Phase Shift corrections.
  1123.          * Contains the phase shift corrections used to
  1124.          * generate phases consistent with respect to cycle shifts.
  1125.          */
  1126.         public class PhaseShiftCorrection {

  1128.             /** Satellite System. */
  1129.             private final SatelliteSystem satSystemPhaseShift;
  1130.             /** Carrier Phase Observation Code. */
  1131.             private final ObservationType typeObsPhaseShift;
  1132.             /** Phase Shift Corrections (cycles). */
  1133.             private final double phaseShiftCorrection;
  1134.             /** List of satellites involved. */
  1135.             private final String[] satsPhaseShift;

  1137.             /** Simple constructor.
  1138.              * @param satSystemPhaseShift Satellite System
  1139.              * @param typeObsPhaseShift Carrier Phase Observation Code
  1140.              * @param phaseShiftCorrection Phase Shift Corrections (cycles)
  1141.              * @param satsPhaseShift List of satellites involved
  1142.              */
  1143.             private PhaseShiftCorrection(final SatelliteSystem satSystemPhaseShift,
  1144.                                          final ObservationType typeObsPhaseShift,
  1145.                                          final double phaseShiftCorrection, final String[] satsPhaseShift) {
  1146.                 this.satSystemPhaseShift = satSystemPhaseShift;
  1147.                 this.typeObsPhaseShift = typeObsPhaseShift;
  1148.                 this.phaseShiftCorrection = phaseShiftCorrection;
  1149.                 this.satsPhaseShift = satsPhaseShift;
  1150.             }

  1152.             /** Get the Satellite System.
  1153.              * @return Satellite System.
  1154.              */
  1155.             public SatelliteSystem getSatelliteSystem() {
  1156.                 return satSystemPhaseShift;
  1157.             }
  1158.             /** Get the Carrier Phase Observation Code.
  1159.              * @return Carrier Phase Observation Code.
  1160.              */
  1161.             public ObservationType getTypeObs() {
  1162.                 return typeObsPhaseShift;
  1163.             }
  1164.             /** Get the Phase Shift Corrections.
  1165.              * @return Phase Shift Corrections (cycles)
  1166.              */
  1167.             public double getCorrection() {
  1168.                 return phaseShiftCorrection;
  1169.             }
  1170.             /** Get the list of satellites involved.
  1171.              * @return List of satellites involved (if null, all the sats are involved)
  1172.              */
  1173.             public String[] getSatsCorrected() {
  1174.                 //If empty, all the satellites of this constellation are affected for this Observation type
  1175.                 return satsPhaseShift;
  1176.             }
  1177.         }

  1179.         /** Scale Factor to be applied.
  1180.          * Contains the scale factors of 10 applied to the data before
  1181.          * being stored into the RINEX file.
  1182.          */
  1183.         public class ScaleFactorCorrection {

  1185.             /** Satellite System. */
  1186.             private final SatelliteSystem satSystemScaleFactor;
  1187.             /** List of Observations types that have been scaled. */
  1188.             private final List<ObservationType> typesObsScaleFactor;
  1189.             /** Factor to divide stored observations with before use. */
  1190.             private final double scaleFactor;

  1192.             /** Simple constructor.
  1193.              * @param satSystemScaleFactor Satellite System
  1194.              * @param scaleFactor Factor to divide stored observations (1,10,100,1000)
  1195.              * @param typesObsScaleFactor List of Observations types that have been scaled
  1196.              */
  1197.             private ScaleFactorCorrection(final SatelliteSystem satSystemScaleFactor,
  1198.                                           final double scaleFactor,
  1199.                                           final List<ObservationType> typesObsScaleFactor) {
  1200.                 this.satSystemScaleFactor = satSystemScaleFactor;
  1201.                 this.scaleFactor = scaleFactor;
  1202.                 this.typesObsScaleFactor = typesObsScaleFactor;
  1203.             }
  1204.             /** Get the Satellite System.
  1205.              * @return Satellite System
  1206.              */
  1207.             public SatelliteSystem getSatelliteSystem() {
  1208.                 return satSystemScaleFactor;
  1209.             }
  1210.             /** Get the Scale Factor.
  1211.              * @return Scale Factor
  1212.              */
  1213.             public double getCorrection() {
  1214.                 return scaleFactor;
  1215.             }
  1216.             /** Get the list of Observation Types scaled.
  1217.              * @return List of Observation types scaled
  1218.              */
  1219.             public List<ObservationType> getTypesObsScaled() {
  1220.                 return typesObsScaleFactor;
  1221.             }
  1222.         }

  1224.         /** Corrections of Differential Code Biases (DCBs) applied.
  1225.          * Contains information on the programs used to correct the observations
  1226.          * in RINEX files for differential code biases.
  1227.          */
  1228.         public class AppliedDCBS {

  1230.             /** Satellite system. */
  1231.             private final SatelliteSystem satelliteSystem;

  1233.             /** Program name used to apply differential code bias corrections. */
  1234.             private final String progDCBS;

  1236.             /** Source of corrections (URL). */
  1237.             private final String sourceDCBS;

  1239.             /** Simple constructor.
  1240.              * @param satelliteSystem satellite system
  1241.              * @param progDCBS Program name used to apply DCBs
  1242.              * @param sourceDCBS Source of corrections (URL)
  1243.              */
  1244.             private AppliedDCBS(final SatelliteSystem satelliteSystem,
  1245.                                 final String progDCBS, final String sourceDCBS) {
  1246.                 this.satelliteSystem = satelliteSystem;
  1247.                 this.progDCBS        = progDCBS;
  1248.                 this.sourceDCBS      = sourceDCBS;
  1249.             }

  1251.             /** Get the satellite system.
  1252.              * @return satellite system
  1253.              */
  1254.             public SatelliteSystem getSatelliteSystem() {
  1255.                 return satelliteSystem;
  1256.             }

  1258.             /** Get the program name used to apply DCBs.
  1259.              * @return  Program name used to apply DCBs
  1260.              */
  1261.             public String getProgDCBS() {
  1262.                 return progDCBS;
  1263.             }

  1265.             /** Get the source of corrections.
  1266.              * @return Source of corrections (URL)
  1267.              */
  1268.             public String getSourceDCBS() {
  1269.                 return sourceDCBS;
  1270.             }

  1272.         }

  1274.         /** Corrections of antenna phase center variations (PCVs) applied.
  1275.          * Contains information on the programs used to correct the observations
  1276.          * in RINEX files for antenna phase center variations.
  1277.          */
  1278.         public class AppliedPCVS {

  1280.             /** Satellite system. */
  1281.             private final SatelliteSystem satelliteSystem;

  1283.             /** Program name used to antenna center variation corrections. */
  1284.             private final String progPCVS;

  1286.             /** Source of corrections (URL). */
  1287.             private final String sourcePCVS;

  1289.             /** Simple constructor.
  1290.              * @param satelliteSystem satellite system
  1291.              * @param progPCVS Program name used for PCVs
  1292.              * @param sourcePCVS Source of corrections (URL)
  1293.              */
  1294.             private AppliedPCVS(final SatelliteSystem satelliteSystem,
  1295.                                 final String progPCVS, final String sourcePCVS) {
  1296.                 this.satelliteSystem = satelliteSystem;
  1297.                 this.progPCVS        = progPCVS;
  1298.                 this.sourcePCVS      = sourcePCVS;
  1299.             }

  1301.             /** Get the satellite system.
  1302.              * @return satellite system
  1303.              */
  1304.             public SatelliteSystem getSatelliteSystem() {
  1305.                 return satelliteSystem;
  1306.             }

  1308.             /** Get the program name used to apply PCVs.
  1309.              * @return  Program name used to apply PCVs
  1310.              */
  1311.             public String getProgPCVS() {
  1312.                 return progPCVS;
  1313.             }

  1315.             /** Get the source of corrections.
  1316.              * @return Source of corrections (URL)
  1317.              */
  1318.             public String getSourcePCVS() {
  1319.                 return sourcePCVS;
  1320.             }

  1322.         }
  1323.     }

  1325. }
Created with JaCoCo 0.8.2.201808211720