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.Reader;
  22. import java.util.ArrayList;
  23. import java.util.List;
  24. import java.util.Locale;
  25. import java.util.Optional;
  26. import java.util.Scanner;
  27. import java.util.function.Function;
  28. import java.util.regex.Pattern;
  29. import java.util.stream.Stream;

  31. import org.hipparchus.exception.LocalizedCoreFormats;
  32. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  33. import org.hipparchus.util.FastMath;
  34. import org.orekit.annotation.DefaultDataContext;
  35. import org.orekit.data.DataContext;
  36. import org.orekit.data.DataSource;
  37. import org.orekit.errors.OrekitException;
  38. import org.orekit.errors.OrekitIllegalArgumentException;
  39. import org.orekit.errors.OrekitMessages;
  40. import org.orekit.files.general.EphemerisFileParser;
  41. import org.orekit.files.sp3.SP3.SP3Coordinate;
  42. import org.orekit.files.sp3.SP3.SP3FileType;
  43. import org.orekit.frames.Frame;
  44. import org.orekit.gnss.TimeSystem;
  45. import org.orekit.time.AbsoluteDate;
  46. import org.orekit.time.DateComponents;
  47. import org.orekit.time.DateTimeComponents;
  48. import org.orekit.time.TimeComponents;
  49. import org.orekit.time.TimeScale;
  50. import org.orekit.time.TimeScales;
  51. import org.orekit.utils.CartesianDerivativesFilter;
  52. import org.orekit.utils.Constants;
  53. import org.orekit.utils.IERSConventions;

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

  69.     /** Bad or absent clock values are to be set to 999999.999999. */
  70.     public static final double DEFAULT_CLOCK_VALUE = 999999.999999;

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

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

  78.     /** Standard gravitational parameter in m^3 / s^2. */
  79.     private final double mu;
  80.     /** Number of data points to use in interpolation. */
  81.     private final int interpolationSamples;
  82.     /** Mapping from frame identifier in the file to a {@link Frame}. */
  83.     private final Function<? super String, ? extends Frame> frameBuilder;
  84.     /** Set of time scales. */
  85.     private final TimeScales timeScales;

  87.     /**
  88.      * Create an SP3 parser using default values.
  89.      *
  90.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  91.      *
  92.      * @see #SP3Parser(double, int, Function)
  93.      */
  94.     @DefaultDataContext
  95.     public SP3Parser() {
  96.         this(Constants.EIGEN5C_EARTH_MU, 7, SP3Parser::guessFrame);
  97.     }

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

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

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

  160.     @Override
  161.     public SP3 parse(final DataSource source) {

  163.         try (Reader reader = source.getOpener().openReaderOnce();
  164.              BufferedReader br = (reader == null) ? null : new BufferedReader(reader)) {

  166.             if (br == null) {
  167.                 throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, source.getName());
  168.             }

  170.             // initialize internal data structures
  171.             final ParseInfo pi = new ParseInfo();

  173.             int lineNumber = 0;
  174.             Stream<LineParser> candidateParsers = Stream.of(LineParser.HEADER_VERSION);
  175.             for (String line = br.readLine(); line != null; line = br.readLine()) {
  176.                 ++lineNumber;
  177.                 final String l = line;
  178.                 final Optional<LineParser> selected = candidateParsers.filter(p -> p.canHandle(l)).findFirst();
  179.                 if (selected.isPresent()) {
  180.                     try {
  181.                         selected.get().parse(line, pi);
  182.                     } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  183.                         throw new OrekitException(e,
  184.                                                   OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  185.                                                   lineNumber, source.getName(), line);
  186.                     }
  187.                     candidateParsers = selected.get().allowedNext();
  188.                 } else {
  189.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  190.                                               lineNumber, source.getName(), line);
  191.                 }
  192.                 if (pi.done) {
  193.                     if (pi.nbEpochs != pi.file.getNumberOfEpochs()) {
  194.                         throw new OrekitException(OrekitMessages.SP3_NUMBER_OF_EPOCH_MISMATCH,
  195.                                                   pi.nbEpochs, source.getName(), pi.file.getNumberOfEpochs());
  196.                     }
  197.                     return pi.file;
  198.                 }
  199.             }

  201.             // Sometimes, the "EOF" key is not available in the file
  202.             // If the expected number of entries has been read
  203.             // we can suppose that the file has been read properly
  204.             if (pi.nbEpochs == pi.file.getNumberOfEpochs()) {
  205.                 return pi.file;
  206.             }

  208.             // we never reached the EOF marker or number of epochs doesn't correspond to the expected number
  209.             throw new OrekitException(OrekitMessages.SP3_UNEXPECTED_END_OF_FILE, lineNumber);

  211.         } catch (IOException ioe) {
  212.             throw new OrekitException(ioe, LocalizedCoreFormats.SIMPLE_MESSAGE, ioe.getLocalizedMessage());
  213.         }

  215.     }

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

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

  252.         /** Set of time scales for parsing dates. */
  253.         private final TimeScales timeScales;

  255.         /** The corresponding SP3File object. */
  256.         private SP3 file;

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

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

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

  267.         /** Indicates if the SP3 file has velocity entries. */
  268.         private boolean hasVelocityEntries;

  270.         /** The timescale used in the SP3 file. */
  271.         private TimeScale timeScale;

  273.         /** Date and time of the file. */
  274.         private DateTimeComponents epoch;

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

  279.         /** The number of satellites accuracies already seen. */
  280.         private int nbAccuracies;

  282.         /** The number of epochs already seen. */
  283.         private int nbEpochs;

  285.         /** End Of File reached indicator. */
  286.         private boolean done;

  288.         /** The base for pos/vel. */
  289.         //private double posVelBase;

  291.         /** The base for clock/rate. */
  292.         //private double clockBase;

  294.         /** Create a new {@link ParseInfo} object. */
  295.         protected ParseInfo() {
  296.             this.timeScales = SP3Parser.this.timeScales;
  297.             file               = new SP3(mu, interpolationSamples, frameBuilder);
  298.             latestEpoch        = null;
  299.             latestPosition     = null;
  300.             latestClock        = 0.0;
  301.             hasVelocityEntries = false;
  302.             epoch              = DateTimeComponents.JULIAN_EPOCH;
  303.             timeScale          = timeScales.getGPS();
  304.             maxSatellites      = 0;
  305.             nbAccuracies       = 0;
  306.             nbEpochs           = 0;
  307.             done               = false;
  308.             //posVelBase = 2d;
  309.             //clockBase = 2d;
  310.         }
  311.     }

  313.     /** Parsers for specific lines. */
  314.     private enum LineParser {

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

  319.             /** {@inheritDoc} */
  320.             @Override
  321.             public void parse(final String line, final ParseInfo pi) {
  322.                 try (Scanner s1      = new Scanner(line);
  323.                      Scanner s2      = s1.useDelimiter(SPACES);
  324.                      Scanner scanner = s2.useLocale(Locale.US)) {
  325.                     scanner.skip("#");
  326.                     final String v = scanner.next();

  328.                     final char version = v.substring(0, 1).toLowerCase().charAt(0);
  329.                     if (version != 'a' && version != 'b' && version != 'c' && version != 'd') {
  330.                         throw new OrekitException(OrekitMessages.SP3_UNSUPPORTED_VERSION, version);
  331.                     }

  333.                     pi.hasVelocityEntries = "V".equals(v.substring(1, 2));
  334.                     pi.file.setFilter(pi.hasVelocityEntries ?
  335.                                       CartesianDerivativesFilter.USE_PV :
  336.                                       CartesianDerivativesFilter.USE_P);

  338.                     final int    year   = Integer.parseInt(v.substring(2));
  339.                     final int    month  = scanner.nextInt();
  340.                     final int    day    = scanner.nextInt();
  341.                     final int    hour   = scanner.nextInt();
  342.                     final int    minute = scanner.nextInt();
  343.                     final double second = scanner.nextDouble();

  345.                     pi.epoch = new DateTimeComponents(year, month, day,
  346.                                                       hour, minute, second);

  348.                     final int numEpochs = scanner.nextInt();
  349.                     pi.file.setNumberOfEpochs(numEpochs);

  351.                     // data used indicator
  352.                     pi.file.setDataUsed(scanner.next());

  354.                     pi.file.setCoordinateSystem(scanner.next());
  355.                     pi.file.setOrbitTypeKey(scanner.next());
  356.                     pi.file.setAgency(scanner.next());
  357.                 }
  358.             }

  360.             /** {@inheritDoc} */
  361.             @Override
  362.             public Stream<LineParser> allowedNext() {
  363.                 return Stream.of(HEADER_DATE_TIME_REFERENCE);
  364.             }

  366.         },

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

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

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

  392.             /** {@inheritDoc} */
  393.             @Override
  394.             public Stream<LineParser> allowedNext() {
  395.                 return Stream.of(HEADER_SAT_IDS);
  396.             }

  398.         },

  400.         /** Parser for satellites identifiers. */
  401.         HEADER_SAT_IDS("^\\+ .*") {

  403.             /** {@inheritDoc} */
  404.             @Override
  405.             public void parse(final String line, final ParseInfo pi) {

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

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

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

  430.         },

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

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

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

  457.         },

  459.         /** Parser for time system. */
  460.         HEADER_TIME_SYSTEM("^%c.*") {

  462.             /** {@inheritDoc} */
  463.             @Override
  464.             public void parse(final String line, final ParseInfo pi) {

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

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

  481.                     // now we know the time scale used, we can set the file epoch
  482.                     pi.file.setEpoch(new AbsoluteDate(pi.epoch, pi.timeScale));
  483.                 }

  485.             }

  487.             /** {@inheritDoc} */
  488.             @Override
  489.             public Stream<LineParser> allowedNext() {
  490.                 return Stream.of(HEADER_TIME_SYSTEM, HEADER_STANDARD_DEVIATIONS);
  491.             }

  493.         },

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

  498.             /** {@inheritDoc} */
  499.             @Override
  500.             public void parse(final String line, final ParseInfo pi) {
  501.                 // String base = line.substring(3, 13).trim();
  502.                 // if (!base.equals("0.0000000")) {
  503.                 //    // (mm or 10**-4 mm/sec)
  504.                 //    pi.posVelBase = Double.valueOf(base);
  505.                 // }

  507.                 // base = line.substring(14, 26).trim();
  508.                 // if (!base.equals("0.000000000")) {
  509.                 //    // (psec or 10**-4 psec/sec)
  510.                 //    pi.clockBase = Double.valueOf(base);
  511.                 // }
  512.             }

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

  520.         },

  522.         /** Parser for custom parameters. */
  523.         HEADER_CUSTOM_PARAMETERS("^%i.*") {

  525.             /** {@inheritDoc} */
  526.             @Override
  527.             public void parse(final String line, final ParseInfo pi) {
  528.                 // ignore additional custom parameters
  529.             }

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

  537.         },

  539.         /** Parser for comments. */
  540.         HEADER_COMMENTS("^[%]?/\\*.*|") {

  542.             /** {@inheritDoc} */
  543.             @Override
  544.             public void parse(final String line, final ParseInfo pi) {
  545.                 // ignore comments
  546.             }

  548.             /** {@inheritDoc} */
  549.             @Override
  550.             public Stream<LineParser> allowedNext() {
  551.                 return Stream.of(HEADER_COMMENTS, DATA_EPOCH);
  552.             }

  554.         },

  556.         /** Parser for epoch. */
  557.         DATA_EPOCH("^\\* .*") {

  559.             /** {@inheritDoc} */
  560.             @Override
  561.             public void parse(final String line, final ParseInfo pi) {
  562.                 final int    year   = Integer.parseInt(line.substring(3, 7).trim());
  563.                 final int    month  = Integer.parseInt(line.substring(8, 10).trim());
  564.                 final int    day    = Integer.parseInt(line.substring(11, 13).trim());
  565.                 final int    hour   = Integer.parseInt(line.substring(14, 16).trim());
  566.                 final int    minute = Integer.parseInt(line.substring(17, 19).trim());
  567.                 final double second = Double.parseDouble(line.substring(20).trim());

  569.                 // some SP3 files have weird epochs as in the following two examples, where
  570.                 // the middle dates are wrong
  571.                 //
  572.                 // *  2016  7  6 16 58  0.00000000
  573.                 // PL51  11872.234459   3316.551981    101.400098 999999.999999
  574.                 // VL51   8054.606014 -27076.640110 -53372.762255 999999.999999
  575.                 // *  2016  7  6 16 60  0.00000000
  576.                 // PL51  11948.228978   2986.113872   -538.901114 999999.999999
  577.                 // VL51   4605.419303 -27972.588048 -53316.820671 999999.999999
  578.                 // *  2016  7  6 17  2  0.00000000
  579.                 // PL51  11982.652569   2645.786926  -1177.549463 999999.999999
  580.                 // VL51   1128.248622 -28724.293303 -53097.358387 999999.999999
  581.                 //
  582.                 // *  2016  7  6 23 58  0.00000000
  583.                 // PL51   3215.382310  -7958.586164   8812.395707
  584.                 // VL51 -18058.659942 -45834.335707 -34496.540437
  585.                 // *  2016  7  7 24  0  0.00000000
  586.                 // PL51   2989.229334  -8494.421415   8385.068555
  587.                 // VL51 -19617.027447 -43444.824985 -36706.159070
  588.                 // *  2016  7  7  0  2  0.00000000
  589.                 // PL51   2744.983592  -9000.639164   7931.904779
  590.                 // VL51 -21072.925764 -40899.633288 -38801.567078
  591.                 //
  592.                 // In the first case, the date should really be 2016  7  6 17  0  0.00000000,
  593.                 // i.e as the minutes field overflows, the hours field should be incremented
  594.                 // In the second case, the date should really be 2016  7  7  0  0  0.00000000,
  595.                 // i.e. as the hours field overflows, the day field should be kept as is
  596.                 // we cannot be sure how carry was managed when these bogus files were written
  597.                 // so we try different options, incrementing or not previous field, and selecting
  598.                 // the closest one to expected date
  599.                 DateComponents dc = new DateComponents(year, month, day);
  600.                 final List<AbsoluteDate> candidates = new ArrayList<>();
  601.                 int h = hour;
  602.                 int m = minute;
  603.                 double s = second;
  604.                 if (s >= 60.0) {
  605.                     s -= 60;
  606.                     addCandidate(candidates, dc, h, m, s, pi.timeScale);
  607.                     m++;
  608.                 }
  609.                 if (m > 59) {
  610.                     m = 0;
  611.                     addCandidate(candidates, dc, h, m, s, pi.timeScale);
  612.                     h++;
  613.                 }
  614.                 if (h > 23) {
  615.                     h = 0;
  616.                     addCandidate(candidates, dc, h, m, s, pi.timeScale);
  617.                     dc = new DateComponents(dc, 1);
  618.                 }
  619.                 addCandidate(candidates, dc, h, m, s, pi.timeScale);
  620.                 final AbsoluteDate expected = pi.latestEpoch == null ?
  621.                                               pi.file.getEpoch() :
  622.                                                   pi.latestEpoch.shiftedBy(pi.file.getEpochInterval());
  623.                 pi.latestEpoch = null;
  624.                 for (final AbsoluteDate candidate : candidates) {
  625.                     if (FastMath.abs(candidate.durationFrom(expected)) < 0.01 * pi.file.getEpochInterval()) {
  626.                         pi.latestEpoch = candidate;
  627.                     }
  628.                 }
  629.                 if (pi.latestEpoch == null) {
  630.                     // no date recognized, just parse again the initial fields
  631.                     // in order to generate again an exception
  632.                     pi.latestEpoch = new AbsoluteDate(year, month, day, hour, minute, second, pi.timeScale);
  633.                 }
  634.                 pi.nbEpochs++;
  635.             }

  637.             /** Add an epoch candidate to a list.
  638.              * @param candidates list of candidates
  639.              * @param dc date components
  640.              * @param hour hour number from 0 to 23
  641.              * @param minute minute number from 0 to 59
  642.              * @param second second number from 0.0 to 60.0 (excluded)
  643.              * @param timeScale time scale
  644.              * @since 11.1.1
  645.              */
  646.             private void addCandidate(final List<AbsoluteDate> candidates, final DateComponents dc,
  647.                                       final int hour, final int minute, final double second,
  648.                                       final TimeScale timeScale) {
  649.                 try {
  650.                     candidates.add(new AbsoluteDate(dc, new TimeComponents(hour, minute, second), timeScale));
  651.                 } catch (OrekitIllegalArgumentException oiae) {
  652.                     // ignored
  653.                 }
  654.             }

  656.             /** {@inheritDoc} */
  657.             @Override
  658.             public Stream<LineParser> allowedNext() {
  659.                 return Stream.of(DATA_POSITION);
  660.             }

  662.         },

  664.         /** Parser for position. */
  665.         DATA_POSITION("^P.*") {

  667.             /** {@inheritDoc} */
  668.             @Override
  669.             public void parse(final String line, final ParseInfo pi) {
  670.                 final String satelliteId = line.substring(1, 4).trim();

  672.                 if (!pi.file.containsSatellite(satelliteId)) {
  673.                     pi.latestPosition = null;
  674.                 } else {
  675.                     final double x = Double.parseDouble(line.substring(4, 18).trim());
  676.                     final double y = Double.parseDouble(line.substring(18, 32).trim());
  677.                     final double z = Double.parseDouble(line.substring(32, 46).trim());

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

  682.                     // clock (microsec)
  683.                     pi.latestClock = line.trim().length() <= 46 ?
  684.                                                           DEFAULT_CLOCK_VALUE :
  685.                                                               Double.parseDouble(line.substring(46, 60).trim()) * 1e-6;

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

  689.                     // if (line.length() >= 73) {
  690.                     // // x-sdev (b**n mm)
  691.                     // int xStdDevExp = Integer.valueOf(line.substring(61,
  692.                     // 63).trim());
  693.                     // // y-sdev (b**n mm)
  694.                     // int yStdDevExp = Integer.valueOf(line.substring(64,
  695.                     // 66).trim());
  696.                     // // z-sdev (b**n mm)
  697.                     // int zStdDevExp = Integer.valueOf(line.substring(67,
  698.                     // 69).trim());
  699.                     // // c-sdev (b**n psec)
  700.                     // int cStdDevExp = Integer.valueOf(line.substring(70,
  701.                     // 73).trim());
  702.                     //
  703.                     // pi.posStdDevRecord =
  704.                     // new PositionStdDevRecord(FastMath.pow(pi.posVelBase, xStdDevExp),
  705.                     // FastMath.pow(pi.posVelBase,
  706.                     // yStdDevExp), FastMath.pow(pi.posVelBase, zStdDevExp),
  707.                     // FastMath.pow(pi.clockBase, cStdDevExp));
  708.                     //
  709.                     // String clockEventFlag = line.substring(74, 75);
  710.                     // String clockPredFlag = line.substring(75, 76);
  711.                     // String maneuverFlag = line.substring(78, 79);
  712.                     // String orbitPredFlag = line.substring(79, 80);
  713.                     // }

  715.                     if (!pi.hasVelocityEntries) {
  716.                         final SP3Coordinate coord =
  717.                                 new SP3Coordinate(pi.latestEpoch,
  718.                                                   pi.latestPosition,
  719.                                                   pi.latestClock);
  720.                         pi.file.addSatelliteCoordinate(satelliteId, coord);
  721.                     }
  722.                 }
  723.             }

  725.             /** {@inheritDoc} */
  726.             @Override
  727.             public Stream<LineParser> allowedNext() {
  728.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_POSITION_CORRELATION, DATA_VELOCITY, EOF);
  729.             }

  731.         },

  733.         /** Parser for position correlation. */
  734.         DATA_POSITION_CORRELATION("^EP.*") {

  736.             /** {@inheritDoc} */
  737.             @Override
  738.             public void parse(final String line, final ParseInfo pi) {
  739.                 // ignored for now
  740.             }

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

  748.         },

  750.         /** Parser for velocity. */
  751.         DATA_VELOCITY("^V.*") {

  753.             /** {@inheritDoc} */
  754.             @Override
  755.             public void parse(final String line, final ParseInfo pi) {
  756.                 final String satelliteId = line.substring(1, 4).trim();

  758.                 if (pi.file.containsSatellite(satelliteId)) {
  759.                     final double xv = Double.parseDouble(line.substring(4, 18).trim());
  760.                     final double yv = Double.parseDouble(line.substring(18, 32).trim());
  761.                     final double zv = Double.parseDouble(line.substring(32, 46).trim());

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

  766.                     // clock rate in file is 1e-4 us / s
  767.                     final double clockRateChange = line.trim().length() <= 46 ?
  768.                                                                         DEFAULT_CLOCK_VALUE :
  769.                                                                             Double.parseDouble(line.substring(46, 60).trim()) * 1e-4;

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

  773.                     // if (line.length() >= 73) {
  774.                     // // xvel-sdev (b**n 10**-4 mm/sec)
  775.                     // int xVstdDevExp = Integer.valueOf(line.substring(61,
  776.                     // 63).trim());
  777.                     // // yvel-sdev (b**n 10**-4 mm/sec)
  778.                     // int yVstdDevExp = Integer.valueOf(line.substring(64,
  779.                     // 66).trim());
  780.                     // // zvel-sdev (b**n 10**-4 mm/sec)
  781.                     // int zVstdDevExp = Integer.valueOf(line.substring(67,
  782.                     // 69).trim());
  783.                     // // clkrate-sdev (b**n 10**-4 psec/sec)
  784.                     // int clkStdDevExp = Integer.valueOf(line.substring(70,
  785.                     // 73).trim());
  786.                     // }

  788.                     final SP3Coordinate coord =
  789.                             new SP3Coordinate(pi.latestEpoch,
  790.                                               pi.latestPosition,
  791.                                               velocity,
  792.                                               pi.latestClock,
  793.                                               clockRateChange);
  794.                     pi.file.addSatelliteCoordinate(satelliteId, coord);
  795.                 }
  796.             }

  798.             /** {@inheritDoc} */
  799.             @Override
  800.             public Stream<LineParser> allowedNext() {
  801.                 return Stream.of(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY_CORRELATION, EOF);
  802.             }

  804.         },

  806.         /** Parser for velocity correlation. */
  807.         DATA_VELOCITY_CORRELATION("^EV.*") {

  809.             /** {@inheritDoc} */
  810.             @Override
  811.             public void parse(final String line, final ParseInfo pi) {
  812.                 // ignored for now
  813.             }

  815.             /** {@inheritDoc} */
  816.             @Override
  817.             public Stream<LineParser> allowedNext() {
  818.                 return Stream.of(DATA_EPOCH, DATA_POSITION, EOF);
  819.             }

  821.         },

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

  826.             /** {@inheritDoc} */
  827.             @Override
  828.             public void parse(final String line, final ParseInfo pi) {
  829.                 pi.done = true;
  830.             }

  832.             /** {@inheritDoc} */
  833.             @Override
  834.             public Stream<LineParser> allowedNext() {
  835.                 return Stream.of(EOF);
  836.             }

  838.         };

  840.         /** Pattern for identifying line. */
  841.         private final Pattern pattern;

  843.         /** Simple constructor.
  844.          * @param lineRegexp regular expression for identifying line
  845.          */
  846.         LineParser(final String lineRegexp) {
  847.             pattern = Pattern.compile(lineRegexp);
  848.         }

  850.         /** Parse a line.
  851.          * @param line line to parse
  852.          * @param pi holder for transient data
  853.          */
  854.         public abstract void parse(String line, ParseInfo pi);

  856.         /** Get the allowed parsers for next line.
  857.          * @return allowed parsers for next line
  858.          */
  859.         public abstract Stream<LineParser> allowedNext();

  861.         /** Check if parser can handle line.
  862.          * @param line line to parse
  863.          * @return true if parser can handle the specified line
  864.          */
  865.         public boolean canHandle(final String line) {
  866.             return pattern.matcher(line).matches();
  867.         }

  869.     }

  871. }
Created with JaCoCo 0.8.8.202204050719