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.Arrays;
  24. import java.util.Collections;
  25. import java.util.List;
  26. import java.util.Locale;
  27. import java.util.Scanner;
  28. import java.util.function.Function;
  29. import java.util.regex.Pattern;

  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.frames.Frame;
  42. import org.orekit.gnss.TimeSystem;
  43. import org.orekit.time.AbsoluteDate;
  44. import org.orekit.time.DateComponents;
  45. import org.orekit.time.DateTimeComponents;
  46. import org.orekit.time.TimeComponents;
  47. import org.orekit.time.TimeScale;
  48. import org.orekit.time.TimeScales;
  49. import org.orekit.utils.CartesianDerivativesFilter;
  50. import org.orekit.utils.Constants;
  51. import org.orekit.utils.IERSConventions;

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

  67.     /** String representation of the center of ephemeris coordinate system. **/
  68.     public static final String SP3_FRAME_CENTER_STRING = "EARTH";

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

  73.     /** Standard gravitational parameter in m³/s². */
  74.     private final double mu;

  76.     /** Number of data points to use in interpolation. */
  77.     private final int interpolationSamples;

  79.     /** Mapping from frame identifier in the file to a {@link Frame}. */
  80.     private final Function<? super String, ? extends Frame> frameBuilder;

  82.     /** Set of time scales. */
  83.     private final TimeScales timeScales;

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

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

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

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

  158.     @Override
  159.     public SP3 parse(final DataSource source) {

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

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

  168.             // initialize internal data structures
  169.             final ParseInfo pi = new ParseInfo(source.getName());

  171.             int lineNumber = 0;
  172.             Iterable<LineParser> candidateParsers = Collections.singleton(LineParser.HEADER_VERSION);
  173.             nextLine:
  174.                 for (String line = br.readLine(); line != null; line = br.readLine()) {
  175.                     ++lineNumber;
  176.                     for (final LineParser candidate : candidateParsers) {
  177.                         if (candidate.canHandle(line)) {
  178.                             try {
  179.                                 candidate.parse(line, pi);
  180.                                 if (pi.done) {
  181.                                     break nextLine;
  182.                                 }
  183.                                 candidateParsers = candidate.allowedNext();
  184.                                 continue nextLine;
  185.                             } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  186.                                 throw new OrekitException(e,
  187.                                                           OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  188.                                                           lineNumber, pi.fileName, line);
  189.                             }
  190.                         }
  191.                     }

  193.                     // no parsers found for this line
  194.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  195.                                               lineNumber, pi.fileName, line);

  197.                 }

  199.             pi.file.validate(true, pi.fileName);
  200.             return pi.file;

  202.         } catch (IOException ioe) {
  203.             throw new OrekitException(ioe, LocalizedCoreFormats.SIMPLE_MESSAGE, ioe.getLocalizedMessage());
  204.         }

  206.     }

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

  215.         /** File name.
  216.          * @since 12.0
  217.          */
  218.         private final String fileName;

  220.         /** Set of time scales for parsing dates. */
  221.         private final TimeScales timeScales;

  223.         /** The corresponding SP3File object. */
  224.         private SP3 file;

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

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

  232.         /** The latest position accuracy as read from the SP3 file.
  233.          * @since 12.0
  234.          */
  235.         private Vector3D latestPositionAccuracy;

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

  240.         /** The latest clock value as read from the SP3 file.
  241.          * @since 12.0
  242.          */
  243.         private double latestClockAccuracy;

  245.         /** The latest clock event flag as read from the SP3 file.
  246.          * @since 12.0
  247.          */
  248.         private boolean latestClockEvent;

  250.         /** The latest clock prediction flag as read from the SP3 file.
  251.          * @since 12.0
  252.          */
  253.         private boolean latestClockPrediction;

  255.         /** The latest orbit maneuver event flag as read from the SP3 file.
  256.          * @since 12.0
  257.          */
  258.         private boolean latestOrbitManeuverEvent;

  260.         /** The latest orbit prediction flag as read from the SP3 file.
  261.          * @since 12.0
  262.          */
  263.         private boolean latestOrbitPrediction;

  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.         /** Date and time of the file. */
  272.         private DateTimeComponents epoch;

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

  277.         /** The number of satellites accuracies already seen. */
  278.         private int nbAccuracies;

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

  283.         /** Create a new {@link ParseInfo} object.
  284.          * @param fileName file name
  285.          */
  286.         protected ParseInfo(final String fileName) {
  287.             this.fileName      = fileName;
  288.             this.timeScales    = SP3Parser.this.timeScales;
  289.             file               = new SP3(mu, interpolationSamples, frameBuilder.apply(SP3_FRAME_CENTER_STRING));
  290.             latestEpoch        = null;
  291.             latestPosition     = null;
  292.             latestClock        = 0.0;
  293.             hasVelocityEntries = false;
  294.             epoch              = DateTimeComponents.JULIAN_EPOCH;
  295.             timeScale          = timeScales.getGPS();
  296.             maxSatellites      = 0;
  297.             nbAccuracies       = 0;
  298.             done               = false;
  299.         }
  300.     }

  302.     /** Parsers for specific lines. */
  303.     private enum LineParser {

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

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

  317.                     pi.file.getHeader().setVersion(v.substring(0, 1).toLowerCase().charAt(0));

  319.                     pi.hasVelocityEntries = "V".equals(v.substring(1, 2));
  320.                     pi.file.getHeader().setFilter(pi.hasVelocityEntries ?
  321.                                                   CartesianDerivativesFilter.USE_PV :
  322.                                                   CartesianDerivativesFilter.USE_P);

  324.                     final int    year   = Integer.parseInt(v.substring(2));
  325.                     final int    month  = scanner.nextInt();
  326.                     final int    day    = scanner.nextInt();
  327.                     final int    hour   = scanner.nextInt();
  328.                     final int    minute = scanner.nextInt();
  329.                     final double second = scanner.nextDouble();

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

  334.                     final int numEpochs = scanner.nextInt();
  335.                     pi.file.getHeader().setNumberOfEpochs(numEpochs);

  337.                     // data used indicator
  338.                     final String fullSpec = scanner.next();
  339.                     final List<DataUsed> dataUsed = new ArrayList<>();
  340.                     for (final String specifier : fullSpec.split("\\+")) {
  341.                         dataUsed.add(DataUsed.parse(specifier, pi.fileName, pi.file.getHeader().getVersion()));
  342.                     }
  343.                     pi.file.getHeader().setDataUsed(dataUsed);

  345.                     pi.file.getHeader().setCoordinateSystem(scanner.next());
  346.                     pi.file.getHeader().setOrbitTypeKey(scanner.next());
  347.                     pi.file.getHeader().setAgency(scanner.next());
  348.                 }
  349.             }

  351.             /** {@inheritDoc} */
  352.             @Override
  353.             public Iterable<LineParser> allowedNext() {
  354.                 return Collections.singleton(HEADER_DATE_TIME_REFERENCE);
  355.             }

  357.         },

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

  362.             /** {@inheritDoc} */
  363.             @Override
  364.             public void parse(final String line, final ParseInfo pi) {
  365.                 try (Scanner s1      = new Scanner(line);
  366.                      Scanner s2      = s1.useDelimiter(SPACES);
  367.                      Scanner scanner = s2.useLocale(Locale.US)) {
  368.                     scanner.skip("##");

  370.                     // gps week
  371.                     pi.file.getHeader().setGpsWeek(scanner.nextInt());
  372.                     // seconds of week
  373.                     pi.file.getHeader().setSecondsOfWeek(scanner.nextDouble());
  374.                     // epoch interval
  375.                     pi.file.getHeader().setEpochInterval(scanner.nextDouble());
  376.                     // modified julian day
  377.                     pi.file.getHeader().setModifiedJulianDay(scanner.nextInt());
  378.                     // day fraction
  379.                     pi.file.getHeader().setDayFraction(scanner.nextDouble());
  380.                 }
  381.             }

  383.             /** {@inheritDoc} */
  384.             @Override
  385.             public Iterable<LineParser> allowedNext() {
  386.                 return Collections.singleton(HEADER_SAT_IDS);
  387.             }

  389.         },

  391.         /** Parser for satellites identifiers. */
  392.         HEADER_SAT_IDS("^\\+ .*") {

  394.             /** {@inheritDoc} */
  395.             @Override
  396.             public void parse(final String line, final ParseInfo pi) {

  398.                 if (pi.maxSatellites == 0) {
  399.                     // this is the first ids line, it also contains the number of satellites
  400.                     pi.maxSatellites = Integer.parseInt(line.substring(3, 6).trim());
  401.                 }

  403.                 final int lineLength = line.length();
  404.                 int count = pi.file.getSatelliteCount();
  405.                 int startIdx = 9;
  406.                 while (count++ < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  407.                     final String satId = line.substring(startIdx, startIdx + 3).trim();
  408.                     if (satId.length() > 0) {
  409.                         pi.file.addSatellite(satId);
  410.                     }
  411.                     startIdx += 3;
  412.                 }
  413.             }

  415.             /** {@inheritDoc} */
  416.             @Override
  417.             public Iterable<LineParser> allowedNext() {
  418.                 return Arrays.asList(HEADER_SAT_IDS, HEADER_ACCURACY);
  419.             }

  421.         },

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

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

  445.             /** {@inheritDoc} */
  446.             @Override
  447.             public Iterable<LineParser> allowedNext() {
  448.                 return Arrays.asList(HEADER_ACCURACY, HEADER_TIME_SYSTEM);
  449.             }

  451.         },

  453.         /** Parser for time system. */
  454.         HEADER_TIME_SYSTEM("^%c.*") {

  456.             /** {@inheritDoc} */
  457.             @Override
  458.             public void parse(final String line, final ParseInfo pi) {

  460.                 if (pi.file.getHeader().getType() == null) {
  461.                     // this the first custom fields line, the only one really used
  462.                     pi.file.getHeader().setType(SP3FileType.parse(line.substring(3, 5).trim()));

  464.                     // now identify the time system in use
  465.                     final String tsStr = line.substring(9, 12).trim();
  466.                     final TimeSystem ts;
  467.                     if (tsStr.equalsIgnoreCase("ccc")) {
  468.                         ts = TimeSystem.GPS;
  469.                     } else {
  470.                         ts = TimeSystem.valueOf(tsStr);
  471.                     }
  472.                     pi.file.getHeader().setTimeSystem(ts);
  473.                     pi.timeScale = ts.getTimeScale(pi.timeScales);

  475.                     // now we know the time scale used, we can set the file epoch
  476.                     pi.file.getHeader().setEpoch(new AbsoluteDate(pi.epoch, pi.timeScale));
  477.                 }

  479.             }

  481.             /** {@inheritDoc} */
  482.             @Override
  483.             public Iterable<LineParser> allowedNext() {
  484.                 return Arrays.asList(HEADER_TIME_SYSTEM, HEADER_STANDARD_DEVIATIONS);
  485.             }

  487.         },

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

  492.             /** {@inheritDoc} */
  493.             @Override
  494.             public void parse(final String line, final ParseInfo pi) {
  495.                 final double posVelBase = Double.parseDouble(line.substring(3, 13).trim());
  496.                 if (posVelBase != 0.0) {
  497.                     // (mm or 10⁻⁴ mm/s)
  498.                     pi.file.getHeader().setPosVelBase(posVelBase);
  499.                 }

  501.                 final double clockBase = Double.parseDouble(line.substring(14, 26).trim());
  502.                 if (clockBase != 0.0) {
  503.                     // (ps or 10⁻⁴ ps/s)
  504.                     pi.file.getHeader().setClockBase(clockBase);
  505.                 }
  506.             }

  508.             /** {@inheritDoc} */
  509.             @Override
  510.             public Iterable<LineParser> allowedNext() {
  511.                 return Arrays.asList(HEADER_STANDARD_DEVIATIONS, HEADER_CUSTOM_PARAMETERS);
  512.             }

  514.         },

  516.         /** Parser for custom parameters. */
  517.         HEADER_CUSTOM_PARAMETERS("^%i.*") {

  519.             /** {@inheritDoc} */
  520.             @Override
  521.             public void parse(final String line, final ParseInfo pi) {
  522.                 // ignore additional custom parameters
  523.             }

  525.             /** {@inheritDoc} */
  526.             @Override
  527.             public Iterable<LineParser> allowedNext() {
  528.                 return Arrays.asList(HEADER_CUSTOM_PARAMETERS, HEADER_COMMENTS);
  529.             }

  531.         },

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

  536.             /** {@inheritDoc} */
  537.             @Override
  538.             public void parse(final String line, final ParseInfo pi) {
  539.                 pi.file.getHeader().addComment(line.substring(line.indexOf('*') + 1).trim());
  540.             }

  542.             /** {@inheritDoc} */
  543.             @Override
  544.             public Iterable<LineParser> allowedNext() {
  545.                 return Arrays.asList(HEADER_COMMENTS, DATA_EPOCH);
  546.             }

  548.         },

  550.         /** Parser for epoch. */
  551.         DATA_EPOCH("^\\* .*") {

  553.             /** {@inheritDoc} */
  554.             @Override
  555.             public void parse(final String line, final ParseInfo pi) {
  556.                 final int    year;
  557.                 final int    month;
  558.                 final int    day;
  559.                 final int    hour;
  560.                 final int    minute;
  561.                 final double second;
  562.                 try (Scanner s1      = new Scanner(line);
  563.                      Scanner s2      = s1.useDelimiter(SPACES);
  564.                      Scanner scanner = s2.useLocale(Locale.US)) {
  565.                     scanner.skip("\\*");
  566.                     year   = scanner.nextInt();
  567.                     month  = scanner.nextInt();
  568.                     day    = scanner.nextInt();
  569.                     hour   = scanner.nextInt();
  570.                     minute = scanner.nextInt();
  571.                     second = scanner.nextDouble();
  572.                 }

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

  653.             }

  655.             /** Add an epoch candidate to a list.
  656.              * @param candidates list of candidates
  657.              * @param dc date components
  658.              * @param hour hour number from 0 to 23
  659.              * @param minute minute number from 0 to 59
  660.              * @param second second number from 0.0 to 60.0 (excluded)
  661.              * @param timeScale time scale
  662.              * @since 11.1.1
  663.              */
  664.             private void addCandidate(final List<AbsoluteDate> candidates, final DateComponents dc,
  665.                                       final int hour, final int minute, final double second,
  666.                                       final TimeScale timeScale) {
  667.                 try {
  668.                     candidates.add(new AbsoluteDate(dc, new TimeComponents(hour, minute, second), timeScale));
  669.                 } catch (OrekitIllegalArgumentException oiae) {
  670.                     // ignored
  671.                 }
  672.             }

  674.             /** {@inheritDoc} */
  675.             @Override
  676.             public Iterable<LineParser> allowedNext() {
  677.                 return Collections.singleton(DATA_POSITION);
  678.             }

  680.         },

  682.         /** Parser for position. */
  683.         DATA_POSITION("^P.*") {

  685.             /** {@inheritDoc} */
  686.             @Override
  687.             public void parse(final String line, final ParseInfo pi) {
  688.                 final String satelliteId = line.substring(1, 4).trim();

  690.                 if (!pi.file.containsSatellite(satelliteId)) {
  691.                     pi.latestPosition = Vector3D.ZERO;
  692.                 } else {

  694.                     final SP3Header header = pi.file.getHeader();

  696.                     // the position values are in km and have to be converted to m
  697.                     pi.latestPosition = new Vector3D(SP3Utils.POSITION_UNIT.toSI(Double.parseDouble(line.substring(4, 18).trim())),
  698.                                                      SP3Utils.POSITION_UNIT.toSI(Double.parseDouble(line.substring(18, 32).trim())),
  699.                                                      SP3Utils.POSITION_UNIT.toSI(Double.parseDouble(line.substring(32, 46).trim())));

  701.                     // clock (microsec)
  702.                     pi.latestClock = SP3Utils.CLOCK_UNIT.toSI(line.trim().length() <= 46 ?
  703.                                                               SP3Utils.DEFAULT_CLOCK_VALUE :
  704.                                                               Double.parseDouble(line.substring(46, 60).trim()));

  706.                     if (pi.latestPosition.getNorm() > 0) {

  708.                         if (line.length() < 69 || line.substring(61, 69).trim().length() == 0) {
  709.                             pi.latestPositionAccuracy = null;
  710.                         } else {
  711.                             pi.latestPositionAccuracy = new Vector3D(SP3Utils.siAccuracy(SP3Utils.POSITION_ACCURACY_UNIT,
  712.                                                                                          header.getPosVelBase(),
  713.                                                                                          Integer.parseInt(line.substring(61, 63).trim())),
  714.                                                                      SP3Utils.siAccuracy(SP3Utils.POSITION_ACCURACY_UNIT,
  715.                                                                                          header.getPosVelBase(),
  716.                                                                                          Integer.parseInt(line.substring(64, 66).trim())),
  717.                                                                      SP3Utils.siAccuracy(SP3Utils.POSITION_ACCURACY_UNIT,
  718.                                                                                          header.getPosVelBase(),
  719.                                                                                          Integer.parseInt(line.substring(67, 69).trim())));
  720.                         }

  722.                         if (line.length() < 73 || line.substring(70, 73).trim().length() == 0) {
  723.                             pi.latestClockAccuracy    = Double.NaN;
  724.                         } else {
  725.                             pi.latestClockAccuracy    = SP3Utils.siAccuracy(SP3Utils.CLOCK_ACCURACY_UNIT,
  726.                                                                             header.getClockBase(),
  727.                                                                             Integer.parseInt(line.substring(70, 73).trim()));
  728.                         }

  730.                         pi.latestClockEvent         = line.length() < 75 ? false : line.substring(74, 75).equals("E");
  731.                         pi.latestClockPrediction    = line.length() < 76 ? false : line.substring(75, 76).equals("P");
  732.                         pi.latestOrbitManeuverEvent = line.length() < 79 ? false : line.substring(78, 79).equals("M");
  733.                         pi.latestOrbitPrediction    = line.length() < 80 ? false : line.substring(79, 80).equals("P");

  735.                         if (!pi.hasVelocityEntries) {
  736.                             final SP3Coordinate coord =
  737.                                             new SP3Coordinate(pi.latestEpoch,
  738.                                                               pi.latestPosition,           pi.latestPositionAccuracy,
  739.                                                               Vector3D.ZERO,               null,
  740.                                                               pi.latestClock,              pi.latestClockAccuracy,
  741.                                                               0.0,                         Double.NaN,
  742.                                                               pi.latestClockEvent,         pi.latestClockPrediction,
  743.                                                               pi.latestOrbitManeuverEvent, pi.latestOrbitPrediction);
  744.                             pi.file.getEphemeris(satelliteId).addCoordinate(coord, header.getEpochInterval());
  745.                         }
  746.                     }
  747.                 }
  748.             }

  750.             /** {@inheritDoc} */
  751.             @Override
  752.             public Iterable<LineParser> allowedNext() {
  753.                 return Arrays.asList(DATA_EPOCH, DATA_POSITION, DATA_POSITION_CORRELATION, DATA_VELOCITY, EOF);
  754.             }

  756.         },

  758.         /** Parser for position correlation. */
  759.         DATA_POSITION_CORRELATION("^EP.*") {

  761.             /** {@inheritDoc} */
  762.             @Override
  763.             public void parse(final String line, final ParseInfo pi) {
  764.                 // ignored for now
  765.             }

  767.             /** {@inheritDoc} */
  768.             @Override
  769.             public Iterable<LineParser> allowedNext() {
  770.                 return Arrays.asList(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY, EOF);
  771.             }

  773.         },

  775.         /** Parser for velocity. */
  776.         DATA_VELOCITY("^V.*") {

  778.             /** {@inheritDoc} */
  779.             @Override
  780.             public void parse(final String line, final ParseInfo pi) {
  781.                 final String satelliteId = line.substring(1, 4).trim();

  783.                 if (pi.file.containsSatellite(satelliteId) && pi.latestPosition.getNorm() > 0) {

  785.                     final SP3Header header = pi.file.getHeader();

  787.                     // the velocity values are in dm/s and have to be converted to m/s
  788.                     final Vector3D velocity = new Vector3D(SP3Utils.VELOCITY_UNIT.toSI(Double.parseDouble(line.substring(4, 18).trim())),
  789.                                                            SP3Utils.VELOCITY_UNIT.toSI(Double.parseDouble(line.substring(18, 32).trim())),
  790.                                                            SP3Utils.VELOCITY_UNIT.toSI(Double.parseDouble(line.substring(32, 46).trim())));

  792.                     // clock rate in file is 1e-4 us / s
  793.                     final double clockRateChange = SP3Utils.CLOCK_RATE_UNIT.toSI(line.trim().length() <= 46 ?
  794.                                                                                  SP3Utils.DEFAULT_CLOCK_RATE_VALUE :
  795.                                                                                  Double.parseDouble(line.substring(46, 60).trim()));

  797.                     final Vector3D velocityAccuracy;
  798.                     if (line.length() < 69 || line.substring(61, 69).trim().length() == 0) {
  799.                         velocityAccuracy  = null;
  800.                     } else {
  801.                         velocityAccuracy = new Vector3D(SP3Utils.siAccuracy(SP3Utils.VELOCITY_ACCURACY_UNIT,
  802.                                                                             header.getPosVelBase(),
  803.                                                                             Integer.parseInt(line.substring(61, 63).trim())),
  804.                                                         SP3Utils.siAccuracy(SP3Utils.VELOCITY_ACCURACY_UNIT,
  805.                                                                             header.getPosVelBase(),
  806.                                                                             Integer.parseInt(line.substring(64, 66).trim())),
  807.                                                         SP3Utils.siAccuracy(SP3Utils.VELOCITY_ACCURACY_UNIT,
  808.                                                                             header.getPosVelBase(),
  809.                                                                             Integer.parseInt(line.substring(67, 69).trim())));
  810.                     }

  812.                     final double clockRateAccuracy;
  813.                     if (line.length() < 73 || line.substring(70, 73).trim().length() == 0) {
  814.                         clockRateAccuracy = Double.NaN;
  815.                     } else {
  816.                         clockRateAccuracy = SP3Utils.siAccuracy(SP3Utils.CLOCK_RATE_ACCURACY_UNIT,
  817.                                                                 header.getClockBase(),
  818.                                                                 Integer.parseInt(line.substring(70, 73).trim()));
  819.                     }

  821.                     final SP3Coordinate coord =
  822.                             new SP3Coordinate(pi.latestEpoch,
  823.                                               pi.latestPosition,           pi.latestPositionAccuracy,
  824.                                               velocity,                    velocityAccuracy,
  825.                                               pi.latestClock,              pi.latestClockAccuracy,
  826.                                               clockRateChange,             clockRateAccuracy,
  827.                                               pi.latestClockEvent,         pi.latestClockPrediction,
  828.                                               pi.latestOrbitManeuverEvent, pi.latestOrbitPrediction);
  829.                     pi.file.getEphemeris(satelliteId).addCoordinate(coord, header.getEpochInterval());
  830.                 }
  831.             }

  833.             /** {@inheritDoc} */
  834.             @Override
  835.             public Iterable<LineParser> allowedNext() {
  836.                 return Arrays.asList(DATA_EPOCH, DATA_POSITION, DATA_VELOCITY_CORRELATION, EOF);
  837.             }

  839.         },

  841.         /** Parser for velocity correlation. */
  842.         DATA_VELOCITY_CORRELATION("^EV.*") {

  844.             /** {@inheritDoc} */
  845.             @Override
  846.             public void parse(final String line, final ParseInfo pi) {
  847.                 // ignored for now
  848.             }

  850.             /** {@inheritDoc} */
  851.             @Override
  852.             public Iterable<LineParser> allowedNext() {
  853.                 return Arrays.asList(DATA_EPOCH, DATA_POSITION, EOF);
  854.             }

  856.         },

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

  861.             /** {@inheritDoc} */
  862.             @Override
  863.             public void parse(final String line, final ParseInfo pi) {
  864.                 pi.done = true;
  865.             }

  867.             /** {@inheritDoc} */
  868.             @Override
  869.             public Iterable<LineParser> allowedNext() {
  870.                 return Collections.singleton(EOF);
  871.             }

  873.         };

  875.         /** Pattern for identifying line. */
  876.         private final Pattern pattern;

  878.         /** Simple constructor.
  879.          * @param lineRegexp regular expression for identifying line
  880.          */
  881.         LineParser(final String lineRegexp) {
  882.             pattern = Pattern.compile(lineRegexp);
  883.         }

  885.         /** Parse a line.
  886.          * @param line line to parse
  887.          * @param pi holder for transient data
  888.          */
  889.         public abstract void parse(String line, ParseInfo pi);

  891.         /** Get the allowed parsers for next line.
  892.          * @return allowed parsers for next line
  893.          */
  894.         public abstract Iterable<LineParser> allowedNext();

  896.         /** Check if parser can handle line.
  897.          * @param line line to parse
  898.          * @return true if parser can handle the specified line
  899.          */
  900.         public boolean canHandle(final String line) {
  901.             return pattern.matcher(line).matches();
  902.         }

  904.     }

  906. }
Created with JaCoCo 0.8.11.202310140853