SINEXLoader.java

  1. /* Copyright 2002-2020 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.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.nio.charset.StandardCharsets;
  24. import java.text.ParseException;
  25. import java.util.Collections;
  26. import java.util.HashMap;
  27. import java.util.Map;
  28. import java.util.regex.Pattern;

  30. import org.hipparchus.exception.DummyLocalizable;
  31. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  32. import org.hipparchus.util.FastMath;
  33. import org.orekit.annotation.DefaultDataContext;
  34. import org.orekit.data.DataContext;
  35. import org.orekit.data.DataLoader;
  36. import org.orekit.data.DataProvidersManager;
  37. import org.orekit.errors.OrekitException;
  38. import org.orekit.errors.OrekitMessages;
  39. import org.orekit.files.sinex.Station.ReferenceSystem;
  40. import org.orekit.time.AbsoluteDate;
  41. import org.orekit.time.DateComponents;
  42. import org.orekit.time.TimeScale;
  43. import org.orekit.utils.Constants;

  45. /**
  46.  * Loader for Solution INdependent EXchange (SINEX) files.
  47.  * <p>
  48.  * For now only few keys are supported: SITE/ID, SITE/ECCENTRICITY, SOLUTION/EPOCHS and SOLUTION/ESTIMATE.
  49.  * They represent the minimum set of parameters that are interesting to consider in a SINEX file.
  50.  * </p>
  51.  * @author Bryan Cazabonne
  52.  * @since 10.3
  53.  */
  54. public class SINEXLoader {

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

  59.     /** Station data.
  60.      * Key: Site code
  61.      */
  62.     private final Map<String, Station> stations;

  64.     /** UTC time scale. */
  65.     private final TimeScale utc;

  67.     /** Simple constructor. This constructor uses the {@link DataContext#getDefault()
  68.      * default data context}.
  69.      * @param supportedNames regular expression for supported files names
  70.      * @see #SINEXLoader(String, DataProvidersManager, TimeScale)
  71.      */
  72.     @DefaultDataContext
  73.     public SINEXLoader(final String supportedNames) {
  74.         this(supportedNames,
  75.              DataContext.getDefault().getDataProvidersManager(),
  76.              DataContext.getDefault().getTimeScales().getUTC());
  77.     }

  79.     /**
  80.      * Construct a loader by specifying the source of SINEX auxiliary data files.
  81.      * @param supportedNames regular expression for supported files names
  82.      * @param dataProvidersManager provides access to auxiliary data.
  83.      * @param utc UTC time scale
  84.      */
  85.     public SINEXLoader(final String supportedNames,
  86.                        final DataProvidersManager dataProvidersManager,
  87.                        final TimeScale utc) {
  88.         this.utc = utc;
  89.         stations = new HashMap<>();
  90.         dataProvidersManager.feed(supportedNames, new Parser());
  91.     }

  93.     /** Simple constructor. This constructor uses the {@link DataContext#getDefault()
  94.      * default data context}.
  95.      * @param input data input stream
  96.      * @param name name of the file (or zip entry)
  97.      * @see #SINEXLoader(InputStream, String, TimeScale)
  98.      */
  99.     @DefaultDataContext
  100.     public SINEXLoader(final InputStream input, final String name) {
  101.         this(input, name, DataContext.getDefault().getTimeScales().getUTC());
  102.     }

  104.     /**
  105.      * Loads SINEX from the given input stream using the specified auxiliary data.
  106.      * @param input data input stream
  107.      * @param name name of the file (or zip entry)
  108.      * @param utc UTC time scale
  109.      */
  110.     public SINEXLoader(final InputStream input,
  111.                        final String name,
  112.                        final TimeScale utc) {
  113.         try {
  114.             this.utc = utc;
  115.             stations = new HashMap<>();
  116.             new Parser().loadData(input, name);
  117.         } catch (IOException | ParseException ioe) {
  118.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  119.         }
  120.     }

  122.     /**
  123.      * Get the parsed station data.
  124.      * @return unmodifiable view of parsed station data
  125.      */
  126.     public Map<String, Station> getStations() {
  127.         return Collections.unmodifiableMap(stations);
  128.     }

  130.     /**
  131.      * Get the station corresponding to the given site code.
  132.      * @param siteCode site code
  133.      * @return the corresponding station
  134.      */
  135.     public Station getStation(final String siteCode) {
  136.         return stations.get(siteCode);
  137.     }

  139.     /**
  140.      * Add a new entry to the map of stations.
  141.      * @param station station entry to add
  142.      */
  143.     private void addStation(final Station station) {
  144.         // Check if station already exists
  145.         if (stations.get(station.getSiteCode()) == null) {
  146.             stations.put(station.getSiteCode(), station);
  147.         }
  148.     }

  150.     /** Parser for SINEX files. */
  151.     private class Parser implements DataLoader {

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

  156.         /** {@inheritDoc} */
  157.         @Override
  158.         public boolean stillAcceptsData() {
  159.             // We load all SINEX files we can find
  160.             return true;
  161.         }

  163.         /** {@inheritDoc} */
  164.         @Override
  165.         public void loadData(final InputStream input, final String name)
  166.             throws IOException, ParseException {

  168.             // Useful parameters
  169.             int lineNumber     = 0;
  170.             String line        = null;
  171.             boolean inId       = false;
  172.             boolean inEcc      = false;
  173.             boolean inEpoch    = false;
  174.             boolean inEstimate = false;
  175.             Vector3D position  = Vector3D.ZERO;
  176.             Vector3D velocity  = Vector3D.ZERO;

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

  180.                 // Loop on lines
  181.                 for (line = reader.readLine(); line != null; line = reader.readLine()) {
  182.                     ++lineNumber;
  183.                     // For now, only few keys are supported
  184.                     // They represent the minimum set of parameters that are interesting to consider in a SINEX file
  185.                     // Other keys can be added depending user needs
  186.                     switch(line.trim()) {
  187.                         case "+SITE/ID" :
  188.                             // Start of site id. data
  189.                             inId = true;
  190.                             break;
  191.                         case "-SITE/ID" :
  192.                             // End of site id. data
  193.                             inId = false;
  194.                             break;
  195.                         case "+SITE/ECCENTRICITY" :
  196.                             // Start of antenna eccentricities data
  197.                             inEcc = true;
  198.                             break;
  199.                         case "-SITE/ECCENTRICITY" :
  200.                             // End of antenna eccentricities data
  201.                             inEcc = false;
  202.                             break;
  203.                         case "+SOLUTION/EPOCHS" :
  204.                             // Start of epoch data
  205.                             inEpoch = true;
  206.                             break;
  207.                         case "-SOLUTION/EPOCHS" :
  208.                             // End of epoch data
  209.                             inEpoch = false;
  210.                             break;
  211.                         case "+SOLUTION/ESTIMATE" :
  212.                             // Start of coordinates data
  213.                             inEstimate = true;
  214.                             break;
  215.                         case "-SOLUTION/ESTIMATE" :
  216.                             // Start of coordinates data
  217.                             inEstimate = false;
  218.                             break;
  219.                         default:
  220.                             if (line.startsWith(COMMENT)) {
  221.                                 // ignore that line
  222.                             } else {
  223.                                 // parsing data
  224.                                 if (inId) {
  225.                                     // read site id. data
  226.                                     final Station station = new Station();
  227.                                     station.setSiteCode(parseString(line, 1, 4));
  228.                                     station.setDomes(parseString(line, 9, 9));
  229.                                     // add the station to the map
  230.                                     addStation(station);
  231.                                 } else if (inEcc) {
  232.                                     // read antenna eccentricities data
  233.                                     final Station station = getStation(parseString(line, 1, 4));
  234.                                     // check if start and end dates have been set
  235.                                     if (station.getValidFrom() == null) {
  236.                                         station.setValidFrom(stringEpochToAbsoluteDate(parseString(line, 16, 12)));
  237.                                         station.setValidUntil(stringEpochToAbsoluteDate(parseString(line, 29, 12)));
  238.                                     }
  239.                                     station.setEccRefSystem(ReferenceSystem.getEccRefSystem(parseString(line, 42, 3)));
  240.                                     station.setEccentricities(new Vector3D(parseDouble(line, 46, 8),
  241.                                                                            parseDouble(line, 55, 8),
  242.                                                                            parseDouble(line, 64, 8)));
  243.                                 } else if (inEpoch) {
  244.                                     // read epoch data
  245.                                     final Station station = getStation(parseString(line, 1, 4));
  246.                                     station.setValidFrom(stringEpochToAbsoluteDate(parseString(line, 16, 12)));
  247.                                     station.setValidUntil(stringEpochToAbsoluteDate(parseString(line, 29, 12)));
  248.                                 } else if (inEstimate) {
  249.                                     final Station station = getStation(parseString(line, 14, 4));
  250.                                     // check if this station exists
  251.                                     if (station != null) {
  252.                                         // switch on coordinates data
  253.                                         switch(parseString(line, 7, 6)) {
  254.                                             case "STAX":
  255.                                                 // station X coordinate
  256.                                                 final double x = parseDouble(line, 47, 22);
  257.                                                 position = new Vector3D(x, position.getY(), position.getZ());
  258.                                                 station.setPosition(position);
  259.                                                 break;
  260.                                             case "STAY":
  261.                                                 // station Y coordinate
  262.                                                 final double y = parseDouble(line, 47, 22);
  263.                                                 position = new Vector3D(position.getX(), y, position.getZ());
  264.                                                 station.setPosition(position);
  265.                                                 break;
  266.                                             case "STAZ":
  267.                                                 // station Z coordinate
  268.                                                 final double z = parseDouble(line, 47, 22);
  269.                                                 position = new Vector3D(position.getX(), position.getY(), z);
  270.                                                 station.setPosition(position);
  271.                                                 // set the reference epoch (identical for all coordinates)
  272.                                                 station.setEpoch(stringEpochToAbsoluteDate(parseString(line, 27, 12)));
  273.                                                 // reset position vector
  274.                                                 position = Vector3D.ZERO;
  275.                                                 break;
  276.                                             case "VELX":
  277.                                                 // station X velocity (value is in m/y)
  278.                                                 final double vx = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  279.                                                 velocity = new Vector3D(vx, velocity.getY(), velocity.getZ());
  280.                                                 station.setVelocity(velocity);
  281.                                                 break;
  282.                                             case "VELY":
  283.                                                 // station Y velocity (value is in m/y)
  284.                                                 final double vy = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  285.                                                 velocity = new Vector3D(velocity.getX(), vy, velocity.getZ());
  286.                                                 station.setVelocity(velocity);
  287.                                                 break;
  288.                                             case "VELZ":
  289.                                                 // station Z velocity (value is in m/y)
  290.                                                 final double vz = parseDouble(line, 47, 22) / Constants.JULIAN_YEAR;
  291.                                                 velocity = new Vector3D(velocity.getX(), velocity.getY(), vz);
  292.                                                 station.setVelocity(velocity);
  293.                                                 // reset position vector
  294.                                                 velocity = Vector3D.ZERO;
  295.                                                 break;
  296.                                             default:
  297.                                                 // ignore that field
  298.                                                 break;
  299.                                         }
  300.                                     }

  302.                                 } else {
  303.                                     // not supported line, ignore it
  304.                                 }
  305.                             }
  306.                             break;
  307.                     }
  308.                 }

  310.             } catch (NumberFormatException nfe) {
  311.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  312.                                           lineNumber, name, line);
  313.             }

  315.         }

  317.         /** Extract a string from a line.
  318.          * @param line to parse
  319.          * @param start start index of the string
  320.          * @param length length of the string
  321.          * @return parsed string
  322.          */
  323.         private String parseString(final String line, final int start, final int length) {
  324.             return line.substring(start, FastMath.min(line.length(), start + length)).trim();
  325.         }

  327.         /** Extract a double from a line.
  328.          * @param line to parse
  329.          * @param start start index of the real
  330.          * @param length length of the real
  331.          * @return parsed real
  332.          */
  333.         private double parseDouble(final String line, final int start, final int length) {
  334.             return Double.parseDouble(parseString(line, start, length));
  335.         }

  337.     }

  339.     /**
  340.      * Transform a String epoch to an AbsoluteDate.
  341.      * @param stringDate string epoch
  342.      * @return the corresponding AbsoluteDate
  343.      */
  344.     private AbsoluteDate stringEpochToAbsoluteDate(final String stringDate) {
  345.         // Date components
  346.         final String[] fields = SEPARATOR.split(stringDate);

  348.         // Read fields
  349.         final int twoDigitsYear = Integer.parseInt(fields[0]);
  350.         final int day           = Integer.parseInt(fields[1]);
  351.         final int secInDay      = Integer.parseInt(fields[2]);

  353.         // Data year
  354.         final int year;
  355.         if (twoDigitsYear > 50) {
  356.             year = 1900 + twoDigitsYear;
  357.         } else {
  358.             year = 2000 + twoDigitsYear;
  359.         }

  361.         // Return an absolute date.
  362.         // Initialize to 1st January of the given year because
  363.         // sometimes day in equal to 0 in the file.
  364.         return new AbsoluteDate(new DateComponents(year, 1, 1), utc).
  365.                         shiftedBy(Constants.JULIAN_DAY * (day - 1)).
  366.                         shiftedBy(secInDay);
  367.     }

  369. }
Created with JaCoCo 0.8.6.202009150832