SP3Parser.java

  1. /* Copyright 2002-2012 Space Applications Services
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.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.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;
  36. import org.orekit.files.general.EphemerisFileParser;
  37. import org.orekit.files.sp3.SP3File.SP3Coordinate;
  38. import org.orekit.files.sp3.SP3File.SP3FileType;
  39. import org.orekit.files.sp3.SP3File.TimeSystem;
  40. import org.orekit.frames.Frame;
  41. import org.orekit.frames.FramesFactory;
  42. import org.orekit.time.AbsoluteDate;
  43. import org.orekit.time.TimeScale;
  44. import org.orekit.time.TimeScalesFactory;
  45. import org.orekit.utils.CartesianDerivativesFilter;
  46. import org.orekit.utils.Constants;
  47. import org.orekit.utils.IERSConventions;

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

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

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

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

  76.     /**
  77.      * Create an SP3 parser using default values.
  78.      *
  79.      * @see #SP3Parser(double, int, Function)
  80.      */
  81.     public SP3Parser() {
  82.         this(Constants.EIGEN5C_EARTH_MU, 7, SP3Parser::guessFrame);
  83.     }

  85.     /**
  86.      * Create an SP3 parser and specify the extra information needed to create a {@link
  87.      * org.orekit.propagation.Propagator Propagator} from the ephemeris data.
  88.      *
  89.      * @param mu                   is the standard gravitational parameter to use for
  90.      *                             creating {@link org.orekit.orbits.Orbit Orbits} from
  91.      *                             the ephemeris data. See {@link Constants}.
  92.      * @param interpolationSamples is the number of samples to use when interpolating.
  93.      * @param frameBuilder         is a function that can construct a frame from an SP3
  94.      *                             coordinate system string. The coordinate system can be
  95.      *                             any 5 character string e.g. ITR92, IGb08.
  96.      */
  97.     public SP3Parser(final double mu,
  98.                      final int interpolationSamples,
  99.                      final Function<? super String, ? extends Frame> frameBuilder) {
  100.         this.mu = mu;
  101.         this.interpolationSamples = interpolationSamples;
  102.         this.frameBuilder = frameBuilder;
  103.     }

  105.     /**
  106.      * Default string to {@link Frame} conversion for {@link #SP3Parser()}.
  107.      *
  108.      * @param name of the frame.
  109.      * @return ITRF based on 2010 conventions,
  110.      * with tidal effects considered during EOP interpolation.
  111.      */
  112.     private static Frame guessFrame(final String name) {
  113.         return FramesFactory.getITRF(IERSConventions.IERS_2010, false);
  114.     }

  116.     /**
  117.      * Parse a SP3 file from an input stream using the UTF-8 charset.
  118.      *
  119.      * <p> This method creates a {@link BufferedReader} from the stream and as such this
  120.      * method may read more data than necessary from {@code stream} and the additional
  121.      * data will be lost. The other parse methods do not have this issue.
  122.      *
  123.      * @param stream to read the SP3 file from.
  124.      * @return a parsed SP3 file.
  125.      * @throws IOException     if {@code stream} throws one.
  126.      * @see #parse(String)
  127.      * @see #parse(BufferedReader, String)
  128.      */
  129.     public SP3File parse(final InputStream stream) throws IOException {
  130.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  131.             return parse(reader, stream.toString());
  132.         }
  133.     }

  135.     @Override
  136.     public SP3File parse(final String fileName) throws IOException, OrekitException {
  137.         try (BufferedReader reader = Files.newBufferedReader(Paths.get(fileName),
  138.                                                              StandardCharsets.UTF_8)) {
  139.             return parse(reader, fileName);
  140.         }
  141.     }

  143.     @Override
  144.     public SP3File parse(final BufferedReader reader,
  145.                          final String fileName) throws IOException {

  147.         // initialize internal data structures
  148.         final ParseInfo pi = new ParseInfo();

  150.         int lineNumber = 0;
  151.         Stream<LineParser> candidateParsers = Stream.of(LineParser.HEADER_VERSION);
  152.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  153.             ++lineNumber;
  154.             final String l = line;
  155.             final Optional<LineParser> selected = candidateParsers.filter(p -> p.canHandle(l)).findFirst();
  156.             if (selected.isPresent()) {
  157.                 try {
  158.                     selected.get().parse(line, pi);
  159.                 } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  160.                     throw new OrekitException(e,
  161.                                               OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  162.                                               lineNumber, fileName, line);
  163.                 }
  164.                 candidateParsers = selected.get().allowedNext();
  165.             } else {
  166.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  167.                                           lineNumber, fileName, line);
  168.             }
  169.             if (pi.done) {
  170.                 if (pi.nbEpochs != pi.file.getNumberOfEpochs()) {
  171.                     throw new OrekitException(OrekitMessages.SP3_NUMBER_OF_EPOCH_MISMATCH,
  172.                                               pi.nbEpochs, fileName, pi.file.getNumberOfEpochs());
  173.                 }
  174.                 return pi.file;
  175.             }
  176.         }

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

  181.     }

  183.     /** Returns the {@link SP3FileType} that corresponds to a given string in a SP3 file.
  184.      * @param fileType file type as string
  185.      * @return file type as enum
  186.      */
  187.     private static SP3FileType getFileType(final String fileType) {
  188.         SP3FileType type = SP3FileType.UNDEFINED;
  189.         if ("G".equalsIgnoreCase(fileType)) {
  190.             type = SP3FileType.GPS;
  191.         } else if ("M".equalsIgnoreCase(fileType)) {
  192.             type = SP3FileType.MIXED;
  193.         } else if ("R".equalsIgnoreCase(fileType)) {
  194.             type = SP3FileType.GLONASS;
  195.         } else if ("L".equalsIgnoreCase(fileType)) {
  196.             type = SP3FileType.LEO;
  197.         } else if ("E".equalsIgnoreCase(fileType)) {
  198.             type = SP3FileType.GALILEO;
  199.         } else if ("C".equalsIgnoreCase(fileType)) {
  200.             type = SP3FileType.COMPASS;
  201.         } else if ("J".equalsIgnoreCase(fileType)) {
  202.             type = SP3FileType.QZSS;
  203.         }
  204.         return type;
  205.     }

  207.     /** Transient data used for parsing a sp3 file. The data is kept in a
  208.      * separate data structure to make the parser thread-safe.
  209.      * <p><b>Note</b>: The class intentionally does not provide accessor
  210.      * methods, as it is only used internally for parsing a SP3 file.</p>
  211.      */
  212.     private class ParseInfo {

  214.         /** The corresponding SP3File object. */
  215.         private SP3File file;

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

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

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

  226.         /** Indicates if the SP3 file has velocity entries. */
  227.         private boolean hasVelocityEntries;

  229.         /** The timescale used in the SP3 file. */
  230.         private TimeScale timeScale;

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

  235.         /** The number of satellites accuracies already seen. */
  236.         private int nbAccuracies;

  238.         /** The number of epochs already seen. */
  239.         private int nbEpochs;

  241.         /** End Of File reached indicator. */
  242.         private boolean done;

  244.         /** The base for pos/vel. */
  245.         //private double posVelBase;

  247.         /** The base for clock/rate. */
  248.         //private double clockBase;

  250.         /** Create a new {@link ParseInfo} object. */
  251.         protected ParseInfo() {
  252.             file               = new SP3File(mu, interpolationSamples, frameBuilder);
  253.             latestEpoch        = null;
  254.             latestPosition     = null;
  255.             latestClock        = 0.0;
  256.             hasVelocityEntries = false;
  257.             timeScale          = TimeScalesFactory.getGPS();
  258.             maxSatellites      = 0;
  259.             nbAccuracies       = 0;
  260.             nbEpochs           = 0;
  261.             done               = false;
  262.             //posVelBase = 2d;
  263.             //clockBase = 2d;
  264.         }
  265.     }

  267.     /** Parsers for specific lines. */
  268.     private enum LineParser {

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

  273.             /** {@inheritDoc} */
  274.             @Override
  275.             public void parse(final String line, final ParseInfo pi) {
  276.                 try (Scanner s1      = new Scanner(line);
  277.                      Scanner s2      = s1.useDelimiter(SPACES);
  278.                      Scanner scanner = s2.useLocale(Locale.US)) {
  279.                     scanner.skip("#");
  280.                     final String v = scanner.next();

  282.                     final char version = v.substring(0, 1).toLowerCase().charAt(0);
  283.                     if (version != 'a' && version != 'b' && version != 'c' && version != 'd') {
  284.                         throw new OrekitException(OrekitMessages.SP3_UNSUPPORTED_VERSION, version);
  285.                     }

  287.                     pi.hasVelocityEntries = "V".equals(v.substring(1, 2));
  288.                     pi.file.setFilter(pi.hasVelocityEntries ?
  289.                                       CartesianDerivativesFilter.USE_PV :
  290.                                       CartesianDerivativesFilter.USE_P);

  292.                     final int    year   = Integer.parseInt(v.substring(2));
  293.                     final int    month  = scanner.nextInt();
  294.                     final int    day    = scanner.nextInt();
  295.                     final int    hour   = scanner.nextInt();
  296.                     final int    minute = scanner.nextInt();
  297.                     final double second = scanner.nextDouble();

  299.                     final AbsoluteDate epoch = new AbsoluteDate(year, month, day,
  300.                                                                 hour, minute, second,
  301.                                                                 TimeScalesFactory.getGPS());

  303.                     pi.file.setEpoch(epoch);

  305.                     final int numEpochs = scanner.nextInt();
  306.                     pi.file.setNumberOfEpochs(numEpochs);

  308.                     // data used indicator
  309.                     pi.file.setDataUsed(scanner.next());

  311.                     pi.file.setCoordinateSystem(scanner.next());
  312.                     pi.file.setOrbitTypeKey(scanner.next());
  313.                     pi.file.setAgency(scanner.next());
  314.                 }
  315.             }

  317.             /** {@inheritDoc} */
  318.             @Override
  319.             public Stream<LineParser> allowedNext() {
  320.                 return Stream.of(HEADER_DATE_TIME_REFERENCE);
  321.             }

  323.         },

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

  328.             /** {@inheritDoc} */
  329.             @Override
  330.             public void parse(final String line, final ParseInfo pi) {
  331.                 try (Scanner s1      = new Scanner(line);
  332.                      Scanner s2      = s1.useDelimiter(SPACES);
  333.                      Scanner scanner = s2.useLocale(Locale.US)) {
  334.                     scanner.skip("##");

  336.                     // gps week
  337.                     pi.file.setGpsWeek(scanner.nextInt());
  338.                     // seconds of week
  339.                     pi.file.setSecondsOfWeek(scanner.nextDouble());
  340.                     // epoch interval
  341.                     pi.file.setEpochInterval(scanner.nextDouble());
  342.                     // julian day
  343.                     pi.file.setJulianDay(scanner.nextInt());
  344.                     // day fraction
  345.                     pi.file.setDayFraction(scanner.nextDouble());
  346.                 }
  347.             }

  349.             /** {@inheritDoc} */
  350.             @Override
  351.             public Stream<LineParser> allowedNext() {
  352.                 return Stream.of(HEADER_SAT_IDS);
  353.             }

  355.         },

  357.         /** Parser for satellites identifiers. */
  358.         HEADER_SAT_IDS("^\\+ .*") {

  360.             /** {@inheritDoc} */
  361.             @Override
  362.             public void parse(final String line, final ParseInfo pi) {

  364.                 if (pi.maxSatellites == 0) {
  365.                     // this is the first ids line, it also contains the number of satellites
  366.                     pi.maxSatellites = Integer.parseInt(line.substring(3, 6).trim());
  367.                 }

  369.                 final int lineLength = line.length();
  370.                 int count = pi.file.getSatelliteCount();
  371.                 int startIdx = 9;
  372.                 while (count++ < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  373.                     final String satId = line.substring(startIdx, startIdx + 3).trim();
  374.                     if (satId.length() > 0) {
  375.                         pi.file.addSatellite(satId);
  376.                     }
  377.                     startIdx += 3;
  378.                 }
  379.             }

  381.             /** {@inheritDoc} */
  382.             @Override
  383.             public Stream<LineParser> allowedNext() {
  384.                 return Stream.of(HEADER_SAT_IDS, HEADER_ACCURACY);
  385.             }

  387.         },

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

  392.             /** {@inheritDoc} */
  393.             @Override
  394.             public void parse(final String line, final ParseInfo pi) {
  395.                 final int lineLength = line.length();
  396.                 int startIdx = 9;
  397.                 while (pi.nbAccuracies < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  398.                     final String sub = line.substring(startIdx, startIdx + 3).trim();
  399.                     if (sub.length() > 0) {
  400.                         final int exponent = Integer.parseInt(sub);
  401.                         // the accuracy is calculated as 2**exp (in mm)
  402.                         pi.file.setAccuracy(pi.nbAccuracies++, (2 << exponent) * MILLIMETER);
  403.                     }
  404.                     startIdx += 3;
  405.                 }
  406.             }

  408.             /** {@inheritDoc} */
  409.             @Override
  410.             public Stream<LineParser> allowedNext() {
  411.                 return Stream.of(HEADER_ACCURACY, HEADER_TIME_SYSTEM);
  412.             }

  414.         },

  416.         /** Parser for time system. */
  417.         HEADER_TIME_SYSTEM("^%c.*") {

  419.             /** {@inheritDoc} */
  420.             @Override
  421.             public void parse(final String line, final ParseInfo pi) {

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

  427.                     // now identify the time system in use
  428.                     final String tsStr = line.substring(9, 12).trim();
  429.                     pi.file.setTimeScaleString(tsStr);
  430.                     final TimeSystem ts;
  431.                     if (tsStr.equalsIgnoreCase("ccc")) {
  432.                         ts = TimeSystem.GPS;
  433.                     } else {
  434.                         ts = TimeSystem.valueOf(tsStr);
  435.                     }
  436.                     pi.file.setTimeSystem(ts);

  438.                     switch (ts) {
  439.                         case GPS:
  440.                             pi.timeScale = TimeScalesFactory.getGPS();
  441.                             break;

  443.                         case GAL:
  444.                             pi.timeScale = TimeScalesFactory.getGST();
  445.                             break;

  447.                         case GLO:
  448.                             pi.timeScale = TimeScalesFactory.getGLONASS();
  449.                             break;

  451.                         case QZS:
  452.                             pi.timeScale = TimeScalesFactory.getQZSS();
  453.                             break;

  455.                         case TAI:
  456.                             pi.timeScale = TimeScalesFactory.getTAI();
  457.                             break;

  459.                         case UTC:
  460.                             pi.timeScale = TimeScalesFactory.getUTC();
  461.                             break;

  463.                         default:
  464.                             pi.timeScale = TimeScalesFactory.getGPS();
  465.                             break;
  466.                     }
  467.                     pi.file.setTimeScale(pi.timeScale);
  468.                 }

  470.             }

  472.             /** {@inheritDoc} */
  473.             @Override
  474.             public Stream<LineParser> allowedNext() {
  475.                 return Stream.of(HEADER_TIME_SYSTEM, HEADER_STANDARD_DEVIATIONS);
  476.             }

  478.         },

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

  483.             /** {@inheritDoc} */
  484.             @Override
  485.             public void parse(final String line, final ParseInfo pi) {
  486.                 // String base = line.substring(3, 13).trim();
  487.                 // if (!base.equals("0.0000000")) {
  488.                 //    // (mm or 10**-4 mm/sec)
  489.                 //    pi.posVelBase = Double.valueOf(base);
  490.                 // }

  492.                 // base = line.substring(14, 26).trim();
  493.                 // if (!base.equals("0.000000000")) {
  494.                 //    // (psec or 10**-4 psec/sec)
  495.                 //    pi.clockBase = Double.valueOf(base);
  496.                 // }
  497.             }

  499.             /** {@inheritDoc} */
  500.             @Override
  501.             public Stream<LineParser> allowedNext() {
  502.                 return Stream.of(HEADER_STANDARD_DEVIATIONS, HEADER_CUSTOM_PARAMETERS);
  503.             }

  505.         },

  507.         /** Parser for custom parameters. */
  508.         HEADER_CUSTOM_PARAMETERS("^%i.*") {

  510.             /** {@inheritDoc} */
  511.             @Override
  512.             public void parse(final String line, final ParseInfo pi) {
  513.                 // ignore additional custom parameters
  514.             }

  516.             /** {@inheritDoc} */
  517.             @Override
  518.             public Stream<LineParser> allowedNext() {
  519.                 return Stream.of(HEADER_CUSTOM_PARAMETERS, HEADER_COMMENTS);
  520.             }

  522.         },

  524.         /** Parser for comments. */
  525.         HEADER_COMMENTS("^/\\*.*") {

  527.             /** {@inheritDoc} */
  528.             @Override
  529.             public void parse(final String line, final ParseInfo pi) {
  530.                 // ignore comments
  531.             }

  533.             /** {@inheritDoc} */
  534.             @Override
  535.             public Stream<LineParser> allowedNext() {
  536.                 return Stream.of(HEADER_COMMENTS, DATA_EPOCH);
  537.             }

  539.         },

  541.         /** Parser for epoch. */
  542.         DATA_EPOCH("^\\* .*") {

  544.             /** {@inheritDoc} */
  545.             @Override
  546.             public void parse(final String line, final ParseInfo pi) {
  547.                 final int    year   = Integer.parseInt(line.substring(3, 7).trim());
  548.                 final int    month  = Integer.parseInt(line.substring(8, 10).trim());
  549.                 final int    day    = Integer.parseInt(line.substring(11, 13).trim());
  550.                 final int    hour   = Integer.parseInt(line.substring(14, 16).trim());
  551.                 final int    minute = Integer.parseInt(line.substring(17, 19).trim());
  552.                 final double second = Double.parseDouble(line.substring(20, 31).trim());

  554.                 pi.latestEpoch = new AbsoluteDate(year, month, day,
  555.                                                   hour, minute, second,
  556.                                                   pi.timeScale);
  557.                 pi.nbEpochs++;
  558.             }

  560.             /** {@inheritDoc} */
  561.             @Override
  562.             public Stream<LineParser> allowedNext() {
  563.                 return Stream.of(DATA_POSITION);
  564.             }

  566.         },

  568.         /** Parser for position. */
  569.         DATA_POSITION("^P.*") {

  571.             /** {@inheritDoc} */
  572.             @Override
  573.             public void parse(final String line, final ParseInfo pi) {
  574.                 final String satelliteId = line.substring(1, 4).trim();

  576.                 if (!pi.file.containsSatellite(satelliteId)) {
  577.                     pi.latestPosition = null;
  578.                 } else {
  579.                     final double x = Double.parseDouble(line.substring(4, 18).trim());
  580.                     final double y = Double.parseDouble(line.substring(18, 32).trim());
  581.                     final double z = Double.parseDouble(line.substring(32, 46).trim());

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

  586.                     // clock (microsec)
  587.                     pi.latestClock =
  588.                             Double.parseDouble(line.substring(46, 60).trim()) * 1e6;

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

  592.                     // if (line.length() >= 73) {
  593.                     // // x-sdev (b**n mm)
  594.                     // int xStdDevExp = Integer.valueOf(line.substring(61,
  595.                     // 63).trim());
  596.                     // // y-sdev (b**n mm)
  597.                     // int yStdDevExp = Integer.valueOf(line.substring(64,
  598.                     // 66).trim());
  599.                     // // z-sdev (b**n mm)
  600.                     // int zStdDevExp = Integer.valueOf(line.substring(67,
  601.                     // 69).trim());
  602.                     // // c-sdev (b**n psec)
  603.                     // int cStdDevExp = Integer.valueOf(line.substring(70,
  604.                     // 73).trim());
  605.                     //
  606.                     // pi.posStdDevRecord =
  607.                     // new PositionStdDevRecord(FastMath.pow(pi.posVelBase, xStdDevExp),
  608.                     // FastMath.pow(pi.posVelBase,
  609.                     // yStdDevExp), FastMath.pow(pi.posVelBase, zStdDevExp),
  610.                     // FastMath.pow(pi.clockBase, cStdDevExp));
  611.                     //
  612.                     // String clockEventFlag = line.substring(74, 75);
  613.                     // String clockPredFlag = line.substring(75, 76);
  614.                     // String maneuverFlag = line.substring(78, 79);
  615.                     // String orbitPredFlag = line.substring(79, 80);
  616.                     // }

  618.                     if (!pi.hasVelocityEntries) {
  619.                         final SP3Coordinate coord =
  620.                                 new SP3Coordinate(pi.latestEpoch,
  621.                                                   pi.latestPosition,
  622.                                                   pi.latestClock);
  623.                         pi.file.addSatelliteCoordinate(satelliteId, coord);
  624.                     }
  625.                 }
  626.             }

  628.             /** {@inheritDoc} */
  629.             @Override
  630.             public Stream<LineParser> allowedNext() {
  631.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_POSITION_CORRELATION, DATA_VELOCITY, EOF);
  632.             }

  634.         },

  636.         /** Parser for position correlation. */
  637.         DATA_POSITION_CORRELATION("^EP.*") {

  639.             /** {@inheritDoc} */
  640.             @Override
  641.             public void parse(final String line, final ParseInfo pi) {
  642.                 // ignored for now
  643.             }

  645.             /** {@inheritDoc} */
  646.             @Override
  647.             public Stream<LineParser> allowedNext() {
  648.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY, EOF);
  649.             }

  651.         },

  653.         /** Parser for velocity. */
  654.         DATA_VELOCITY("^V.*") {

  656.             /** {@inheritDoc} */
  657.             @Override
  658.             public void parse(final String line, final ParseInfo pi) {
  659.                 final String satelliteId = line.substring(1, 4).trim();

  661.                 if (pi.file.containsSatellite(satelliteId)) {
  662.                     final double xv = Double.parseDouble(line.substring(4, 18).trim());
  663.                     final double yv = Double.parseDouble(line.substring(18, 32).trim());
  664.                     final double zv = Double.parseDouble(line.substring(32, 46).trim());

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

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

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

  675.                     // if (line.length() >= 73) {
  676.                     // // xvel-sdev (b**n 10**-4 mm/sec)
  677.                     // int xVstdDevExp = Integer.valueOf(line.substring(61,
  678.                     // 63).trim());
  679.                     // // yvel-sdev (b**n 10**-4 mm/sec)
  680.                     // int yVstdDevExp = Integer.valueOf(line.substring(64,
  681.                     // 66).trim());
  682.                     // // zvel-sdev (b**n 10**-4 mm/sec)
  683.                     // int zVstdDevExp = Integer.valueOf(line.substring(67,
  684.                     // 69).trim());
  685.                     // // clkrate-sdev (b**n 10**-4 psec/sec)
  686.                     // int clkStdDevExp = Integer.valueOf(line.substring(70,
  687.                     // 73).trim());
  688.                     // }

  690.                     final SP3Coordinate coord =
  691.                             new SP3Coordinate(pi.latestEpoch,
  692.                                               pi.latestPosition,
  693.                                               velocity,
  694.                                               pi.latestClock,
  695.                                               clockRateChange);
  696.                     pi.file.addSatelliteCoordinate(satelliteId, coord);
  697.                 }
  698.             }

  700.             /** {@inheritDoc} */
  701.             @Override
  702.             public Stream<LineParser> allowedNext() {
  703.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY_CORRELATION, EOF);
  704.             }

  706.         },

  708.         /** Parser for velocity correlation. */
  709.         DATA_VELOCITY_CORRELATION("^EV.*") {

  711.             /** {@inheritDoc} */
  712.             @Override
  713.             public void parse(final String line, final ParseInfo pi) {
  714.                 // ignored for now
  715.             }

  717.             /** {@inheritDoc} */
  718.             @Override
  719.             public Stream<LineParser> allowedNext() {
  720.                 return Stream.of(DATA_EPOCH, DATA_POSITION, EOF);
  721.             }

  723.         },

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

  728.             /** {@inheritDoc} */
  729.             @Override
  730.             public void parse(final String line, final ParseInfo pi) {
  731.                 pi.done = true;
  732.             }

  734.             /** {@inheritDoc} */
  735.             @Override
  736.             public Stream<LineParser> allowedNext() {
  737.                 return Stream.of(EOF);
  738.             }

  740.         };

  742.         /** Pattern for identifying line. */
  743.         private final Pattern pattern;

  745.         /** Simple constructor.
  746.          * @param lineRegexp regular expression for identifying line
  747.          */
  748.         LineParser(final String lineRegexp) {
  749.             pattern = Pattern.compile(lineRegexp);
  750.         }

  752.         /** Parse a line.
  753.          * @param line line to parse
  754.          * @param pi holder for transient data
  755.          */
  756.         public abstract void parse(String line, ParseInfo pi);

  758.         /** Get the allowed parsers for next line.
  759.          * @return allowed parsers for next line
  760.          */
  761.         public abstract Stream<LineParser> allowedNext();

  763.         /** Check if parser can handle line.
  764.          * @param line line to parse
  765.          * @return true if parser can handle the specified line
  766.          */
  767.         public boolean canHandle(final String line) {
  768.             return pattern.matcher(line).matches();
  769.         }

  771.     }

  773. }
Created with JaCoCo 0.8.2.201808211720