SinexLoader.java

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

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

  60. /**
  61.  * Loader for Solution INdependent EXchange (SINEX) files.
  62.  * <p>
  63.  * For now only few keys are supported: SITE/ID, SITE/ECCENTRICITY, SOLUTION/EPOCHS and SOLUTION/ESTIMATE.
  64.  * They represent the minimum set of parameters that are interesting to consider in a SINEX file.
  65.  * </p>
  66.  * <p>
  67.  * The parsing of EOP parameters for multiple files in different SinexLoader object, fed into the default DataContext
  68.  * might pose a problem in case validity dates are overlapping. As Sinex daily solution files provide a single EOP entry,
  69.  * the Sinex loader will add points at the limits of data dates (startDate, endDate) of the Sinex file, which in case of
  70.  * overlap will lead to inconsistencies in the final EOPHistory object. Multiple files can be parsed using a single SinexLoader
  71.  * with a regex to overcome this issue.
  72.  * </p>
  73.  *
  74.  * @author Bryan Cazabonne
  75.  * @since 10.3
  76.  */
  77. public class SinexLoader implements EOPHistoryLoader {

  79.     /** Length of day. */
  80.     private static final String LOD = "LOD";

  82.     /** UT1-UTC. */
  83.     private static final String UT = "UT";

  85.     /** X polar motion. */
  86.     private static final String XPO = "XPO";

  88.     /** Y polar motion. */
  89.     private static final String YPO = "YPO";

  91.     /** Nutation correction in longitude. */
  92.     private static final String NUT_LN = "NUT_LN";

  94.     /** Nutation correction in obliquity. */
  95.     private static final String NUT_OB = "NUT_OB";

  97.     /** Nutation correction X. */
  98.     private static final String NUT_X = "NUT_X";

  100.     /** Nutation correction Y. */
  101.     private static final String NUT_Y = "NUT_Y";

  103.     /** 00:000:00000 epoch. */
  104.     private static final String DEFAULT_EPOCH = "00:000:00000";

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

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

  112.     /** Pattern to check beginning of SINEX files.*/
  113.     private static final Pattern PATTERN_BEGIN = Pattern.compile("(%=).*");

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

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

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

  124.     /** Station data.
  125.      * Key: Site code
  126.      */
  127.     private final Map<String, Station> stations;

  129.     /** Data set. */
  130.     private Map<AbsoluteDate, SinexEopEntry> map;

  132.     /** ITRF Version used for EOP parsing. */
  133.     private ITRFVersion itrfVersionEop;

  135.     /** UTC time scale. */
  136.     private final TimeScale utc;

  138.     /** Simple constructor. This constructor uses the {@link DataContext#getDefault()
  139.      * default data context}.
  140.      * @param supportedNames regular expression for supported files names
  141.      * @see #SinexLoader(String, DataProvidersManager, TimeScale)
  142.      */
  143.     @DefaultDataContext
  144.     public SinexLoader(final String supportedNames) {
  145.         this(supportedNames,
  146.              DataContext.getDefault().getDataProvidersManager(),
  147.              DataContext.getDefault().getTimeScales().getUTC());
  148.     }

  150.     /**
  151.      * Construct a loader by specifying the source of SINEX auxiliary data files.
  152.      * <p>
  153.      * For EOP loading, a default {@link ITRFVersion#ITRF_2014} is used. It is
  154.      * possible to update the version using the {@link #setITRFVersion(int)}
  155.      * method.
  156.      * </p>
  157.      * @param supportedNames regular expression for supported files names
  158.      * @param dataProvidersManager provides access to auxiliary data.
  159.      * @param utc UTC time scale
  160.      */
  161.     public SinexLoader(final String supportedNames,
  162.                        final DataProvidersManager dataProvidersManager,
  163.                        final TimeScale utc) {
  164.         this.utc            = utc;
  165.         this.stations       = new HashMap<>();
  166.         this.itrfVersionEop = ITRFVersion.ITRF_2014;
  167.         this.map            = new HashMap<>();
  168.         dataProvidersManager.feed(supportedNames, new Parser());
  169.     }

  171.     /**
  172.      * Simple constructor. This constructor uses the {@link DataContext#getDefault()
  173.      * default data context}.
  174.      * <p>
  175.      * For EOP loading, a default {@link ITRFVersion#ITRF_2014} is used. It is
  176.      * possible to update the version using the {@link #setITRFVersion(int)}
  177.      * method.
  178.      * </p>
  179.      * @param source source for the RINEX data
  180.      * @see #SinexLoader(String, DataProvidersManager, TimeScale)
  181.      */
  182.     @DefaultDataContext
  183.     public SinexLoader(final DataSource source) {
  184.         this(source, DataContext.getDefault().getTimeScales().getUTC());
  185.     }

  187.     /**
  188.      * Loads SINEX from the given input stream using the specified auxiliary data.
  189.      * <p>
  190.      * For EOP loading, a default {@link ITRFVersion#ITRF_2014} is used. It is
  191.      * possible to update the version using the {@link #setITRFVersion(int)}
  192.      * method.
  193.      * </p>
  194.      * @param source source for the RINEX data
  195.      * @param utc UTC time scale
  196.      */
  197.     public SinexLoader(final DataSource source, final TimeScale utc) {
  198.         try {
  199.             this.utc            = utc;
  200.             this.stations       = new HashMap<>();
  201.             this.itrfVersionEop = ITRFVersion.ITRF_2014;
  202.             this.map            = new HashMap<>();
  203.             try (InputStream         is  = source.getOpener().openStreamOnce();
  204.                  BufferedInputStream bis = new BufferedInputStream(is)) {
  205.                 new Parser().loadData(bis, source.getName());
  206.             }
  207.         } catch (IOException | ParseException ioe) {
  208.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  209.         }
  210.     }

  212.     /**
  213.      * Set the ITRF version used in EOP entries processing.
  214.      * @param year Year of the ITRF Version used for parsing EOP.
  215.      * @since 11.2
  216.      */
  217.     public void setITRFVersion(final int year) {
  218.         this.itrfVersionEop = ITRFVersion.getITRFVersion(year);
  219.     }

  221.     /**
  222.      * Get the ITRF version used for the EOP entries processing.
  223.      * @return the ITRF Version used for the EOP processing.
  224.      * @since 11.2
  225.      */
  226.     public ITRFVersion getITRFVersion() {
  227.         return itrfVersionEop;
  228.     }

  230.     /**
  231.      * Get the parsed station data.
  232.      * @return unmodifiable view of parsed station data
  233.      */
  234.     public Map<String, Station> getStations() {
  235.         return Collections.unmodifiableMap(stations);
  236.     }

  238.     /**
  239.      * Get the parsed EOP data.
  240.      * @return unmodifiable view of parsed station data
  241.      * @since 11.2
  242.      */
  243.     public Map<AbsoluteDate, SinexEopEntry> getParsedEop() {
  244.         return Collections.unmodifiableMap(map);
  245.     }

  247.     /**
  248.      * Get the station corresponding to the given site code.
  249.      * @param siteCode site code
  250.      * @return the corresponding station
  251.      */
  252.     public Station getStation(final String siteCode) {
  253.         return stations.get(siteCode);
  254.     }

  256.     /** {@inheritDoc} */
  257.     @Override
  258.     public void fillHistory(final NutationCorrectionConverter converter,
  259.                             final SortedSet<EOPEntry> history) {
  260.         // Fill the history set with the content of the parsed data
  261.         history.addAll(getEopList(converter));
  262.     }

  264.     /** Parser for SINEX files. */
  265.     private class Parser implements DataLoader {

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

  270.         /** {@inheritDoc} */
  271.         @Override
  272.         public boolean stillAcceptsData() {
  273.             // We load all SINEX files we can find
  274.             return true;
  275.         }

  277.         /** {@inheritDoc} */
  278.         @Override
  279.         public void loadData(final InputStream input, final String name)
  280.             throws IOException, ParseException {

  282.             // Useful parameters
  283.             int lineNumber     = 0;
  284.             String line        = null;
  285.             boolean inId       = false;
  286.             boolean inEcc      = false;
  287.             boolean inEpoch    = false;
  288.             boolean inEstimate = false;
  289.             boolean firstEcc   = true;
  290.             Vector3D position  = Vector3D.ZERO;
  291.             Vector3D velocity  = Vector3D.ZERO;

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

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

  302.                     // The first line is parsed in order to get the creation date of the file, which might be used
  303.                     // in the case of an absent date as the final date of the data.
  304.                     // Its position is fixed in the file, at the first line, in the 4th column.
  305.                     if (lineNumber == 1 && PATTERN_BEGIN.matcher(line).matches()) {
  306.                         final String[]     splitFirstLine = PATTERN_SPACE.split(line);
  307.                         final AbsoluteDate fileStartDate  = stringEpochToAbsoluteDate(splitFirstLine[5]);
  308.                         final AbsoluteDate fileEndDate    = stringEpochToAbsoluteDate(splitFirstLine[6]);
  309.                         if (startDate == null) {
  310.                             // First data loading, needs to initialize the start and end dates for EOP history
  311.                             startDate = fileStartDate;
  312.                             endDate   = fileEndDate;
  313.                         }
  314.                         // In case of multiple files used for EOP history, the start and end dates can be updated
  315.                         startDate = fileStartDate.isBefore(startDate) ? fileStartDate : startDate;
  316.                         endDate   = fileEndDate.isAfter(endDate) ? fileEndDate : endDate;
  317.                     }

  319.                     switch (line.trim()) {
  320.                         case "+SITE/ID" :
  321.                             // Start of site id. data
  322.                             inId = true;
  323.                             break;
  324.                         case "-SITE/ID" :
  325.                             // End of site id. data
  326.                             inId = false;
  327.                             break;
  328.                         case "+SITE/ECCENTRICITY" :
  329.                             // Start of antenna eccentricities data
  330.                             inEcc = true;
  331.                             break;
  332.                         case "-SITE/ECCENTRICITY" :
  333.                             // End of antenna eccentricities data
  334.                             inEcc = false;
  335.                             break;
  336.                         case "+SOLUTION/EPOCHS" :
  337.                             // Start of epoch data
  338.                             inEpoch = true;
  339.                             break;
  340.                         case "-SOLUTION/EPOCHS" :
  341.                             // End of epoch data
  342.                             inEpoch = false;
  343.                             break;
  344.                         case "+SOLUTION/ESTIMATE" :
  345.                             // Start of coordinates data
  346.                             inEstimate = true;
  347.                             break;
  348.                         case "-SOLUTION/ESTIMATE" :
  349.                             // Start of coordinates data
  350.                             inEstimate = false;
  351.                             break;
  352.                         default:
  353.                             if (line.startsWith(COMMENT)) {
  354.                                 // ignore that line
  355.                             } else {
  356.                                 // parsing data
  357.                                 if (inId) {
  358.                                     // read site id. data
  359.                                     final Station station = new Station();
  360.                                     station.setSiteCode(parseString(line, 1, 4));
  361.                                     station.setDomes(parseString(line, 9, 9));
  362.                                     // add the station to the map
  363.                                     addStation(station);
  364.                                 } else if (inEcc) {

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

  369.                                     // check if it is the first eccentricity entry for this station
  370.                                     if (station.getEccentricitiesTimeSpanMap().getSpansNumber() == 1) {
  371.                                         // we are parsing eccentricity data for a new station
  372.                                         firstEcc = true;
  373.                                     }

  375.                                     // start and end of validity for the current entry
  376.                                     final AbsoluteDate start = stringEpochToAbsoluteDate(parseString(line, 16, 12));
  377.                                     final AbsoluteDate end   = stringEpochToAbsoluteDate(parseString(line, 29, 12));

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

  382.                                     // eccentricity vector
  383.                                     final Vector3D eccStation = new Vector3D(parseDouble(line, 46, 8),
  384.                                                                              parseDouble(line, 55, 8),
  385.                                                                              parseDouble(line, 64, 8));

  387.                                     // special implementation for the first entry
  388.                                     if (firstEcc) {
  389.                                         // we want null values outside validity limits of the station
  390.                                         station.addStationEccentricitiesValidBefore(eccStation, end);
  391.                                         station.addStationEccentricitiesValidBefore(null,       start);
  392.                                         // we parsed the first entry, set the flag to false
  393.                                         firstEcc = false;
  394.                                     } else {
  395.                                         station.addStationEccentricitiesValidBefore(eccStation, end);
  396.                                     }

  398.                                     // update the last known eccentricities entry
  399.                                     station.setEccentricities(eccStation);

  401.                                 } else if (inEpoch) {
  402.                                     // read epoch data
  403.                                     final Station station = getStation(parseString(line, 1, 4));
  404.                                     station.setValidFrom(stringEpochToAbsoluteDate(parseString(line, 16, 12)));
  405.                                     station.setValidUntil(stringEpochToAbsoluteDate(parseString(line, 29, 12)));
  406.                                 } else if (inEstimate) {
  407.                                     final Station       station     = getStation(parseString(line, 14, 4));
  408.                                     final AbsoluteDate  currentDate = stringEpochToAbsoluteDate(parseString(line, 27, 12));
  409.                                     final String        dataType    = parseString(line, 7, 6);
  410.                                     // check if this station exists or if we are parsing EOP
  411.                                     if (station != null || EOP_TYPES.contains(dataType)) {
  412.                                         // switch on coordinates data
  413.                                         switch (dataType) {
  414.                                             case "STAX":
  415.                                                 // station X coordinate
  416.                                                 final double x = parseDouble(line, 47, 22);
  417.                                                 position = new Vector3D(x, position.getY(), position.getZ());
  418.                                                 station.setPosition(position);
  419.                                                 break;
  420.                                             case "STAY":
  421.                                                 // station Y coordinate
  422.                                                 final double y = parseDouble(line, 47, 22);
  423.                                                 position = new Vector3D(position.getX(), y, position.getZ());
  424.                                                 station.setPosition(position);
  425.                                                 break;
  426.                                             case "STAZ":
  427.                                                 // station Z coordinate
  428.                                                 final double z = parseDouble(line, 47, 22);
  429.                                                 position = new Vector3D(position.getX(), position.getY(), z);
  430.                                                 station.setPosition(position);
  431.                                                 // set the reference epoch (identical for all coordinates)
  432.                                                 station.setEpoch(currentDate);
  433.                                                 // reset position vector
  434.                                                 position = Vector3D.ZERO;
  435.                                                 break;
  436.                                             case "VELX":
  437.                                                 // station X velocity (value is in m/y)
  438.                                                 final double vx = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  439.                                                 velocity = new Vector3D(vx, velocity.getY(), velocity.getZ());
  440.                                                 station.setVelocity(velocity);
  441.                                                 break;
  442.                                             case "VELY":
  443.                                                 // station Y velocity (value is in m/y)
  444.                                                 final double vy = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  445.                                                 velocity = new Vector3D(velocity.getX(), vy, velocity.getZ());
  446.                                                 station.setVelocity(velocity);
  447.                                                 break;
  448.                                             case "VELZ":
  449.                                                 // station Z velocity (value is in m/y)
  450.                                                 final double vz = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  451.                                                 velocity = new Vector3D(velocity.getX(), velocity.getY(), vz);
  452.                                                 station.setVelocity(velocity);
  453.                                                 // reset position vector
  454.                                                 velocity = Vector3D.ZERO;
  455.                                                 break;
  456.                                             case XPO:
  457.                                                 // X polar motion
  458.                                                 final double xPo = parseDoubleWithUnit(line, 40, 4, 47, 21);
  459.                                                 getSinexEopEntry(currentDate).setxPo(xPo);
  460.                                                 break;
  461.                                             case YPO:
  462.                                                 // Y polar motion
  463.                                                 final double yPo = parseDoubleWithUnit(line, 40, 4, 47, 21);
  464.                                                 getSinexEopEntry(currentDate).setyPo(yPo);
  465.                                                 break;
  466.                                             case LOD:
  467.                                                 // length of day
  468.                                                 final double lod = parseDoubleWithUnit(line, 40, 4, 47, 21);
  469.                                                 getSinexEopEntry(currentDate).setLod(lod);
  470.                                                 break;
  471.                                             case UT:
  472.                                                 // delta time UT1-UTC
  473.                                                 final double dt = parseDoubleWithUnit(line, 40, 4, 47, 21);
  474.                                                 getSinexEopEntry(currentDate).setUt1MinusUtc(dt);
  475.                                                 break;
  476.                                             case NUT_LN:
  477.                                                 // nutation correction in longitude
  478.                                                 final double nutLn = parseDoubleWithUnit(line, 40, 4, 47, 21);
  479.                                                 getSinexEopEntry(currentDate).setNutLn(nutLn);
  480.                                                 break;
  481.                                             case NUT_OB:
  482.                                                 // nutation correction in obliquity
  483.                                                 final double nutOb = parseDoubleWithUnit(line, 40, 4, 47, 21);
  484.                                                 getSinexEopEntry(currentDate).setNutOb(nutOb);
  485.                                                 break;
  486.                                             case NUT_X:
  487.                                                 // nutation correction X
  488.                                                 final double nutX = parseDoubleWithUnit(line, 40, 4, 47, 21);
  489.                                                 getSinexEopEntry(currentDate).setNutX(nutX);
  490.                                                 break;
  491.                                             case NUT_Y:
  492.                                                 // nutation correction Y
  493.                                                 final double nutY = parseDoubleWithUnit(line, 40, 4, 47, 21);
  494.                                                 getSinexEopEntry(currentDate).setNutY(nutY);
  495.                                                 break;
  496.                                             default:
  497.                                                 // ignore that field
  498.                                                 break;
  499.                                         }
  500.                                     }
  501.                                 } else {
  502.                                     // not supported line, ignore it
  503.                                 }
  504.                             }
  505.                             break;
  506.                     }
  507.                 }

  509.             } catch (NumberFormatException nfe) {
  510.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  511.                         lineNumber, name, line);
  512.             }

  514.         }

  516.         /** Extract a string from a line.
  517.          * @param line to parse
  518.          * @param start start index of the string
  519.          * @param length length of the string
  520.          * @return parsed string
  521.          */
  522.         private String parseString(final String line, final int start, final int length) {
  523.             return line.substring(start, FastMath.min(line.length(), start + length)).trim();
  524.         }

  526.         /** Extract a double from a line.
  527.          * @param line to parse
  528.          * @param start start index of the real
  529.          * @param length length of the real
  530.          * @return parsed real
  531.          */
  532.         private double parseDouble(final String line, final int start, final int length) {
  533.             return Double.parseDouble(parseString(line, start, length));
  534.         }

  536.         /** Extract a double from a line and convert in SI unit.
  537.          * @param line to parse
  538.          * @param startUnit start index of the unit
  539.          * @param lengthUnit length of the unit
  540.          * @param startDouble start index of the real
  541.          * @param lengthDouble length of the real
  542.          * @return parsed double in SI unit
  543.          */
  544.         private double parseDoubleWithUnit(final String line, final int startUnit, final int lengthUnit,
  545.                                            final int startDouble, final int lengthDouble) {
  546.             final Unit unit = Unit.parse(parseString(line, startUnit, lengthUnit));
  547.             return unit.toSI(parseDouble(line, startDouble, lengthDouble));
  548.         }

  550.     }

  552.     /**
  553.      * Transform a String epoch to an AbsoluteDate.
  554.      * @param stringDate string epoch
  555.      * @return the corresponding AbsoluteDate
  556.      */
  557.     private AbsoluteDate stringEpochToAbsoluteDate(final String stringDate) {

  559.         // Deal with 00:000:00000 epochs
  560.         if (DEFAULT_EPOCH.equals(stringDate)) {
  561.             // Data is still available, return a dummy date at infinity in the future direction
  562.             return AbsoluteDate.FUTURE_INFINITY;
  563.         }

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

  568.         // Read fields
  569.         final int twoDigitsYear = Integer.parseInt(fields[0]);
  570.         final int day           = Integer.parseInt(fields[1]);
  571.         final int secInDay      = Integer.parseInt(fields[2]);

  573.         // Data year
  574.         final int year;
  575.         if (twoDigitsYear > 50) {
  576.             year = 1900 + twoDigitsYear;
  577.         } else {
  578.             year = 2000 + twoDigitsYear;
  579.         }

  581.         // Return an absolute date.
  582.         // Initialize to 1st January of the given year because
  583.         // sometimes day in equal to 0 in the file.
  584.         return new AbsoluteDate(new DateComponents(year, 1, 1), utc).
  585.                 shiftedBy(Constants.JULIAN_DAY * (day - 1)).
  586.                 shiftedBy(secInDay);

  588.     }

  590.     /**
  591.      * Add a new entry to the map of stations.
  592.      * @param station station entry to add
  593.      */
  594.     private void addStation(final Station station) {
  595.         // Check if station already exists
  596.         if (stations.get(station.getSiteCode()) == null) {
  597.             stations.put(station.getSiteCode(), station);
  598.         }
  599.     }

  601.     /**
  602.      * Get the EOP entry for the given epoch.
  603.      * @param date epoch
  604.      * @return the EOP entry corresponding to the epoch
  605.      */
  606.     private SinexEopEntry getSinexEopEntry(final AbsoluteDate date) {
  607.         map.putIfAbsent(date, new SinexEopEntry(date));
  608.         return map.get(date);
  609.     }

  611.     /**
  612.      * Converts parsed EOP lines a list of EOP entries.
  613.      * <p>
  614.      * The first read chronological EOP entry is duplicated at the start
  615.      * time of the data as read in the Sinex header. In addition, the last
  616.      * read chronological data is duplicated at the end time of the data.
  617.      * </p>
  618.      * @param converter converter to use for nutation corrections
  619.      * @return a list of EOP entries
  620.      */
  621.     private List<EOPEntry> getEopList(final IERSConventions.NutationCorrectionConverter converter) {

  623.         // Initialize the list
  624.         final List<EOPEntry> eop = new ArrayList<>();

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

  629.         // Loop on set
  630.         for (final SinexEopEntry entry : set) {
  631.             // Add to the list
  632.             eop.add(entry.toEopEntry(converter, itrfVersionEop, utc));
  633.         }

  635.         // Add first entry to the start time of the data
  636.         eop.add(copyEopEntry(startDate, set.first()).toEopEntry(converter, itrfVersionEop, utc));

  638.         // Add the last entry to the end time of the data
  639.         eop.add(copyEopEntry(endDate, set.last()).toEopEntry(converter, itrfVersionEop, utc));

  641.         // Return
  642.         eop.sort(new ChronologicalComparator());
  643.         return eop;

  645.     }

  647.     /**
  648.      * Convert a map of TimeStamped instances to a sorted set.
  649.      * @param inputMap input map
  650.      * @param <T> type of TimeStamped
  651.      * @return corresponding sorted set, chronologically ordered
  652.      */
  653.     private <T extends TimeStamped> SortedSet<T> mapToSortedSet(final Map<AbsoluteDate, T> inputMap) {

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

  658.         // Fill the set
  659.         for (final Map.Entry<AbsoluteDate, T> entry : inputMap.entrySet()) {
  660.             set.add(entry.getValue());
  661.         }

  663.         // Return the filled list
  664.         return set;

  666.     }

  668.     /**
  669.      * Copy an EOP entry.
  670.      * <p>
  671.      * The data epoch is updated.
  672.      * </p>
  673.      * @param date new epoch
  674.      * @param reference reference used for the data
  675.      * @return a copy of the reference with new epoch
  676.      */
  677.     private SinexEopEntry copyEopEntry(final AbsoluteDate date, final SinexEopEntry reference) {

  679.         // Initialize
  680.         final SinexEopEntry newEntry = new SinexEopEntry(date);

  682.         // Fill
  683.         newEntry.setLod(reference.getLod());
  684.         newEntry.setUt1MinusUtc(reference.getUt1MinusUtc());
  685.         newEntry.setxPo(reference.getXPo());
  686.         newEntry.setyPo(reference.getYPo());
  687.         newEntry.setNutX(reference.getNutX());
  688.         newEntry.setNutY(reference.getNutY());
  689.         newEntry.setNutLn(reference.getNutLn());
  690.         newEntry.setNutOb(reference.getNutOb());

  692.         // Return
  693.         return newEntry;

  695.     }

  697. }
Created with JaCoCo 0.8.8.202204050719