SinexLoader.java

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

  19. import java.io.BufferedInputStream;
  20. import java.io.BufferedReader;
  21. import java.io.IOException;
  22. import java.io.InputStream;
  23. import java.io.InputStreamReader;
  24. import java.nio.charset.StandardCharsets;
  25. import java.text.ParseException;
  26. import java.util.ArrayList;
  27. import java.util.Arrays;
  28. import java.util.Collections;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;
  32. import java.util.SortedSet;
  33. import java.util.TreeSet;
  34. import java.util.regex.Matcher;
  35. import java.util.regex.Pattern;

  37. import org.hipparchus.exception.DummyLocalizable;
  38. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  39. import org.hipparchus.util.FastMath;
  40. import org.orekit.annotation.DefaultDataContext;
  41. import org.orekit.data.DataContext;
  42. import org.orekit.data.DataLoader;
  43. import org.orekit.data.DataProvidersManager;
  44. import org.orekit.data.DataSource;
  45. import org.orekit.errors.OrekitException;
  46. import org.orekit.errors.OrekitMessages;
  47. import org.orekit.files.sinex.Station.ReferenceSystem;
  48. import org.orekit.frames.EOPEntry;
  49. import org.orekit.frames.EopHistoryLoader;
  50. import org.orekit.frames.ITRFVersion;
  51. import org.orekit.gnss.SatelliteSystem;
  52. import org.orekit.gnss.TimeSystem;
  53. import org.orekit.time.AbsoluteDate;
  54. import org.orekit.time.ChronologicalComparator;
  55. import org.orekit.time.DateComponents;
  56. import org.orekit.time.TimeScale;
  57. import org.orekit.time.TimeScales;
  58. import org.orekit.time.TimeStamped;
  59. import org.orekit.utils.Constants;
  60. import org.orekit.utils.IERSConventions;
  61. import org.orekit.utils.IERSConventions.NutationCorrectionConverter;
  62. import org.orekit.utils.units.Unit;

  64. /**
  65.  * Loader for Solution INdependent EXchange (SINEX) files.
  66.  * <p>
  67.  * The loader can be used to load several data types contained in Sinex files.
  68.  * The current supported data are: station coordinates, site eccentricities, EOP, and Difference Code Bias (DCB).
  69.  * Several instances of Sinex loader must be created in order to parse different data types.
  70.  * </p>
  71.  * <p>
  72.  * The parsing of EOP parameters for multiple files in different SinexLoader object, fed into the default DataContext
  73.  * might pose a problem in case validity dates are overlapping. As Sinex daily solution files provide a single EOP entry,
  74.  * the Sinex loader will add points at the limits of data dates (startDate, endDate) of the Sinex file, which in case of
  75.  * overlap will lead to inconsistencies in the final EOPHistory object. Multiple files can be parsed using a single SinexLoader
  76.  * with a regex to overcome this issue.
  77.  * </p>
  78.  * @author Bryan Cazabonne
  79.  * @since 10.3
  80.  */
  81. public class SinexLoader implements EopHistoryLoader {

  83.     /** Length of day. */
  84.     private static final String LOD = "LOD";

  86.     /** UT1-UTC. */
  87.     private static final String UT = "UT";

  89.     /** X polar motion. */
  90.     private static final String XPO = "XPO";

  92.     /** Y polar motion. */
  93.     private static final String YPO = "YPO";

  95.     /** Nutation correction in longitude. */
  96.     private static final String NUT_LN = "NUT_LN";

  98.     /** Nutation correction in obliquity. */
  99.     private static final String NUT_OB = "NUT_OB";

  101.     /** Nutation correction X. */
  102.     private static final String NUT_X = "NUT_X";

  104.     /** Nutation correction Y. */
  105.     private static final String NUT_Y = "NUT_Y";

  107.     /** 00:000:00000 epoch. */
  108.     private static final String DEFAULT_EPOCH_TWO_DIGITS = "00:000:00000";

  110.     /** 0000:000:00000 epoch. */
  111.     private static final String DEFAULT_EPOCH_FOUR_DIGITS = "0000:000:00000";

  113.     /** Pattern for delimiting regular expressions. */
  114.     private static final Pattern SEPARATOR = Pattern.compile(":");

  116.     /** Pattern for regular data. */
  117.     private static final Pattern PATTERN_SPACE = Pattern.compile("\\s+");

  119.     /** Pattern to check beginning of SINEX files.*/
  120.     private static final Pattern PATTERN_BEGIN = Pattern.compile("%=(?:SNX|BIA) \\d\\.\\d\\d ..." +
  121.                                                                  " (\\d{2,4}:\\d{3}:\\d{5}) ..." +
  122.                                                                  " (\\d{2,4}:\\d{3}:\\d{5}) (\\d{2,4}:\\d{3}:\\d{5})" +
  123.                                                                  " . .*");

  125.     /** List of all EOP parameter types. */
  126.     private static final List<String> EOP_TYPES = Arrays.asList(LOD, UT, XPO, YPO, NUT_LN, NUT_OB, NUT_X, NUT_Y);

  128.     /** Start time of the data used in the Sinex solution.*/
  129.     private AbsoluteDate startDate;

  131.     /** End time of the data used in the Sinex solution.*/
  132.     private AbsoluteDate endDate;

  134.     /** SINEX file creation date as extracted for the first line. */
  135.     private AbsoluteDate creationDate;

  137.     /** Station data.
  138.      * Key: Site code
  139.      */
  140.     private final Map<String, Station> stations;

  142.     /**
  143.      * DCB data.
  144.      * Key: Site code
  145.      */
  146.     private final Map<String, DcbStation> dcbStations;

  148.     /**
  149.      * DCB data.
  150.      * Key: Satellite PRN
  151.      */
  152.     private final Map<String, DcbSatellite> dcbSatellites;

  154.     /** DCB description. */
  155.     private final DcbDescription dcbDescription;

  157.     /** Data set. */
  158.     private Map<AbsoluteDate, SinexEopEntry> eop;

  160.     /** ITRF Version used for EOP parsing. */
  161.     private ITRFVersion itrfVersionEop;

  163.     /** Time scales. */
  164.     private final TimeScales scales;

  166.     /** Simple constructor. This constructor uses the {@link DataContext#getDefault()
  167.      * default data context}.
  168.      * @param supportedNames regular expression for supported files names
  169.      * @see #SinexLoader(String, DataProvidersManager, TimeScales)
  170.      */
  171.     @DefaultDataContext
  172.     public SinexLoader(final String supportedNames) {
  173.         this(supportedNames,
  174.              DataContext.getDefault().getDataProvidersManager(),
  175.              DataContext.getDefault().getTimeScales());
  176.     }

  178.     /**
  179.      * Construct a loader by specifying the source of SINEX auxiliary data files.
  180.      * <p>
  181.      * For EOP loading, a default {@link ITRFVersion#ITRF_2014} is used. It is
  182.      * possible to update the version using the {@link #setITRFVersion(int)}
  183.      * method.
  184.      * </p>
  185.      * @param supportedNames regular expression for supported files names
  186.      * @param dataProvidersManager provides access to auxiliary data.
  187.      * @param scales time scales
  188.      */
  189.     public SinexLoader(final String supportedNames,
  190.                        final DataProvidersManager dataProvidersManager,
  191.                        final TimeScales scales) {
  192.         // Common data
  193.         this.scales         = scales;
  194.         this.creationDate   = AbsoluteDate.FUTURE_INFINITY;
  195.         // DCB parameters
  196.         this.dcbDescription = new DcbDescription();
  197.         this.dcbStations    = new HashMap<>();
  198.         this.dcbSatellites  = new HashMap<>();
  199.         // EOP parameters
  200.         this.eop            = new HashMap<>();
  201.         this.itrfVersionEop = ITRFVersion.ITRF_2014;
  202.         // Station data
  203.         this.stations       = new HashMap<>();

  205.         // Read the file
  206.         dataProvidersManager.feed(supportedNames, new Parser());
  207.     }

  209.     /**
  210.      * Simple constructor. This constructor uses the {@link DataContext#getDefault()
  211.      * default data context}.
  212.      * <p>
  213.      * For EOP loading, a default {@link ITRFVersion#ITRF_2014} is used. It is
  214.      * possible to update the version using the {@link #setITRFVersion(int)}
  215.      * method.
  216.      * </p>
  217.      * @param source source for the RINEX data
  218.      * @see #SinexLoader(String, DataProvidersManager, TimeScales)
  219.      */
  220.     @DefaultDataContext
  221.     public SinexLoader(final DataSource source) {
  222.         this(source, DataContext.getDefault().getTimeScales());
  223.     }

  225.     /**
  226.      * Loads SINEX from the given input stream using the specified auxiliary data.
  227.      * <p>
  228.      * For EOP loading, a default {@link ITRFVersion#ITRF_2014} is used. It is
  229.      * possible to update the version using the {@link #setITRFVersion(int)}
  230.      * method.
  231.      * </p>
  232.      * @param source source for the RINEX data
  233.      * @param scales time scales
  234.      */
  235.     public SinexLoader(final DataSource source, final TimeScales scales) {
  236.         try {
  237.             // Common data
  238.             this.scales         = scales;
  239.             this.creationDate   = AbsoluteDate.FUTURE_INFINITY;
  240.             // EOP data
  241.             this.itrfVersionEop = ITRFVersion.ITRF_2014;
  242.             this.eop            = new HashMap<>();
  243.             // DCB data
  244.             this.dcbStations    = new HashMap<>();
  245.             this.dcbSatellites  = new HashMap<>();
  246.             this.dcbDescription = new DcbDescription();
  247.             // Station data
  248.             this.stations       = new HashMap<>();

  250.             // Read the file
  251.             try (InputStream         is  = source.getOpener().openStreamOnce();
  252.                  BufferedInputStream bis = new BufferedInputStream(is)) {
  253.                 new Parser().loadData(bis, source.getName());
  254.             }
  255.         } catch (IOException | ParseException ioe) {
  256.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  257.         }
  258.     }

  260.     /**
  261.      * Set the ITRF version used in EOP entries processing.
  262.      * @param year Year of the ITRF Version used for parsing EOP.
  263.      * @since 11.2
  264.      */
  265.     public void setITRFVersion(final int year) {
  266.         this.itrfVersionEop = ITRFVersion.getITRFVersion(year);
  267.     }

  269.     /**
  270.      * Get the ITRF version used for the EOP entries processing.
  271.      * @return the ITRF Version used for the EOP processing.
  272.      * @since 11.2
  273.      */
  274.     public ITRFVersion getITRFVersion() {
  275.         return itrfVersionEop;
  276.     }

  278.     /**
  279.      * Get the creation date of the parsed SINEX file.
  280.      * @return SINEX file creation date as an AbsoluteDate
  281.      * @since 12.0
  282.      */
  283.     public AbsoluteDate getCreationDate() {
  284.         return creationDate;
  285.     }

  287.     /**
  288.      * Get the file epoch start time.
  289.      * @return the file epoch start time
  290.      * @since 12.0
  291.      */
  292.     public AbsoluteDate getFileEpochStartTime() {
  293.         return startDate;
  294.     }

  296.     /**
  297.      * Get the file epoch end time.
  298.      * @return the file epoch end time
  299.      * @since 12.0
  300.      */
  301.     public AbsoluteDate getFileEpochEndTime() {
  302.         return endDate;
  303.     }

  305.     /**
  306.      * Get the parsed station data.
  307.      * @return unmodifiable view of parsed station data
  308.      */
  309.     public Map<String, Station> getStations() {
  310.         return Collections.unmodifiableMap(stations);
  311.     }

  313.     /**
  314.      * Get the parsed EOP data.
  315.      * @return unmodifiable view of parsed station data
  316.      * @since 11.2
  317.      */
  318.     public Map<AbsoluteDate, SinexEopEntry> getParsedEop() {
  319.         return Collections.unmodifiableMap(eop);
  320.     }

  322.     /**
  323.      * Get the station corresponding to the given site code.
  324.      *
  325.      * @param siteCode site code
  326.      * @return the corresponding station
  327.      */
  328.     public Station getStation(final String siteCode) {
  329.         return stations.get(siteCode);
  330.     }

  332.     /** {@inheritDoc} */
  333.     @Override
  334.     public void fillHistory(final NutationCorrectionConverter converter,
  335.                             final SortedSet<EOPEntry> history) {
  336.         // Fill the history set with the content of the parsed data
  337.         // According to Sinex standard, data are given in UTC
  338.         history.addAll(getEopList(converter, scales.getUTC()));
  339.     }

  341.     /**
  342.      * Get the DCB data for a given station.
  343.      * @param siteCode site code
  344.      * @return DCB data for the station
  345.      * @since 12.0
  346.      */
  347.     public DcbStation getDcbStation(final String siteCode) {
  348.         return dcbStations.get(siteCode);
  349.     }

  351.     /**
  352.      * Get the DCB data for a given satellite identified by its PRN.
  353.      * @param prn the satellite PRN (e.g. "G01" for GPS 01)
  354.      * @return the DCB data for the satellite
  355.      * @since 12.0
  356.      */
  357.     public DcbSatellite getDcbSatellite(final String prn) {
  358.         return dcbSatellites.get(prn);
  359.     }

  361.     /** Parser for SINEX files. */
  362.     private class Parser implements DataLoader {

  364.         /** Start character of a comment line. */
  365.         private static final String COMMENT = "*";

  367.         /** {@inheritDoc} */
  368.         @Override
  369.         public boolean stillAcceptsData() {
  370.             // We load all SINEX files we can find
  371.             return true;
  372.         }

  374.         /** {@inheritDoc} */
  375.         @Override
  376.         public void loadData(final InputStream input, final String name)
  377.             throws IOException, ParseException {

  379.             // Useful parameters
  380.             int lineNumber            = 0;
  381.             String line               = null;
  382.             boolean inDcbDesc         = false;
  383.             boolean inDcbSol          = false;
  384.             boolean inId              = false;
  385.             boolean inAntenna         = false;
  386.             boolean inEcc             = false;
  387.             boolean inEpoch           = false;
  388.             boolean inEstimate        = false;
  389.             Vector3D position         = Vector3D.ZERO;
  390.             Vector3D velocity         = Vector3D.ZERO;
  391.             String startDateString    = "";
  392.             String endDateString      = "";
  393.             String creationDateString = "";

  395.             // According to Sinex standard, the epochs are given in UTC scale.
  396.             // Except for DCB files for which a TIME_SYSTEM key is present.
  397.             TimeScale scale    = scales.getUTC();

  399.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8))) {

  401.                 // Loop on lines
  402.                 for (line = reader.readLine(); line != null; line = reader.readLine()) {
  403.                     ++lineNumber;
  404.                     // For now, only few keys are supported
  405.                     // They represent the minimum set of parameters that are interesting to consider in a SINEX file
  406.                     // Other keys can be added depending user needs

  408.                     // The first line is parsed in order to get the creation, start and end dates of the file
  409.                     if (lineNumber == 1) {
  410.                         final Matcher matcher = PATTERN_BEGIN.matcher(line);
  411.                         if (matcher.matches()) {

  413.                             creationDateString = matcher.group(1);
  414.                             startDateString    = matcher.group(2);
  415.                             endDateString      = matcher.group(3);
  416.                             creationDate       = stringEpochToAbsoluteDate(creationDateString, false, scale);

  418.                             if (startDate == null) {
  419.                                 // First data loading, needs to initialize the start and end dates for EOP history
  420.                                 startDate = stringEpochToAbsoluteDate(startDateString, true,  scale);
  421.                                 endDate   = stringEpochToAbsoluteDate(endDateString,   false, scale);
  422.                             }
  423.                         } else {
  424.                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  425.                                                       lineNumber, name, line);
  426.                         }
  427.                     } else {
  428.                         switch (line.trim()) {
  429.                             case "+SITE/ID" :
  430.                                 // Start of site id. data
  431.                                 inId = true;
  432.                                 break;
  433.                             case "-SITE/ID" :
  434.                                 // End of site id. data
  435.                                 inId = false;
  436.                                 break;
  437.                             case "+SITE/ANTENNA" :
  438.                                 // Start of site antenna data
  439.                                 inAntenna = true;
  440.                                 break;
  441.                             case "-SITE/ANTENNA" :
  442.                                 // End of site antenna data
  443.                                 inAntenna = false;
  444.                                 break;
  445.                             case "+SITE/ECCENTRICITY" :
  446.                                 // Start of antenna eccentricities data
  447.                                 inEcc = true;
  448.                                 break;
  449.                             case "-SITE/ECCENTRICITY" :
  450.                                 // End of antenna eccentricities data
  451.                                 inEcc = false;
  452.                                 break;
  453.                             case "+SOLUTION/EPOCHS" :
  454.                                 // Start of epoch data
  455.                                 inEpoch = true;
  456.                                 break;
  457.                             case "-SOLUTION/EPOCHS" :
  458.                                 // End of epoch data
  459.                                 inEpoch = false;
  460.                                 break;
  461.                             case "+SOLUTION/ESTIMATE" :
  462.                                 // Start of coordinates data
  463.                                 inEstimate = true;
  464.                                 break;
  465.                             case "-SOLUTION/ESTIMATE" :
  466.                                 // End of coordinates data
  467.                                 inEstimate = false;
  468.                                 break;
  469.                             case "+BIAS/DESCRIPTION" :
  470.                                 // Start of Bias description block data
  471.                                 inDcbDesc = true;
  472.                                 break;
  473.                             case "-BIAS/DESCRIPTION" :
  474.                                 // End of Bias description block data
  475.                                 inDcbDesc = false;
  476.                                 break;
  477.                             case "+BIAS/SOLUTION" :
  478.                                 // Start of Bias solution block data
  479.                                 inDcbSol = true;
  480.                                 break;
  481.                             case "-BIAS/SOLUTION" :
  482.                                 // End of Bias solution block data
  483.                                 inDcbSol = false;
  484.                                 break;
  485.                             default:
  486.                                 if (line.startsWith(COMMENT)) {
  487.                                     // ignore that line
  488.                                 } else {
  489.                                     // parsing data
  490.                                     if (inId) {
  491.                                         // read site id. data
  492.                                         final Station station = new Station();
  493.                                         station.setSiteCode(parseString(line, 1, 4));
  494.                                         station.setDomes(parseString(line, 9, 9));
  495.                                         // add the station to the map
  496.                                         addStation(station);
  497.                                     } else if (inAntenna) {

  499.                                         // read antenna type data
  500.                                         final Station station = getStation(parseString(line, 1, 4));

  502.                                         final AbsoluteDate start = stringEpochToAbsoluteDate(parseString(line, 16, 12), true, scale);
  503.                                         final AbsoluteDate end   = stringEpochToAbsoluteDate(parseString(line, 29, 12), false, scale);

  505.                                         // antenna type
  506.                                         final String type = parseString(line, 42, 20);

  508.                                         // special implementation for the first entry
  509.                                         if (station.getAntennaTypeTimeSpanMap().getSpansNumber() == 1) {
  510.                                             // we want null values outside validity limits of the station
  511.                                             station.addAntennaTypeValidBefore(type, end);
  512.                                             station.addAntennaTypeValidBefore(null, start);
  513.                                         } else {
  514.                                             station.addAntennaTypeValidBefore(type, end);
  515.                                         }

  517.                                     } else if (inEcc) {

  519.                                         // read antenna eccentricities data
  520.                                         final Station station = getStation(parseString(line, 1, 4));

  522.                                         final AbsoluteDate start = stringEpochToAbsoluteDate(parseString(line, 16, 12), true, scale);
  523.                                         final AbsoluteDate end   = stringEpochToAbsoluteDate(parseString(line, 29, 12), false, scale);

  525.                                         // reference system UNE or XYZ
  526.                                         station.setEccRefSystem(ReferenceSystem.getEccRefSystem(parseString(line, 42, 3)));

  528.                                         // eccentricity vector
  529.                                         final Vector3D eccStation = new Vector3D(parseDouble(line, 46, 8),
  530.                                                                                  parseDouble(line, 55, 8),
  531.                                                                                  parseDouble(line, 64, 8));

  533.                                         // special implementation for the first entry
  534.                                         if (station.getEccentricitiesTimeSpanMap().getSpansNumber() == 1) {
  535.                                             // we want null values outside validity limits of the station
  536.                                             station.addStationEccentricitiesValidBefore(eccStation, end);
  537.                                             station.addStationEccentricitiesValidBefore(null,       start);
  538.                                         } else {
  539.                                             station.addStationEccentricitiesValidBefore(eccStation, end);
  540.                                         }

  542.                                     } else if (inEpoch) {
  543.                                         // read epoch data
  544.                                         final Station station = getStation(parseString(line, 1, 4));
  545.                                         station.setValidFrom(stringEpochToAbsoluteDate(parseString(line, 16, 12), true, scale));
  546.                                         station.setValidUntil(stringEpochToAbsoluteDate(parseString(line, 29, 12), false, scale));
  547.                                     } else if (inEstimate) {
  548.                                         final Station       station     = getStation(parseString(line, 14, 4));
  549.                                         final AbsoluteDate  currentDate = stringEpochToAbsoluteDate(parseString(line, 27, 12), false, scale);
  550.                                         final String        dataType    = parseString(line, 7, 6);
  551.                                         // check if this station exists or if we are parsing EOP
  552.                                         if (station != null || EOP_TYPES.contains(dataType)) {
  553.                                             // switch on coordinates data
  554.                                             switch (dataType) {
  555.                                                 case "STAX":
  556.                                                     // station X coordinate
  557.                                                     final double x = parseDouble(line, 47, 22);
  558.                                                     position = new Vector3D(x, position.getY(), position.getZ());
  559.                                                     station.setPosition(position);
  560.                                                     break;
  561.                                                 case "STAY":
  562.                                                     // station Y coordinate
  563.                                                     final double y = parseDouble(line, 47, 22);
  564.                                                     position = new Vector3D(position.getX(), y, position.getZ());
  565.                                                     station.setPosition(position);
  566.                                                     break;
  567.                                                 case "STAZ":
  568.                                                     // station Z coordinate
  569.                                                     final double z = parseDouble(line, 47, 22);
  570.                                                     position = new Vector3D(position.getX(), position.getY(), z);
  571.                                                     station.setPosition(position);
  572.                                                     // set the reference epoch (identical for all coordinates)
  573.                                                     station.setEpoch(currentDate);
  574.                                                     // reset position vector
  575.                                                     position = Vector3D.ZERO;
  576.                                                     break;
  577.                                                 case "VELX":
  578.                                                     // station X velocity (value is in m/y)
  579.                                                     final double vx = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  580.                                                     velocity = new Vector3D(vx, velocity.getY(), velocity.getZ());
  581.                                                     station.setVelocity(velocity);
  582.                                                     break;
  583.                                                 case "VELY":
  584.                                                     // station Y velocity (value is in m/y)
  585.                                                     final double vy = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  586.                                                     velocity = new Vector3D(velocity.getX(), vy, velocity.getZ());
  587.                                                     station.setVelocity(velocity);
  588.                                                     break;
  589.                                                 case "VELZ":
  590.                                                     // station Z velocity (value is in m/y)
  591.                                                     final double vz = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  592.                                                     velocity = new Vector3D(velocity.getX(), velocity.getY(), vz);
  593.                                                     station.setVelocity(velocity);
  594.                                                     // reset position vector
  595.                                                     velocity = Vector3D.ZERO;
  596.                                                     break;
  597.                                                 case XPO:
  598.                                                     // X polar motion
  599.                                                     final double xPo = parseDoubleWithUnit(line, 40, 4, 47, 21);
  600.                                                     getSinexEopEntry(currentDate).setxPo(xPo);
  601.                                                     break;
  602.                                                 case YPO:
  603.                                                     // Y polar motion
  604.                                                     final double yPo = parseDoubleWithUnit(line, 40, 4, 47, 21);
  605.                                                     getSinexEopEntry(currentDate).setyPo(yPo);
  606.                                                     break;
  607.                                                 case LOD:
  608.                                                     // length of day
  609.                                                     final double lod = parseDoubleWithUnit(line, 40, 4, 47, 21);
  610.                                                     getSinexEopEntry(currentDate).setLod(lod);
  611.                                                     break;
  612.                                                 case UT:
  613.                                                     // delta time UT1-UTC
  614.                                                     final double dt = parseDoubleWithUnit(line, 40, 4, 47, 21);
  615.                                                     getSinexEopEntry(currentDate).setUt1MinusUtc(dt);
  616.                                                     break;
  617.                                                 case NUT_LN:
  618.                                                     // nutation correction in longitude
  619.                                                     final double nutLn = parseDoubleWithUnit(line, 40, 4, 47, 21);
  620.                                                     getSinexEopEntry(currentDate).setNutLn(nutLn);
  621.                                                     break;
  622.                                                 case NUT_OB:
  623.                                                     // nutation correction in obliquity
  624.                                                     final double nutOb = parseDoubleWithUnit(line, 40, 4, 47, 21);
  625.                                                     getSinexEopEntry(currentDate).setNutOb(nutOb);
  626.                                                     break;
  627.                                                 case NUT_X:
  628.                                                     // nutation correction X
  629.                                                     final double nutX = parseDoubleWithUnit(line, 40, 4, 47, 21);
  630.                                                     getSinexEopEntry(currentDate).setNutX(nutX);
  631.                                                     break;
  632.                                                 case NUT_Y:
  633.                                                     // nutation correction Y
  634.                                                     final double nutY = parseDoubleWithUnit(line, 40, 4, 47, 21);
  635.                                                     getSinexEopEntry(currentDate).setNutY(nutY);
  636.                                                     break;
  637.                                                 default:
  638.                                                     // ignore that field
  639.                                                     break;
  640.                                             }
  641.                                         }
  642.                                     } else if (inDcbDesc) {
  643.                                         // Determining the data type for the DCBDescription object
  644.                                         final String[] splitLine = PATTERN_SPACE.split(line.trim());
  645.                                         final String dataType = splitLine[0];
  646.                                         final String data = splitLine[1];
  647.                                         switch (dataType) {
  648.                                             case "OBSERVATION_SAMPLING":
  649.                                                 dcbDescription.setObservationSampling(Integer.parseInt(data));
  650.                                                 break;
  651.                                             case "PARAMETER_SPACING":
  652.                                                 dcbDescription.setParameterSpacing(Integer.parseInt(data));
  653.                                                 break;
  654.                                             case "DETERMINATION_METHOD":
  655.                                                 dcbDescription.setDeterminationMethod(data);
  656.                                                 break;
  657.                                             case "BIAS_MODE":
  658.                                                 dcbDescription.setBiasMode(data);
  659.                                                 break;
  660.                                             case "TIME_SYSTEM":
  661.                                                 if ("UTC".equals(data)) {
  662.                                                     dcbDescription.setTimeSystem(TimeSystem.UTC);
  663.                                                 } else if ("TAI".equals(data)) {
  664.                                                     dcbDescription.setTimeSystem(TimeSystem.TAI);
  665.                                                 } else {
  666.                                                     dcbDescription.setTimeSystem(TimeSystem.parseOneLetterCode(data));
  667.                                                 }
  668.                                                 scale = dcbDescription.getTimeSystem().getTimeScale(scales);
  669.                                                 // A time scale has been parsed, update start, end, and creation dates
  670.                                                 // to take into account the time scale
  671.                                                 startDate    = stringEpochToAbsoluteDate(startDateString,    true,  scale);
  672.                                                 endDate      = stringEpochToAbsoluteDate(endDateString,      false, scale);
  673.                                                 creationDate = stringEpochToAbsoluteDate(creationDateString, false, scale);
  674.                                                 break;
  675.                                             default:
  676.                                                 break;
  677.                                         }
  678.                                     } else if (inDcbSol) {

  680.                                         // Parsing the data present in a DCB file solution line.
  681.                                         // Most fields are used in the files provided by CDDIS.
  682.                                         // Station is empty for satellite measurements.
  683.                                         // The separator between columns is composed of spaces.

  685.                                         final String satellitePrn = parseString(line, 11, 3);
  686.                                         final String siteCode     = parseString(line, 15, 9);

  688.                                         // Parsing the line data.
  689.                                         final String obs1 = parseString(line, 25, 4);
  690.                                         final String obs2 = parseString(line, 30, 4);
  691.                                         final AbsoluteDate beginDate = stringEpochToAbsoluteDate(parseString(line, 35, 14), true, scale);
  692.                                         final AbsoluteDate finalDate = stringEpochToAbsoluteDate(parseString(line, 50, 14), false, scale);
  693.                                         final Unit unitDcb = Unit.parse(parseString(line, 65, 4));
  694.                                         final double valueDcb = unitDcb.toSI(Double.parseDouble(parseString(line, 70, 21)));

  696.                                         // Verifying if present
  697.                                         if (siteCode.equals("")) {
  698.                                             final String id = satellitePrn;
  699.                                             DcbSatellite dcbSatellite = getDcbSatellite(id);
  700.                                             if (dcbSatellite == null) {
  701.                                                 dcbSatellite = new DcbSatellite(id);
  702.                                                 dcbSatellite.setDescription(dcbDescription);
  703.                                             }
  704.                                             final Dcb dcb = dcbSatellite.getDcbData();
  705.                                             // Add the data to the DCB object.
  706.                                             dcb.addDcbLine(obs1, obs2, beginDate, finalDate, valueDcb);
  707.                                             // Adding the object to the HashMap if not present.
  708.                                             addDcbSatellite(dcbSatellite, id);
  709.                                         } else {
  710.                                             final String id = siteCode;
  711.                                             DcbStation dcbStation = getDcbStation(id);
  712.                                             if (dcbStation == null) {
  713.                                                 dcbStation = new DcbStation(id);
  714.                                                 dcbStation.setDescription(dcbDescription);
  715.                                             }
  716.                                             final SatelliteSystem satSystem = SatelliteSystem.parseSatelliteSystem(satellitePrn);
  717.                                             // Add the data to the DCB object.
  718.                                             final Dcb dcb = dcbStation.getDcbData(satSystem);
  719.                                             if (dcb == null) {
  720.                                                 dcbStation.addDcb(satSystem, new Dcb());
  721.                                             }
  722.                                             dcbStation.getDcbData(satSystem).addDcbLine(obs1, obs2, beginDate, finalDate, valueDcb);
  723.                                             // Adding the object to the HashMap if not present.
  724.                                             addDcbStation(dcbStation, id);
  725.                                         }

  727.                                     } else {
  728.                                         // not supported line, ignore it
  729.                                     }
  730.                                 }
  731.                                 break;
  732.                         }
  733.                     }
  734.                 }

  736.             } catch (NumberFormatException nfe) {
  737.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  738.                         lineNumber, name, line);
  739.             }

  741.         }

  743.         /** Extract a string from a line.
  744.          * @param line to parse
  745.          * @param start start index of the string
  746.          * @param length length of the string
  747.          * @return parsed string
  748.          */
  749.         private String parseString(final String line, final int start, final int length) {
  750.             return line.substring(start, FastMath.min(line.length(), start + length)).trim();
  751.         }

  753.         /** Extract a double from a line.
  754.          * @param line to parse
  755.          * @param start start index of the real
  756.          * @param length length of the real
  757.          * @return parsed real
  758.          */
  759.         private double parseDouble(final String line, final int start, final int length) {
  760.             return Double.parseDouble(parseString(line, start, length));
  761.         }

  763.         /** Extract a double from a line and convert in SI unit.
  764.          * @param line to parse
  765.          * @param startUnit start index of the unit
  766.          * @param lengthUnit length of the unit
  767.          * @param startDouble start index of the real
  768.          * @param lengthDouble length of the real
  769.          * @return parsed double in SI unit
  770.          */
  771.         private double parseDoubleWithUnit(final String line, final int startUnit, final int lengthUnit,
  772.                                            final int startDouble, final int lengthDouble) {
  773.             final Unit unit = Unit.parse(parseString(line, startUnit, lengthUnit));
  774.             return unit.toSI(parseDouble(line, startDouble, lengthDouble));
  775.         }

  777.     }

  779.     /**
  780.      * Transform a String epoch to an AbsoluteDate.
  781.      * @param stringDate string epoch
  782.      * @param isStart true if epoch is a start validity epoch
  783.      * @param scale TimeScale for the computation of the dates
  784.      * @return the corresponding AbsoluteDate
  785.      */
  786.     private AbsoluteDate stringEpochToAbsoluteDate(final String stringDate, final boolean isStart, final TimeScale scale) {

  788.         // Deal with 00:000:00000 epochs
  789.         if (DEFAULT_EPOCH_TWO_DIGITS.equals(stringDate) || DEFAULT_EPOCH_FOUR_DIGITS.equals(stringDate)) {
  790.             // If its a start validity epoch, the file start date shall be used.
  791.             // For end validity epoch, future infinity is acceptable.
  792.             return isStart ? startDate : AbsoluteDate.FUTURE_INFINITY;
  793.         }

  795.         // Date components
  796.         final String[] fields = SEPARATOR.split(stringDate);

  798.         // Read fields
  799.         final int digitsYear = Integer.parseInt(fields[0]);
  800.         final int day        = Integer.parseInt(fields[1]);
  801.         final int secInDay   = Integer.parseInt(fields[2]);

  803.         // Data year
  804.         final int year;
  805.         if (digitsYear > 50 && digitsYear < 100) {
  806.             year = 1900 + digitsYear;
  807.         } else if (digitsYear < 100) {
  808.             year = 2000 + digitsYear;
  809.         } else {
  810.             year = digitsYear;
  811.         }

  813.         // Return an absolute date.
  814.         // Initialize to 1st January of the given year because
  815.         // sometimes day in equal to 0 in the file.
  816.         return new AbsoluteDate(new DateComponents(year, 1, 1), scale).
  817.                 shiftedBy(Constants.JULIAN_DAY * (day - 1)).
  818.                 shiftedBy(secInDay);

  820.     }

  822.     /**
  823.      * Add a new entry to the map of stations.
  824.      * @param station station entry to add
  825.      */
  826.     private void addStation(final Station station) {
  827.         // Check if the station already exists
  828.         if (stations.get(station.getSiteCode()) == null) {
  829.             stations.put(station.getSiteCode(), station);
  830.         }
  831.     }

  833.     /**
  834.      * Add a new entry to the map of stations DCB.
  835.      * @param dcb DCB entry
  836.      * @param siteCode site code
  837.      * @since 12.0
  838.      */
  839.     private void addDcbStation(final DcbStation dcb, final String siteCode) {
  840.         // Check if the DCB for the current station already exists
  841.         if (dcbStations.get(siteCode) == null) {
  842.             dcbStations.put(siteCode, dcb);
  843.         }
  844.     }

  846.     /**
  847.      * Add a new entry to the map of satellites DCB.
  848.      * @param dcb DCB entry
  849.      * @param prn satellite PRN (e.g. "G01" for GPS 01)
  850.      * @since 12.0
  851.      */
  852.     private void addDcbSatellite(final DcbSatellite dcb, final String prn) {
  853.         if (dcbSatellites.get(prn) == null) {
  854.             dcbSatellites.put(prn, dcb);
  855.         }
  856.     }

  858.     /**
  859.      * Get the EOP entry for the given epoch.
  860.      * @param date epoch
  861.      * @return the EOP entry corresponding to the epoch
  862.      */
  863.     private SinexEopEntry getSinexEopEntry(final AbsoluteDate date) {
  864.         eop.putIfAbsent(date, new SinexEopEntry(date));
  865.         return eop.get(date);
  866.     }

  868.     /**
  869.      * Converts parsed EOP lines a list of EOP entries.
  870.      * <p>
  871.      * The first read chronological EOP entry is duplicated at the start
  872.      * time of the data as read in the Sinex header. In addition, the last
  873.      * read chronological data is duplicated at the end time of the data.
  874.      * </p>
  875.      * @param converter converter to use for nutation corrections
  876.      * @param scale time scale of EOP entries
  877.      * @return a list of EOP entries
  878.      */
  879.     private List<EOPEntry> getEopList(final IERSConventions.NutationCorrectionConverter converter,
  880.                                       final TimeScale scale) {

  882.         // Initialize the list
  883.         final List<EOPEntry> eopEntries = new ArrayList<>();

  885.         // Convert the map of parsed EOP data to a sorted set
  886.         final SortedSet<SinexEopEntry> set = mapToSortedSet(eop);

  888.         // Loop on set
  889.         for (final SinexEopEntry entry : set) {
  890.             // Add to the list
  891.             eopEntries.add(entry.toEopEntry(converter, itrfVersionEop, scale));
  892.         }

  894.         // Add first entry to the start time of the data
  895.         eopEntries.add(copyEopEntry(startDate, set.first()).toEopEntry(converter, itrfVersionEop, scale));

  897.         // Add the last entry to the end time of the data
  898.         eopEntries.add(copyEopEntry(endDate, set.last()).toEopEntry(converter, itrfVersionEop, scale));

  900.         if (set.size() < 2) {
  901.             // there is only one entry in the Sinex file
  902.             // in order for interpolation to work, we need to add more dummy entries
  903.             eopEntries.add(copyEopEntry(startDate.shiftedBy(+1.0), set.first()).toEopEntry(converter, itrfVersionEop, scale));
  904.             eopEntries.add(copyEopEntry(endDate.shiftedBy(-1.0),   set.last()).toEopEntry(converter, itrfVersionEop, scale));
  905.         }

  907.         // Return
  908.         eopEntries.sort(new ChronologicalComparator());
  909.         return eopEntries;

  911.     }

  913.     /**
  914.      * Convert a map of TimeStamped instances to a sorted set.
  915.      * @param inputMap input map
  916.      * @param <T> type of TimeStamped
  917.      * @return corresponding sorted set, chronologically ordered
  918.      */
  919.     private <T extends TimeStamped> SortedSet<T> mapToSortedSet(final Map<AbsoluteDate, T> inputMap) {

  921.         // Create a sorted set, chronologically ordered
  922.         final SortedSet<T> set = new TreeSet<>(new ChronologicalComparator());

  924.         // Fill the set
  925.         for (final Map.Entry<AbsoluteDate, T> entry : inputMap.entrySet()) {
  926.             set.add(entry.getValue());
  927.         }

  929.         // Return the filled list
  930.         return set;

  932.     }

  934.     /**
  935.      * Copy an EOP entry.
  936.      * <p>
  937.      * The data epoch is updated.
  938.      * </p>
  939.      * @param date new epoch
  940.      * @param reference reference used for the data
  941.      * @return a copy of the reference with new epoch
  942.      */
  943.     private SinexEopEntry copyEopEntry(final AbsoluteDate date, final SinexEopEntry reference) {

  945.         // Initialize
  946.         final SinexEopEntry newEntry = new SinexEopEntry(date);

  948.         // Fill
  949.         newEntry.setLod(reference.getLod());
  950.         newEntry.setUt1MinusUtc(reference.getUt1MinusUtc());
  951.         newEntry.setxPo(reference.getXPo());
  952.         newEntry.setyPo(reference.getYPo());
  953.         newEntry.setNutX(reference.getNutX());
  954.         newEntry.setNutY(reference.getNutY());
  955.         newEntry.setNutLn(reference.getNutLn());
  956.         newEntry.setNutOb(reference.getNutOb());

  958.         // Return
  959.         return newEntry;

  961.     }

  963. }
Created with JaCoCo 0.8.11.202310140853