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.FileInputStream;
  21. import java.io.FileNotFoundException;
  22. import java.io.IOException;
  23. import java.io.InputStream;
  24. import java.io.InputStreamReader;
  25. import java.util.Locale;
  26. import java.util.Scanner;

  28. import org.apache.commons.math3.exception.util.DummyLocalizable;
  29. import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.errors.OrekitMessages;
  32. import org.orekit.files.general.OrbitFileParser;
  33. import org.orekit.files.general.SatelliteInformation;
  34. import org.orekit.files.general.SatelliteTimeCoordinate;
  35. import org.orekit.files.general.OrbitFile.TimeSystem;
  36. import org.orekit.files.sp3.SP3File.SP3FileType;
  37. import org.orekit.files.sp3.SP3File.SP3OrbitType;
  38. import org.orekit.time.AbsoluteDate;
  39. import org.orekit.time.TimeScale;
  40. import org.orekit.time.TimeScalesFactory;
  41. import org.orekit.utils.PVCoordinates;

  43. /** A parser for the SP3 orbit file format. It supports the original format as
  44.  * well as the latest SP3-c version.
  45.  * <p>
  46.  * <b>Note:</b> this parser is thread-safe, so calling {@link #parse} from
  47.  * different threads is allowed.
  48.  * </p>
  49.  * @see <a href="http://igscb.jpl.nasa.gov/igscb/data/format/sp3_docu.txt">SP3-a file format</a>
  50.  * @see <a href="http://igscb.jpl.nasa.gov/igscb/data/format/sp3c.txt">SP3-c file format</a>
  51.  * @author Thomas Neidhart
  52.  */
  53. public class SP3Parser implements OrbitFileParser {

  55.     /** {@inheritDoc} */
  56.     public SP3File parse(final String fileName) throws OrekitException {

  58.         InputStream stream = null;

  60.         try {
  61.             stream = new FileInputStream(fileName);
  62.             return parse(stream);
  63.         } catch (FileNotFoundException e) {
  64.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  65.         } finally {
  66.             try {
  67.                 if (stream != null) {
  68.                     stream.close();
  69.                 }
  70.             } catch (IOException e) {
  71.                 // ignore
  72.             }
  73.         }
  74.     }

  76.     /** {@inheritDoc} */
  77.     public SP3File parse(final InputStream stream) throws OrekitException {
  78.         try {
  79.             return parseInternal(stream);
  80.         } catch (IOException e) {
  81.             throw new OrekitException(e, new DummyLocalizable(e.getMessage()));
  82.         }
  83.     }

  85.     /** Parses the SP3 file from the given {@link InputStream} and
  86.      * returns a {@link SP3File} object.
  87.      * @param stream the stream to read the SP3File from
  88.      * @return the parsed {@link SP3File} object
  89.      * @throws OrekitException if the file could not be parsed successfully
  90.      * @throws IOException if an error occurs while reading from the stream
  91.      */
  92.     private SP3File parseInternal(final InputStream stream)
  93.         throws OrekitException, IOException {

  95.         final BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"));

  97.         // initialize internal data structures
  98.         final ParseInfo pi = new ParseInfo();

  100.         String line = null;
  101.         int lineNumber = 1;
  102.         try {
  103.             while (lineNumber < 23) {
  104.                 line = reader.readLine();
  105.                 if (line == null) {
  106.                     throw new OrekitException(OrekitMessages.SP3_UNEXPECTED_END_OF_FILE, lineNumber - 1);
  107.                 } else {
  108.                     parseHeaderLine(lineNumber++, line, pi);
  109.                 }
  110.             }

  112.             // now handle the epoch/position/velocity entries

  114.             boolean done = false;
  115.             do {
  116.                 line = reader.readLine();
  117.                 if (line != null) {
  118.                     if ("EOF".equalsIgnoreCase(line)) {
  119.                         done = true;
  120.                     } else if (line.length() > 0) {
  121.                         parseContentLine(line, pi);
  122.                     }
  123.                 }
  124.             } while (!done);
  125.         } finally {
  126.             try {
  127.                 reader.close();
  128.             } catch (IOException e1) {
  129.                 // ignore
  130.             }
  131.         }

  133.         return pi.file;
  134.     }

  136.     /** Parses a header line from the SP3 file (line number 1 - 22).
  137.      * @param lineNumber the current line number
  138.      * @param line the line as read from the SP3 file
  139.      * @param pi the current {@link ParseInfo} object
  140.      * @throws OrekitException if a non-supported construct is found
  141.      */
  142.     private void parseHeaderLine(final int lineNumber, final String line, final ParseInfo pi)
  143.         throws OrekitException {

  145.         final SP3File file = pi.file;
  146.         @SuppressWarnings("resource") // we scan a String which is not closeable
  147.         final Scanner scanner = new Scanner(line).useDelimiter("\\s+").useLocale(Locale.US);

  149.         // CHECKSTYLE: stop FallThrough check

  151.         switch (lineNumber) {
  152.         // version, epoch, data used and agency information
  153.         case 1: {
  154.             scanner.skip("#");
  155.             final String v = scanner.next();

  157.             final char version = v.substring(0, 1).toLowerCase().charAt(0);
  158.             if (version != 'a' && version != 'b' && version != 'c') {
  159.                 throw new OrekitException(OrekitMessages.SP3_UNSUPPORTED_VERSION, version);
  160.             }

  162.             pi.hasVelocityEntries = "V".equals(v.substring(1, 2));

  164.             final int year = Integer.valueOf(v.substring(2));
  165.             final int month = scanner.nextInt();
  166.             final int day = scanner.nextInt();
  167.             final int hour = scanner.nextInt();
  168.             final int minute = scanner.nextInt();
  169.             final double second = scanner.nextDouble();

  171.             final AbsoluteDate epoch = new AbsoluteDate(year, month, day,
  172.                                                         hour, minute, second,
  173.                                                         TimeScalesFactory.getGPS());

  175.             file.setEpoch(epoch);

  177.             final int numEpochs = scanner.nextInt();
  178.             file.setNumberOfEpochs(numEpochs);

  180.             // data used indicator
  181.             file.setDataUsed(scanner.next());

  183.             file.setCoordinateSystem(scanner.next());
  184.             file.setOrbitType(SP3OrbitType.valueOf(scanner.next()));
  185.             file.setAgency(scanner.next());
  186.         }
  187.             break;

  189.         // additional date/time references in gps/julian day notation
  190.         case 2: {
  191.             scanner.skip("##");

  193.             // gps week
  194.             file.setGpsWeek(scanner.nextInt());
  195.             // seconds of week
  196.             file.setSecondsOfWeek(scanner.nextDouble());
  197.             // epoch interval
  198.             file.setEpochInterval(scanner.nextDouble());
  199.             // julian day
  200.             file.setJulianDay(scanner.nextInt());
  201.             // day fraction
  202.             file.setDayFraction(scanner.nextDouble());
  203.         }
  204.             break;

  206.         // line 3 contains the number of satellites
  207.         case 3:
  208.             pi.maxSatellites = Integer.valueOf(line.substring(4, 6).trim());
  209.             // fall-through intended - the line contains already the first entries

  211.             // the following 4 lines contain additional satellite ids
  212.         case 4:
  213.         case 5:
  214.         case 6:
  215.         case 7: {
  216.             final int lineLength = line.length();
  217.             int count = file.getSatelliteCount();
  218.             int startIdx = 9;
  219.             while (count++ < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  220.                 final String satId = line.substring(startIdx, startIdx + 3).trim();
  221.                 file.addSatellite(satId);
  222.                 startIdx += 3;
  223.             }
  224.         }
  225.             break;

  227.         // the following 5 lines contain general accuracy information for each satellite
  228.         case 8:
  229.         case 9:
  230.         case 10:
  231.         case 11:
  232.         case 12: {
  233.             final int lineLength = line.length();
  234.             int satIdx = (lineNumber - 8) * 17;
  235.             int startIdx = 9;
  236.             while (satIdx < pi.maxSatellites && (startIdx + 3) <= lineLength) {
  237.                 final SatelliteInformation satInfo = file.getSatellite(satIdx++);
  238.                 final int exponent = Integer.valueOf(line.substring(startIdx, startIdx + 3).trim());
  239.                 // the accuracy is calculated as 2**exp (in m) -> can be safely
  240.                 // converted to an integer as there will be no fraction
  241.                 satInfo.setAccuracy((int) Math.pow(2d, exponent));
  242.                 startIdx += 3;
  243.             }
  244.         }
  245.             break;

  247.         case 13: {
  248.             file.setType(getFileType(line.substring(3, 5).trim()));

  250.             // now identify the time system in use
  251.             final String tsStr = line.substring(9, 12).trim();
  252.             final TimeSystem ts = TimeSystem.GPS;
  253.             if (!tsStr.equalsIgnoreCase("ccc")) {
  254.                 TimeSystem.valueOf(tsStr);
  255.             }
  256.             file.setTimeSystem(ts);

  258.             switch (ts) {
  259.             case GPS:
  260.                 pi.timeScale = TimeScalesFactory.getGPS();
  261.                 break;

  263.             case GAL:
  264.                 pi.timeScale = TimeScalesFactory.getGST();
  265.                 break;

  267.             case GLO:
  268.             case QZS:
  269.                 throw new OrekitException(OrekitMessages.SP3_UNSUPPORTED_TIMESYSTEM, ts.name());

  271.             case TAI:
  272.                 pi.timeScale = TimeScalesFactory.getTAI();
  273.                 break;

  275.             case UTC:
  276.                 pi.timeScale = TimeScalesFactory.getUTC();
  277.                 break;

  279.             default:
  280.                 pi.timeScale = TimeScalesFactory.getGPS();
  281.                 break;
  282.             }
  283.         }
  284.             break;

  286.         case 14:
  287.             // ignore additional custom fields
  288.             break;

  290.         // load base numbers for the standard deviations of
  291.         // position/velocity/clock components
  292.         case 15: {
  293.             // String base = line.substring(3, 13).trim();
  294.             // if (!base.equals("0.0000000")) {
  295.             //    // (mm or 10**-4 mm/sec)
  296.             //    pi.posVelBase = Double.valueOf(base);
  297.             // }

  299.             // base = line.substring(14, 26).trim();
  300.             // if (!base.equals("0.000000000")) {
  301.             //    // (psec or 10**-4 psec/sec)
  302.             //    pi.clockBase = Double.valueOf(base);
  303.             // }
  304.         }
  305.             break;

  307.         case 16:
  308.         case 17:
  309.         case 18:
  310.             // ignore additional custom parameters
  311.             break;

  313.         case 19:
  314.         case 20:
  315.         case 21:
  316.         case 22:
  317.             // ignore comment lines
  318.             break;
  319.         default:
  320.             // ignore -> method should only be called up to line 22
  321.             break;
  322.         }

  324.         // CHECKSTYLE: resume FallThrough check

  326.     }

  328.     /** Parses a single content line as read from the SP3 file.
  329.      * @param line a string containing the line
  330.      * @param pi the current {@link ParseInfo} object
  331.      */
  332.     private void parseContentLine(final String line, final ParseInfo pi) {
  333.         // EP and EV lines are ignored so far

  335.         final SP3File file = pi.file;

  337.         switch (line.charAt(0)) {
  338.         case '*': {
  339.             final int year = Integer.valueOf(line.substring(3, 7).trim());
  340.             final int month = Integer.valueOf(line.substring(8, 10).trim());
  341.             final int day = Integer.valueOf(line.substring(11, 13).trim());
  342.             final int hour = Integer.valueOf(line.substring(14, 16).trim());
  343.             final int minute = Integer.valueOf(line.substring(17, 19).trim());
  344.             final double second = Double.valueOf(line.substring(20, 31).trim());

  346.             pi.latestEpoch = new AbsoluteDate(year, month, day,
  347.                                               hour, minute, second,
  348.                                               pi.timeScale);
  349.         }
  350.             break;

  352.         case 'P': {
  353.             final String satelliteId = line.substring(1, 4).trim();

  355.             if (!file.containsSatellite(satelliteId)) {
  356.                 pi.latestPosition = null;
  357.             } else {
  358.                 final double x = Double.valueOf(line.substring(4, 18).trim());
  359.                 final double y = Double.valueOf(line.substring(18, 32).trim());
  360.                 final double z = Double.valueOf(line.substring(32, 46).trim());

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

  365.                 // clock (microsec)
  366.                 pi.latestClock = Double.valueOf(line.substring(46, 60).trim());

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

  370.                 // if (line.length() >= 73) {
  371.                 // // x-sdev (b**n mm)
  372.                 // int xStdDevExp = Integer.valueOf(line.substring(61,
  373.                 // 63).trim());
  374.                 // // y-sdev (b**n mm)
  375.                 // int yStdDevExp = Integer.valueOf(line.substring(64,
  376.                 // 66).trim());
  377.                 // // z-sdev (b**n mm)
  378.                 // int zStdDevExp = Integer.valueOf(line.substring(67,
  379.                 // 69).trim());
  380.                 // // c-sdev (b**n psec)
  381.                 // int cStdDevExp = Integer.valueOf(line.substring(70,
  382.                 // 73).trim());
  383.                 //
  384.                 // pi.posStdDevRecord =
  385.                 // new PositionStdDevRecord(Math.pow(pi.posVelBase, xStdDevExp),
  386.                 // Math.pow(pi.posVelBase,
  387.                 // yStdDevExp), Math.pow(pi.posVelBase, zStdDevExp),
  388.                 // Math.pow(pi.clockBase, cStdDevExp));
  389.                 //
  390.                 // String clockEventFlag = line.substring(74, 75);
  391.                 // String clockPredFlag = line.substring(75, 76);
  392.                 // String maneuverFlag = line.substring(78, 79);
  393.                 // String orbitPredFlag = line.substring(79, 80);
  394.                 // }

  396.                 if (!pi.hasVelocityEntries) {
  397.                     final SatelliteTimeCoordinate coord =
  398.                         new SatelliteTimeCoordinate(pi.latestEpoch,
  399.                                                     pi.latestPosition,
  400.                                                     pi.latestClock);
  401.                     file.addSatelliteCoordinate(satelliteId, coord);
  402.                 }
  403.             }
  404.         }
  405.             break;

  407.         case 'V': {
  408.             final String satelliteId = line.substring(1, 4).trim();

  410.             if (file.containsSatellite(satelliteId)) {
  411.                 final double xv = Double.valueOf(line.substring(4, 18).trim());
  412.                 final double yv = Double.valueOf(line.substring(18, 32).trim());
  413.                 final double zv = Double.valueOf(line.substring(32, 46).trim());

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

  418.                 final double clockRateChange = Double.valueOf(line.substring(46, 60).trim());

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

  422.                 // if (line.length() >= 73) {
  423.                 // // xvel-sdev (b**n 10**-4 mm/sec)
  424.                 // int xVstdDevExp = Integer.valueOf(line.substring(61,
  425.                 // 63).trim());
  426.                 // // yvel-sdev (b**n 10**-4 mm/sec)
  427.                 // int yVstdDevExp = Integer.valueOf(line.substring(64,
  428.                 // 66).trim());
  429.                 // // zvel-sdev (b**n 10**-4 mm/sec)
  430.                 // int zVstdDevExp = Integer.valueOf(line.substring(67,
  431.                 // 69).trim());
  432.                 // // clkrate-sdev (b**n 10**-4 psec/sec)
  433.                 // int clkStdDevExp = Integer.valueOf(line.substring(70,
  434.                 // 73).trim());
  435.                 // }

  437.                 final SatelliteTimeCoordinate coord =
  438.                     new SatelliteTimeCoordinate(pi.latestEpoch,
  439.                                                 new PVCoordinates(pi.latestPosition, velocity),
  440.                                                 pi.latestClock,
  441.                                                 clockRateChange);
  442.                 file.addSatelliteCoordinate(satelliteId, coord);
  443.             }
  444.         }
  445.             break;

  447.         default:
  448.             // ignore everything else
  449.             break;
  450.         }
  451.     }

  453.     /** Returns the {@link SP3FileType} that corresponds to a given string in a SP3 file.
  454.      * @param fileType file type as string
  455.      * @return file type as enum
  456.      */
  457.     private SP3FileType getFileType(final String fileType) {
  458.         SP3FileType type = SP3FileType.UNDEFINED;
  459.         if ("G".equalsIgnoreCase(fileType)) {
  460.             type = SP3FileType.GPS;
  461.         } else if ("M".equalsIgnoreCase(fileType)) {
  462.             type = SP3FileType.MIXED;
  463.         } else if ("R".equalsIgnoreCase(fileType)) {
  464.             type = SP3FileType.GLONASS;
  465.         } else if ("L".equalsIgnoreCase(fileType)) {
  466.             type = SP3FileType.LEO;
  467.         } else if ("E".equalsIgnoreCase(fileType)) {
  468.             type = SP3FileType.GALILEO;
  469.         } else if ("C".equalsIgnoreCase(fileType)) {
  470.             type = SP3FileType.COMPASS;
  471.         } else if ("J".equalsIgnoreCase(fileType)) {
  472.             type = SP3FileType.QZSS;
  473.         }
  474.         return type;
  475.     }

  477.     /** Transient data used for parsing a sp3 file. The data is kept in a
  478.      * separate data structure to make the parser thread-safe.
  479.      * <p><b>Note</b>: The class intentionally does not provide accessor
  480.      * methods, as it is only used internally for parsing a SP3 file.</p>
  481.      */
  482.     private static class ParseInfo {

  484.         /** The corresponding SP3File object. */
  485.         private SP3File file;

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

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

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

  496.         /** Indicates if the SP3 file has velocity entries. */
  497.         private boolean hasVelocityEntries;

  499.         /** The timescale used in the SP3 file. */
  500.         private TimeScale timeScale;

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

  505.         /** The base for pos/vel. */
  506.         //private double posVelBase;

  508.         /** The base for clock/rate. */
  509.         //private double clockBase;

  511.         /** Create a new {@link ParseInfo} object. */
  512.         protected ParseInfo() {
  513.             file = new SP3File();
  514.             latestEpoch = null;
  515.             latestPosition = null;
  516.             latestClock = 0.0d;
  517.             hasVelocityEntries = false;
  518.             timeScale = TimeScalesFactory.getGPS();
  519.             maxSatellites = 0;
  520.             //posVelBase = 2d;
  521.             //clockBase = 2d;
  522.         }
  523.     }
  524. }
Created with JaCoCo 0.6.3.201306030806