SP3Parser.java

  1. /* Copyright 2002-2012 Space Applications Services
  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.sp3;

  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.nio.file.Files;
  25. import java.nio.file.Paths;
  26. import java.util.Locale;
  27. import java.util.Optional;
  28. import java.util.Scanner;
  29. import java.util.function.Function;
  30. import java.util.regex.Pattern;
  31. import java.util.stream.Stream;

  33. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  34. import org.orekit.annotation.DefaultDataContext;
  35. import org.orekit.data.DataContext;
  36. import org.orekit.errors.OrekitException;
  37. import org.orekit.errors.OrekitMessages;
  38. import org.orekit.files.general.EphemerisFileParser;
  39. import org.orekit.files.sp3.SP3File.SP3Coordinate;
  40. import org.orekit.files.sp3.SP3File.SP3FileType;
  41. import org.orekit.files.sp3.SP3File.TimeSystem;
  42. import org.orekit.frames.Frame;
  43. import org.orekit.time.AbsoluteDate;
  44. import org.orekit.time.TimeScale;
  45. import org.orekit.time.TimeScales;
  46. import org.orekit.utils.CartesianDerivativesFilter;
  47. import org.orekit.utils.Constants;
  48. import org.orekit.utils.IERSConventions;

  50. /** A parser for the SP3 orbit file format. It supports all formats from sp3-a
  51.  * to sp3-d.
  52.  * <p>
  53.  * <b>Note:</b> this parser is thread-safe, so calling {@link #parse} from
  54.  * different threads is allowed.
  55.  * </p>
  56.  * @see <a href="ftp://igs.org/pub/data/format/sp3_docu.txt">SP3-a file format</a>
  57.  * @see <a href="ftp://igs.org/pub/data/format/sp3c.txt">SP3-c file format</a>
  58.  * @see <a href="ftp://igs.org/pub/data/format/sp3d.pdf">SP3-d file format</a>
  59.  * @author Thomas Neidhart
  60.  * @author Luc Maisonobe
  61.  */
  62. public class SP3Parser implements EphemerisFileParser {

  64.     /** Spaces delimiters. */
  65.     private static final String SPACES = "\\s+";

  67.     /** One millimeter, in meters. */
  68.     private static final double MILLIMETER = 1.0e-3;

  70.     /** Standard gravitational parameter in m^3 / s^2. */
  71.     private final double mu;
  72.     /** Number of data points to use in interpolation. */
  73.     private final int interpolationSamples;
  74.     /** Mapping from frame identifier in the file to a {@link Frame}. */
  75.     private final Function<? super String, ? extends Frame> frameBuilder;
  76.     /** Set of time scales. */
  77.     private final TimeScales timeScales;

  79.     /**
  80.      * Create an SP3 parser using default values.
  81.      *
  82.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  83.      *
  84.      * @see #SP3Parser(double, int, Function)
  85.      */
  86.     @DefaultDataContext
  87.     public SP3Parser() {
  88.         this(Constants.EIGEN5C_EARTH_MU, 7, SP3Parser::guessFrame);
  89.     }

  91.     /**
  92.      * Create an SP3 parser and specify the extra information needed to create a {@link
  93.      * org.orekit.propagation.Propagator Propagator} from the ephemeris data.
  94.      *
  95.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  96.      *
  97.      * @param mu                   is the standard gravitational parameter to use for
  98.      *                             creating {@link org.orekit.orbits.Orbit Orbits} from
  99.      *                             the ephemeris data. See {@link Constants}.
  100.      * @param interpolationSamples is the number of samples to use when interpolating.
  101.      * @param frameBuilder         is a function that can construct a frame from an SP3
  102.      *                             coordinate system string. The coordinate system can be
  103.      *                             any 5 character string e.g. ITR92, IGb08.
  104.      * @see #SP3Parser(double, int, Function, TimeScales)
  105.      */
  106.     @DefaultDataContext
  107.     public SP3Parser(final double mu,
  108.                      final int interpolationSamples,
  109.                      final Function<? super String, ? extends Frame> frameBuilder) {
  110.         this(mu, interpolationSamples, frameBuilder,
  111.                 DataContext.getDefault().getTimeScales());
  112.     }

  114.     /**
  115.      * Create an SP3 parser and specify the extra information needed to create a {@link
  116.      * org.orekit.propagation.Propagator Propagator} from the ephemeris data.
  117.      *
  118.      * @param mu                   is the standard gravitational parameter to use for
  119.      *                             creating {@link org.orekit.orbits.Orbit Orbits} from
  120.      *                             the ephemeris data. See {@link Constants}.
  121.      * @param interpolationSamples is the number of samples to use when interpolating.
  122.      * @param frameBuilder         is a function that can construct a frame from an SP3
  123.      *                             coordinate system string. The coordinate system can be
  124.      * @param timeScales           the set of time scales used for parsing dates.
  125.      * @since 10.1
  126.      */
  127.     public SP3Parser(final double mu,
  128.                      final int interpolationSamples,
  129.                      final Function<? super String, ? extends Frame> frameBuilder,
  130.                      final TimeScales timeScales) {
  131.         this.mu = mu;
  132.         this.interpolationSamples = interpolationSamples;
  133.         this.frameBuilder = frameBuilder;
  134.         this.timeScales = timeScales;
  135.     }

  137.     /**
  138.      * Default string to {@link Frame} conversion for {@link #SP3Parser()}.
  139.      *
  140.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  141.      *
  142.      * @param name of the frame.
  143.      * @return ITRF based on 2010 conventions,
  144.      * with tidal effects considered during EOP interpolation.
  145.      */
  146.     @DefaultDataContext
  147.     private static Frame guessFrame(final String name) {
  148.         return DataContext.getDefault().getFrames()
  149.                 .getITRF(IERSConventions.IERS_2010, false);
  150.     }

  152.     /**
  153.      * Parse a SP3 file from an input stream using the UTF-8 charset.
  154.      *
  155.      * <p> This method creates a {@link BufferedReader} from the stream and as such this
  156.      * method may read more data than necessary from {@code stream} and the additional
  157.      * data will be lost. The other parse methods do not have this issue.
  158.      *
  159.      * @param stream to read the SP3 file from.
  160.      * @return a parsed SP3 file.
  161.      * @throws IOException     if {@code stream} throws one.
  162.      * @see #parse(String)
  163.      * @see #parse(BufferedReader, String)
  164.      */
  165.     public SP3File parse(final InputStream stream) throws IOException {
  166.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  167.             return parse(reader, stream.toString());
  168.         }
  169.     }

  171.     @Override
  172.     public SP3File parse(final String fileName) throws IOException, OrekitException {
  173.         try (BufferedReader reader = Files.newBufferedReader(Paths.get(fileName),
  174.                                                              StandardCharsets.UTF_8)) {
  175.             return parse(reader, fileName);
  176.         }
  177.     }

  179.     @Override
  180.     public SP3File parse(final BufferedReader reader,
  181.                          final String fileName) throws IOException {

  183.         // initialize internal data structures
  184.         final ParseInfo pi = new ParseInfo();

  186.         int lineNumber = 0;
  187.         Stream<LineParser> candidateParsers = Stream.of(LineParser.HEADER_VERSION);
  188.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  189.             ++lineNumber;
  190.             final String l = line;
  191.             final Optional<LineParser> selected = candidateParsers.filter(p -> p.canHandle(l)).findFirst();
  192.             if (selected.isPresent()) {
  193.                 try {
  194.                     selected.get().parse(line, pi);
  195.                 } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  196.                     throw new OrekitException(e,
  197.                                               OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  198.                                               lineNumber, fileName, line);
  199.                 }
  200.                 candidateParsers = selected.get().allowedNext();
  201.             } else {
  202.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  203.                                           lineNumber, fileName, line);
  204.             }
  205.             if (pi.done) {
  206.                 if (pi.nbEpochs != pi.file.getNumberOfEpochs()) {
  207.                     throw new OrekitException(OrekitMessages.SP3_NUMBER_OF_EPOCH_MISMATCH,
  208.                                               pi.nbEpochs, fileName, pi.file.getNumberOfEpochs());
  209.                 }
  210.                 return pi.file;
  211.             }
  212.         }

  214.         // we never reached the EOF marker
  215.         throw new OrekitException(OrekitMessages.SP3_UNEXPECTED_END_OF_FILE, lineNumber);

  217.     }

  219.     /** Returns the {@link SP3FileType} that corresponds to a given string in a SP3 file.
  220.      * @param fileType file type as string
  221.      * @return file type as enum
  222.      */
  223.     private static SP3FileType getFileType(final String fileType) {
  224.         SP3FileType type = SP3FileType.UNDEFINED;
  225.         if ("G".equalsIgnoreCase(fileType)) {
  226.             type = SP3FileType.GPS;
  227.         } else if ("M".equalsIgnoreCase(fileType)) {
  228.             type = SP3FileType.MIXED;
  229.         } else if ("R".equalsIgnoreCase(fileType)) {
  230.             type = SP3FileType.GLONASS;
  231.         } else if ("L".equalsIgnoreCase(fileType)) {
  232.             type = SP3FileType.LEO;
  233.         } else if ("E".equalsIgnoreCase(fileType)) {
  234.             type = SP3FileType.GALILEO;
  235.         } else if ("C".equalsIgnoreCase(fileType)) {
  236.             type = SP3FileType.COMPASS;
  237.         } else if ("J".equalsIgnoreCase(fileType)) {
  238.             type = SP3FileType.QZSS;
  239.         }
  240.         return type;
  241.     }

  243.     /** Transient data used for parsing a sp3 file. The data is kept in a
  244.      * separate data structure to make the parser thread-safe.
  245.      * <p><b>Note</b>: The class intentionally does not provide accessor
  246.      * methods, as it is only used internally for parsing a SP3 file.</p>
  247.      */
  248.     private class ParseInfo {

  250.         /** Set of time scales for parsing dates. */
  251.         private final TimeScales timeScales;

  253.         /** The corresponding SP3File object. */
  254.         private SP3File file;

  256.         /** The latest epoch as read from the SP3 file. */
  257.         private AbsoluteDate latestEpoch;

  259.         /** The latest position as read from the SP3 file. */
  260.         private Vector3D latestPosition;

  262.         /** The latest clock value as read from the SP3 file. */
  263.         private double latestClock;

  265.         /** Indicates if the SP3 file has velocity entries. */
  266.         private boolean hasVelocityEntries;

  268.         /** The timescale used in the SP3 file. */
  269.         private TimeScale timeScale;

  271.         /** The number of satellites as contained in the SP3 file. */
  272.         private int maxSatellites;

  274.         /** The number of satellites accuracies already seen. */
  275.         private int nbAccuracies;

  277.         /** The number of epochs already seen. */
  278.         private int nbEpochs;

  280.         /** End Of File reached indicator. */
  281.         private boolean done;

  283.         /** The base for pos/vel. */
  284.         //private double posVelBase;

  286.         /** The base for clock/rate. */
  287.         //private double clockBase;

  289.         /** Create a new {@link ParseInfo} object. */
  290.         protected ParseInfo() {
  291.             this.timeScales = SP3Parser.this.timeScales;
  292.             file               = new SP3File(mu, interpolationSamples, frameBuilder);
  293.             latestEpoch        = null;
  294.             latestPosition     = null;
  295.             latestClock        = 0.0;
  296.             hasVelocityEntries = false;
  297.             timeScale          = timeScales.getGPS();
  298.             maxSatellites      = 0;
  299.             nbAccuracies       = 0;
  300.             nbEpochs           = 0;
  301.             done               = false;
  302.             //posVelBase = 2d;
  303.             //clockBase = 2d;
  304.         }
  305.     }

  307.     /** Parsers for specific lines. */
  308.     private enum LineParser {

  310.         /** Parser for version, epoch, data used and agency information. */
  311.         HEADER_VERSION("^#[a-z].*") {

  313.             /** {@inheritDoc} */
  314.             @Override
  315.             public void parse(final String line, final ParseInfo pi) {
  316.                 try (Scanner s1      = new Scanner(line);
  317.                      Scanner s2      = s1.useDelimiter(SPACES);
  318.                      Scanner scanner = s2.useLocale(Locale.US)) {
  319.                     scanner.skip("#");
  320.                     final String v = scanner.next();

  322.                     final char version = v.substring(0, 1).toLowerCase().charAt(0);
  323.                     if (version != 'a' && version != 'b' && version != 'c' && version != 'd') {
  324.                         throw new OrekitException(OrekitMessages.SP3_UNSUPPORTED_VERSION, version);
  325.                     }

  327.                     pi.hasVelocityEntries = "V".equals(v.substring(1, 2));
  328.                     pi.file.setFilter(pi.hasVelocityEntries ?
  329.                                       CartesianDerivativesFilter.USE_PV :
  330.                                       CartesianDerivativesFilter.USE_P);

  332.                     final int    year   = Integer.parseInt(v.substring(2));
  333.                     final int    month  = scanner.nextInt();
  334.                     final int    day    = scanner.nextInt();
  335.                     final int    hour   = scanner.nextInt();
  336.                     final int    minute = scanner.nextInt();
  337.                     final double second = scanner.nextDouble();

  339.                     final AbsoluteDate epoch = new AbsoluteDate(year, month, day,
  340.                                                                 hour, minute, second,
  341.                                                                 pi.timeScales.getGPS());

  343.                     pi.file.setEpoch(epoch);

  345.                     final int numEpochs = scanner.nextInt();
  346.                     pi.file.setNumberOfEpochs(numEpochs);

  348.                     // data used indicator
  349.                     pi.file.setDataUsed(scanner.next());

  351.                     pi.file.setCoordinateSystem(scanner.next());
  352.                     pi.file.setOrbitTypeKey(scanner.next());
  353.                     pi.file.setAgency(scanner.next());
  354.                 }
  355.             }

  357.             /** {@inheritDoc} */
  358.             @Override
  359.             public Stream<LineParser> allowedNext() {
  360.                 return Stream.of(HEADER_DATE_TIME_REFERENCE);
  361.             }

  363.         },

  365.         /** Parser for additional date/time references in gps/julian day notation. */
  366.         HEADER_DATE_TIME_REFERENCE("^##.*") {

  368.             /** {@inheritDoc} */
  369.             @Override
  370.             public void parse(final String line, final ParseInfo pi) {
  371.                 try (Scanner s1      = new Scanner(line);
  372.                      Scanner s2      = s1.useDelimiter(SPACES);
  373.                      Scanner scanner = s2.useLocale(Locale.US)) {
  374.                     scanner.skip("##");

  376.                     // gps week
  377.                     pi.file.setGpsWeek(scanner.nextInt());
  378.                     // seconds of week
  379.                     pi.file.setSecondsOfWeek(scanner.nextDouble());
  380.                     // epoch interval
  381.                     pi.file.setEpochInterval(scanner.nextDouble());
  382.                     // julian day
  383.                     pi.file.setJulianDay(scanner.nextInt());
  384.                     // day fraction
  385.                     pi.file.setDayFraction(scanner.nextDouble());
  386.                 }
  387.             }

  389.             /** {@inheritDoc} */
  390.             @Override
  391.             public Stream<LineParser> allowedNext() {
  392.                 return Stream.of(HEADER_SAT_IDS);
  393.             }

  395.         },

  397.         /** Parser for satellites identifiers. */
  398.         HEADER_SAT_IDS("^\\+ .*") {

  400.             /** {@inheritDoc} */
  401.             @Override
  402.             public void parse(final String line, final ParseInfo pi) {

  404.                 if (pi.maxSatellites == 0) {
  405.                     // this is the first ids line, it also contains the number of satellites
  406.                     pi.maxSatellites = Integer.parseInt(line.substring(3, 6).trim());
  407.                 }

  409.                 final int lineLength = line.length();
  410.                 int count = pi.file.getSatelliteCount();
  411.                 int startIdx = 9;
  412.                 while (count++ < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  413.                     final String satId = line.substring(startIdx, startIdx + 3).trim();
  414.                     if (satId.length() > 0) {
  415.                         pi.file.addSatellite(satId);
  416.                     }
  417.                     startIdx += 3;
  418.                 }
  419.             }

  421.             /** {@inheritDoc} */
  422.             @Override
  423.             public Stream<LineParser> allowedNext() {
  424.                 return Stream.of(HEADER_SAT_IDS, HEADER_ACCURACY);
  425.             }

  427.         },

  429.         /** Parser for general accuracy information for each satellite. */
  430.         HEADER_ACCURACY("^\\+\\+.*") {

  432.             /** {@inheritDoc} */
  433.             @Override
  434.             public void parse(final String line, final ParseInfo pi) {
  435.                 final int lineLength = line.length();
  436.                 int startIdx = 9;
  437.                 while (pi.nbAccuracies < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  438.                     final String sub = line.substring(startIdx, startIdx + 3).trim();
  439.                     if (sub.length() > 0) {
  440.                         final int exponent = Integer.parseInt(sub);
  441.                         // the accuracy is calculated as 2**exp (in mm)
  442.                         pi.file.setAccuracy(pi.nbAccuracies++, (2 << exponent) * MILLIMETER);
  443.                     }
  444.                     startIdx += 3;
  445.                 }
  446.             }

  448.             /** {@inheritDoc} */
  449.             @Override
  450.             public Stream<LineParser> allowedNext() {
  451.                 return Stream.of(HEADER_ACCURACY, HEADER_TIME_SYSTEM);
  452.             }

  454.         },

  456.         /** Parser for time system. */
  457.         HEADER_TIME_SYSTEM("^%c.*") {

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

  463.                 if (pi.file.getType() == null) {
  464.                     // this the first custom fields line, the only one really used
  465.                     pi.file.setType(getFileType(line.substring(3, 5).trim()));

  467.                     // now identify the time system in use
  468.                     final String tsStr = line.substring(9, 12).trim();
  469.                     pi.file.setTimeScaleString(tsStr);
  470.                     final TimeSystem ts;
  471.                     if (tsStr.equalsIgnoreCase("ccc")) {
  472.                         ts = TimeSystem.GPS;
  473.                     } else {
  474.                         ts = TimeSystem.valueOf(tsStr);
  475.                     }
  476.                     pi.file.setTimeSystem(ts);

  478.                     switch (ts) {
  479.                         case GPS:
  480.                             pi.timeScale = pi.timeScales.getGPS();
  481.                             break;

  483.                         case GAL:
  484.                             pi.timeScale = pi.timeScales.getGST();
  485.                             break;

  487.                         case GLO:
  488.                             pi.timeScale = pi.timeScales.getGLONASS();
  489.                             break;

  491.                         case QZS:
  492.                             pi.timeScale = pi.timeScales.getQZSS();
  493.                             break;

  495.                         case TAI:
  496.                             pi.timeScale = pi.timeScales.getTAI();
  497.                             break;

  499.                         case UTC:
  500.                             pi.timeScale = pi.timeScales.getUTC();
  501.                             break;

  503.                         default:
  504.                             pi.timeScale = pi.timeScales.getGPS();
  505.                             break;
  506.                     }
  507.                     pi.file.setTimeScale(pi.timeScale);
  508.                 }

  510.             }

  512.             /** {@inheritDoc} */
  513.             @Override
  514.             public Stream<LineParser> allowedNext() {
  515.                 return Stream.of(HEADER_TIME_SYSTEM, HEADER_STANDARD_DEVIATIONS);
  516.             }

  518.         },

  520.         /** Parser for standard deviations of position/velocity/clock components. */
  521.         HEADER_STANDARD_DEVIATIONS("^%f.*") {

  523.             /** {@inheritDoc} */
  524.             @Override
  525.             public void parse(final String line, final ParseInfo pi) {
  526.                 // String base = line.substring(3, 13).trim();
  527.                 // if (!base.equals("0.0000000")) {
  528.                 //    // (mm or 10**-4 mm/sec)
  529.                 //    pi.posVelBase = Double.valueOf(base);
  530.                 // }

  532.                 // base = line.substring(14, 26).trim();
  533.                 // if (!base.equals("0.000000000")) {
  534.                 //    // (psec or 10**-4 psec/sec)
  535.                 //    pi.clockBase = Double.valueOf(base);
  536.                 // }
  537.             }

  539.             /** {@inheritDoc} */
  540.             @Override
  541.             public Stream<LineParser> allowedNext() {
  542.                 return Stream.of(HEADER_STANDARD_DEVIATIONS, HEADER_CUSTOM_PARAMETERS);
  543.             }

  545.         },

  547.         /** Parser for custom parameters. */
  548.         HEADER_CUSTOM_PARAMETERS("^%i.*") {

  550.             /** {@inheritDoc} */
  551.             @Override
  552.             public void parse(final String line, final ParseInfo pi) {
  553.                 // ignore additional custom parameters
  554.             }

  556.             /** {@inheritDoc} */
  557.             @Override
  558.             public Stream<LineParser> allowedNext() {
  559.                 return Stream.of(HEADER_CUSTOM_PARAMETERS, HEADER_COMMENTS);
  560.             }

  562.         },

  564.         /** Parser for comments. */
  565.         HEADER_COMMENTS("^/\\*.*") {

  567.             /** {@inheritDoc} */
  568.             @Override
  569.             public void parse(final String line, final ParseInfo pi) {
  570.                 // ignore comments
  571.             }

  573.             /** {@inheritDoc} */
  574.             @Override
  575.             public Stream<LineParser> allowedNext() {
  576.                 return Stream.of(HEADER_COMMENTS, DATA_EPOCH);
  577.             }

  579.         },

  581.         /** Parser for epoch. */
  582.         DATA_EPOCH("^\\* .*") {

  584.             /** {@inheritDoc} */
  585.             @Override
  586.             public void parse(final String line, final ParseInfo pi) {
  587.                 final int    year   = Integer.parseInt(line.substring(3, 7).trim());
  588.                 final int    month  = Integer.parseInt(line.substring(8, 10).trim());
  589.                 final int    day    = Integer.parseInt(line.substring(11, 13).trim());
  590.                 final int    hour   = Integer.parseInt(line.substring(14, 16).trim());
  591.                 final int    minute = Integer.parseInt(line.substring(17, 19).trim());
  592.                 final double second = Double.parseDouble(line.substring(20, 31).trim());

  594.                 pi.latestEpoch = new AbsoluteDate(year, month, day,
  595.                                                   hour, minute, second,
  596.                                                   pi.timeScale);
  597.                 pi.nbEpochs++;
  598.             }

  600.             /** {@inheritDoc} */
  601.             @Override
  602.             public Stream<LineParser> allowedNext() {
  603.                 return Stream.of(DATA_POSITION);
  604.             }

  606.         },

  608.         /** Parser for position. */
  609.         DATA_POSITION("^P.*") {

  611.             /** {@inheritDoc} */
  612.             @Override
  613.             public void parse(final String line, final ParseInfo pi) {
  614.                 final String satelliteId = line.substring(1, 4).trim();

  616.                 if (!pi.file.containsSatellite(satelliteId)) {
  617.                     pi.latestPosition = null;
  618.                 } else {
  619.                     final double x = Double.parseDouble(line.substring(4, 18).trim());
  620.                     final double y = Double.parseDouble(line.substring(18, 32).trim());
  621.                     final double z = Double.parseDouble(line.substring(32, 46).trim());

  623.                     // the position values are in km and have to be converted to m
  624.                     pi.latestPosition = new Vector3D(x * 1000, y * 1000, z * 1000);

  626.                     // clock (microsec)
  627.                     pi.latestClock =
  628.                             Double.parseDouble(line.substring(46, 60).trim()) * 1e-6;

  630.                     // the additional items are optional and not read yet

  632.                     // if (line.length() >= 73) {
  633.                     // // x-sdev (b**n mm)
  634.                     // int xStdDevExp = Integer.valueOf(line.substring(61,
  635.                     // 63).trim());
  636.                     // // y-sdev (b**n mm)
  637.                     // int yStdDevExp = Integer.valueOf(line.substring(64,
  638.                     // 66).trim());
  639.                     // // z-sdev (b**n mm)
  640.                     // int zStdDevExp = Integer.valueOf(line.substring(67,
  641.                     // 69).trim());
  642.                     // // c-sdev (b**n psec)
  643.                     // int cStdDevExp = Integer.valueOf(line.substring(70,
  644.                     // 73).trim());
  645.                     //
  646.                     // pi.posStdDevRecord =
  647.                     // new PositionStdDevRecord(FastMath.pow(pi.posVelBase, xStdDevExp),
  648.                     // FastMath.pow(pi.posVelBase,
  649.                     // yStdDevExp), FastMath.pow(pi.posVelBase, zStdDevExp),
  650.                     // FastMath.pow(pi.clockBase, cStdDevExp));
  651.                     //
  652.                     // String clockEventFlag = line.substring(74, 75);
  653.                     // String clockPredFlag = line.substring(75, 76);
  654.                     // String maneuverFlag = line.substring(78, 79);
  655.                     // String orbitPredFlag = line.substring(79, 80);
  656.                     // }

  658.                     if (!pi.hasVelocityEntries) {
  659.                         final SP3Coordinate coord =
  660.                                 new SP3Coordinate(pi.latestEpoch,
  661.                                                   pi.latestPosition,
  662.                                                   pi.latestClock);
  663.                         pi.file.addSatelliteCoordinate(satelliteId, coord);
  664.                     }
  665.                 }
  666.             }

  668.             /** {@inheritDoc} */
  669.             @Override
  670.             public Stream<LineParser> allowedNext() {
  671.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_POSITION_CORRELATION, DATA_VELOCITY, EOF);
  672.             }

  674.         },

  676.         /** Parser for position correlation. */
  677.         DATA_POSITION_CORRELATION("^EP.*") {

  679.             /** {@inheritDoc} */
  680.             @Override
  681.             public void parse(final String line, final ParseInfo pi) {
  682.                 // ignored for now
  683.             }

  685.             /** {@inheritDoc} */
  686.             @Override
  687.             public Stream<LineParser> allowedNext() {
  688.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY, EOF);
  689.             }

  691.         },

  693.         /** Parser for velocity. */
  694.         DATA_VELOCITY("^V.*") {

  696.             /** {@inheritDoc} */
  697.             @Override
  698.             public void parse(final String line, final ParseInfo pi) {
  699.                 final String satelliteId = line.substring(1, 4).trim();

  701.                 if (pi.file.containsSatellite(satelliteId)) {
  702.                     final double xv = Double.parseDouble(line.substring(4, 18).trim());
  703.                     final double yv = Double.parseDouble(line.substring(18, 32).trim());
  704.                     final double zv = Double.parseDouble(line.substring(32, 46).trim());

  706.                     // the velocity values are in dm/s and have to be converted to m/s
  707.                     final Vector3D velocity = new Vector3D(xv / 10d, yv / 10d, zv / 10d);

  709.                     // clock rate in file is 1e-4 us / s
  710.                     final double clockRateChange =
  711.                             Double.parseDouble(line.substring(46, 60).trim()) * 1e-4;

  713.                     // the additional items are optional and not read yet

  715.                     // if (line.length() >= 73) {
  716.                     // // xvel-sdev (b**n 10**-4 mm/sec)
  717.                     // int xVstdDevExp = Integer.valueOf(line.substring(61,
  718.                     // 63).trim());
  719.                     // // yvel-sdev (b**n 10**-4 mm/sec)
  720.                     // int yVstdDevExp = Integer.valueOf(line.substring(64,
  721.                     // 66).trim());
  722.                     // // zvel-sdev (b**n 10**-4 mm/sec)
  723.                     // int zVstdDevExp = Integer.valueOf(line.substring(67,
  724.                     // 69).trim());
  725.                     // // clkrate-sdev (b**n 10**-4 psec/sec)
  726.                     // int clkStdDevExp = Integer.valueOf(line.substring(70,
  727.                     // 73).trim());
  728.                     // }

  730.                     final SP3Coordinate coord =
  731.                             new SP3Coordinate(pi.latestEpoch,
  732.                                               pi.latestPosition,
  733.                                               velocity,
  734.                                               pi.latestClock,
  735.                                               clockRateChange);
  736.                     pi.file.addSatelliteCoordinate(satelliteId, coord);
  737.                 }
  738.             }

  740.             /** {@inheritDoc} */
  741.             @Override
  742.             public Stream<LineParser> allowedNext() {
  743.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY_CORRELATION, EOF);
  744.             }

  746.         },

  748.         /** Parser for velocity correlation. */
  749.         DATA_VELOCITY_CORRELATION("^EV.*") {

  751.             /** {@inheritDoc} */
  752.             @Override
  753.             public void parse(final String line, final ParseInfo pi) {
  754.                 // ignored for now
  755.             }

  757.             /** {@inheritDoc} */
  758.             @Override
  759.             public Stream<LineParser> allowedNext() {
  760.                 return Stream.of(DATA_EPOCH, DATA_POSITION, EOF);
  761.             }

  763.         },

  765.         /** Parser for End Of File marker. */
  766.         EOF("^[eE][oO][fF]\\s*$") {

  768.             /** {@inheritDoc} */
  769.             @Override
  770.             public void parse(final String line, final ParseInfo pi) {
  771.                 pi.done = true;
  772.             }

  774.             /** {@inheritDoc} */
  775.             @Override
  776.             public Stream<LineParser> allowedNext() {
  777.                 return Stream.of(EOF);
  778.             }

  780.         };

  782.         /** Pattern for identifying line. */
  783.         private final Pattern pattern;

  785.         /** Simple constructor.
  786.          * @param lineRegexp regular expression for identifying line
  787.          */
  788.         LineParser(final String lineRegexp) {
  789.             pattern = Pattern.compile(lineRegexp);
  790.         }

  792.         /** Parse a line.
  793.          * @param line line to parse
  794.          * @param pi holder for transient data
  795.          */
  796.         public abstract void parse(String line, ParseInfo pi);

  798.         /** Get the allowed parsers for next line.
  799.          * @return allowed parsers for next line
  800.          */
  801.         public abstract Stream<LineParser> allowedNext();

  803.         /** Check if parser can handle line.
  804.          * @param line line to parse
  805.          * @return true if parser can handle the specified line
  806.          */
  807.         public boolean canHandle(final String line) {
  808.             return pattern.matcher(line).matches();
  809.         }

  811.     }

  813. }
Created with JaCoCo 0.8.6.202009150832