SP3File.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.util.ArrayList;
  20. import java.util.Collections;
  21. import java.util.LinkedHashMap;
  22. import java.util.List;
  23. import java.util.Map;
  24. import java.util.function.Function;

  26. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  27. import org.orekit.files.general.EphemerisFile;
  28. import org.orekit.frames.Frame;
  29. import org.orekit.propagation.BoundedPropagator;
  30. import org.orekit.time.AbsoluteDate;
  31. import org.orekit.time.TimeScale;
  32. import org.orekit.utils.CartesianDerivativesFilter;
  33. import org.orekit.utils.TimeStampedPVCoordinates;

  35. /**
  36.  * Represents a parsed SP3 orbit file.
  37.  * @author Thomas Neidhart
  38.  * @author Evan Ward
  39.  */
  40. public class SP3File implements EphemerisFile {
  41.     /** String representation of the center of ephemeris coordinate system. **/
  42.     public static final String SP3_FRAME_CENTER_STRING = "EARTH";

  44.     /** File type indicator. */
  45.     public enum SP3FileType {
  46.         /** GPS only file. */
  47.         GPS,
  48.         /** Mixed file. */
  49.         MIXED,
  50.         /** GLONASS only file. */
  51.         GLONASS,
  52.         /** LEO only file. */
  53.         LEO,
  54.         /** Galileo only file. */
  55.         GALILEO,
  56.         /** COMPASS only file. */
  57.         COMPASS,
  58.         /** QZSS only file. */
  59.         QZSS,
  60.         /** undefined file format. */
  61.         UNDEFINED
  62.     }

  64.     /** Orbit type indicator. */
  65.     public enum SP3OrbitType {
  66.         /** fitted. */
  67.         FIT,
  68.         /** extrapolated or predicted. */
  69.         EXT,
  70.         /** broadcast. */
  71.         BCT,
  72.         /** fitted after applying a Helmert transformation. */
  73.         HLM,
  74.         /** other type, defined by SP3 file producing agency.
  75.          * @since 9.3
  76.          */
  77.         OTHER;

  79.         /** Parse a string to get the type.
  80.          * @param s string to parse
  81.          * @return the type corresponding to the string
  82.          */
  83.         public static SP3OrbitType parseType(final String s) {
  84.             final String normalizedString = s.trim().toUpperCase();
  85.             if ("EST".equals(normalizedString)) {
  86.                 return FIT;
  87.             } else if ("BHN".equals(normalizedString)) {
  88.                 // ESOC navigation team uses BHN for files produced
  89.                 // by their main parameter estimation program Bahn
  90.                 return FIT;
  91.             } else if ("PRO".equals(normalizedString)) {
  92.                 // ESOC navigation team uses PRO for files produced
  93.                 // by their orbit propagation program Propag
  94.                 return EXT;
  95.             } else {
  96.                 try {
  97.                     return valueOf(normalizedString);
  98.                 } catch (IllegalArgumentException iae) {
  99.                     return OTHER;
  100.                 }
  101.             }
  102.         }

  104.     }

  106.     /** Time system used throughout this SP3 file. */
  107.     public enum TimeSystem {
  108.         /** Global Positioning System. */
  109.         GPS,
  110.         /** GLONASS. */
  111.         GLO,
  112.         /** GALILEO. */
  113.         GAL,
  114.         /** International Atomic Time. */
  115.         TAI,
  116.         /** Coordinated Universal Time. */
  117.         UTC,
  118.         /** Quasi-Zenith System. */
  119.         QZS
  120.     }

  122.     /** File type. */
  123.     private SP3FileType type;

  125.     /** Time system. */
  126.     private TimeSystem timeSystem;

  128.     /** Epoch of the file. */
  129.     private AbsoluteDate epoch;

  131.     /** GPS week. */
  132.     private int gpsWeek;

  134.     /** Seconds of the current GPS week. */
  135.     private double secondsOfWeek;

  137.     /** Julian day. */
  138.     private int julianDay;

  140.     /** Day fraction. */
  141.     private double dayFraction;

  143.     /** Time-interval between epochs. */
  144.     private double epochInterval;

  146.     /** Number of epochs. */
  147.     private int numberOfEpochs;

  149.     /** Coordinate system. */
  150.     private String coordinateSystem;

  152.     /** Data used indicator. */
  153.     private String dataUsed;

  155.     /** Orbit type. */
  156.     private SP3OrbitType orbitType;

  158.     /** Key for orbit type.
  159.      * @since 9.3
  160.      */
  161.     private String orbitTypeKey;

  163.     /** Agency providing the file. */
  164.     private String agency;

  166.     /** Indicates if data contains velocity or not. */
  167.     private CartesianDerivativesFilter filter;

  169.     /** Time scale of dates in the ephemeris file. */
  170.     private TimeScale timeScale;

  172.     /** Time scale, as specified in the file. */
  173.     private String timeScaleString;

  175.     /** Standard gravitational parameter in m^3 / s^2. */
  176.     private final double mu;

  178.     /** Number of samples to use when interpolating. */
  179.     private final int interpolationSamples;

  181.     /** Maps {@link #coordinateSystem} to a {@link Frame}. */
  182.     private final Function<? super String, ? extends Frame> frameBuilder;

  184.     /** A map containing satellite information. */
  185.     private Map<String, SP3Ephemeris> satellites;

  187.     /**
  188.      * Create a new SP3 file object.
  189.      *
  190.      * @param mu                   is the standard gravitational parameter in m^3 / s^2.
  191.      * @param interpolationSamples number of samples to use in interpolation.
  192.      * @param frameBuilder         for constructing a reference frame from the identifier
  193.      *                             in the file.
  194.      */
  195.     SP3File(final double mu,
  196.             final int interpolationSamples,
  197.             final Function<? super String, ? extends Frame> frameBuilder) {
  198.         this.mu = mu;
  199.         this.interpolationSamples = interpolationSamples;
  200.         this.frameBuilder = frameBuilder;
  201.         // must be linked has map to preserve order of satellites in the file.
  202.         satellites = new LinkedHashMap<>();
  203.     }

  205.     /**
  206.      * Set the derivatives filter.
  207.      *
  208.      * @param filter that indicates which derivatives of position are available.
  209.      */
  210.     void setFilter(final CartesianDerivativesFilter filter) {
  211.         this.filter = filter;
  212.     }

  214.     /**
  215.      * Set the time scale.
  216.      *
  217.      * @param timeScale use to parse dates in this file.
  218.      */
  219.     void setTimeScale(final TimeScale timeScale) {
  220.         this.timeScale = timeScale;
  221.     }

  223.     /**
  224.      * Set the string used to define the time scale.
  225.      *
  226.      * @param timeScaleString the time scale identifier used in the file.
  227.      */
  228.     void setTimeScaleString(final String timeScaleString) {
  229.         this.timeScaleString = timeScaleString;
  230.     }

  232.     /** Returns the {@link SP3FileType} associated with this SP3 file.
  233.      * @return the file type for this SP3 file
  234.      */
  235.     public SP3FileType getType() {
  236.         return type;
  237.     }

  239.     /** Set the file type for this SP3 file.
  240.      * @param fileType the file type to be set
  241.      */
  242.     void setType(final SP3FileType fileType) {
  243.         this.type = fileType;
  244.     }

  246.     /** Returns the {@link TimeSystem} used to time-stamp position entries.
  247.      * @return the {@link TimeSystem} of the orbit file
  248.      */
  249.     public TimeSystem getTimeSystem() {
  250.         return timeSystem;
  251.     }

  253.     /** Set the time system used in this SP3 file.
  254.      * @param system the time system to be set
  255.      */
  256.     void setTimeSystem(final TimeSystem system) {
  257.         this.timeSystem = system;
  258.     }

  260.     /** Returns the data used indicator from the SP3 file.
  261.      * @return the data used indicator (unparsed)
  262.      */
  263.     public String getDataUsed() {
  264.         return dataUsed;
  265.     }

  267.     /** Set the data used indicator for this SP3 file.
  268.      * @param data the data used indicator to be set
  269.      */
  270.     void setDataUsed(final String data) {
  271.         this.dataUsed = data;
  272.     }

  274.     /** Returns the start epoch of the orbit file.
  275.      * @return the start epoch
  276.      */
  277.     public AbsoluteDate getEpoch() {
  278.         return epoch;
  279.     }

  281.     /** Set the epoch of the SP3 file.
  282.      * @param time the epoch to be set
  283.      */
  284.     void setEpoch(final AbsoluteDate time) {
  285.         this.epoch = time;
  286.     }

  288.     /** Returns the GPS week as contained in the SP3 file.
  289.      * @return the GPS week of the SP3 file
  290.      */
  291.     public int getGpsWeek() {
  292.         return gpsWeek;
  293.     }

  295.     /** Set the GPS week of the SP3 file.
  296.      * @param week the GPS week to be set
  297.      */
  298.     void setGpsWeek(final int week) {
  299.         this.gpsWeek = week;
  300.     }

  302.     /** Returns the seconds of the GPS week as contained in the SP3 file.
  303.      * @return the seconds of the GPS week
  304.      */
  305.     public double getSecondsOfWeek() {
  306.         return secondsOfWeek;
  307.     }

  309.     /** Set the seconds of the GPS week for this SP3 file.
  310.      * @param seconds the seconds to be set
  311.      */
  312.     void setSecondsOfWeek(final double seconds) {
  313.         this.secondsOfWeek = seconds;
  314.     }

  316.     /** Returns the julian day for this SP3 file.
  317.      * @return the julian day
  318.      */
  319.     public int getJulianDay() {
  320.         return julianDay;
  321.     }

  323.     /** Set the julian day for this SP3 file.
  324.      * @param day the julian day to be set
  325.      */
  326.     void setJulianDay(final int day) {
  327.         this.julianDay = day;
  328.     }

  330.     /** Returns the day fraction for this SP3 file.
  331.      * @return the day fraction
  332.      */
  333.     public double getDayFraction() {
  334.         return dayFraction;
  335.     }

  337.     /** Set the day fraction for this SP3 file.
  338.      * @param fraction the day fraction to be set
  339.      */
  340.     void setDayFraction(final double fraction) {
  341.         this.dayFraction = fraction;
  342.     }

  344.     /** Returns the time interval between epochs (in seconds).
  345.      * @return the time interval between epochs
  346.      */
  347.     public double getEpochInterval() {
  348.         return epochInterval;
  349.     }

  351.     /** Set the epoch interval for this SP3 file.
  352.      * @param interval the interval between orbit entries
  353.      */
  354.     void setEpochInterval(final double interval) {
  355.         this.epochInterval = interval;
  356.     }

  358.     /** Returns the number of epochs contained in this orbit file.
  359.      * @return the number of epochs
  360.      */
  361.     public int getNumberOfEpochs() {
  362.         return numberOfEpochs;
  363.     }

  365.     /** Set the number of epochs as contained in the SP3 file.
  366.      * @param epochCount the number of epochs to be set
  367.      */
  368.     void setNumberOfEpochs(final int epochCount) {
  369.         this.numberOfEpochs = epochCount;
  370.     }

  372.     /** Returns the coordinate system of the entries in this orbit file.
  373.      * @return the coordinate system
  374.      */
  375.     public String getCoordinateSystem() {
  376.         return coordinateSystem;
  377.     }

  379.     /** Set the coordinate system used for the orbit entries.
  380.      * @param system the coordinate system to be set
  381.      */
  382.     void setCoordinateSystem(final String system) {
  383.         this.coordinateSystem = system;
  384.     }

  386.     /** Returns the {@link SP3OrbitType} for this SP3 file.
  387.      * @return the orbit type
  388.      */
  389.     public SP3OrbitType getOrbitType() {
  390.         return orbitType;
  391.     }

  393.     /** Set the {@link SP3OrbitType} for this SP3 file.
  394.      * @param oType the orbit type to be set
  395.      * @deprecated as of 9.4, replaced by {@link #setOrbitTypeKey(String)}
  396.      */
  397.     void setOrbitType(final SP3OrbitType oType) {
  398.         this.orbitType = oType;
  399.     }

  401.     /** Returns the orbit type key for this SP3 file.
  402.      * @return the orbit type key
  403.      * @since 9.3
  404.      */
  405.     public String getOrbitTypeKey() {
  406.         return orbitTypeKey;
  407.     }

  409.     /** Set the orbit type key for this SP3 file.
  410.      * @param oTypeKey the orbit type key to be set
  411.      * @since 9.3
  412.      */
  413.     void setOrbitTypeKey(final String oTypeKey) {
  414.         this.orbitTypeKey = oTypeKey;
  415.         this.orbitType    = SP3OrbitType.parseType(oTypeKey);
  416.     }

  418.     /** Returns the agency that prepared this SP3 file.
  419.      * @return the agency
  420.      */
  421.     public String getAgency() {
  422.         return agency;
  423.     }

  425.     /** Set the agency string for this SP3 file.
  426.      * @param agencyStr the agency string to be set
  427.      */
  428.     void setAgency(final String agencyStr) {
  429.         this.agency = agencyStr;
  430.     }

  432.     /** Add a new satellite with a given identifier to the list of
  433.      * stored satellites.
  434.      * @param satId the satellite identifier
  435.      */
  436.     public void addSatellite(final String satId) {
  437.         // only add satellites which have not been added before
  438.         satellites.putIfAbsent(satId, new SP3Ephemeris(satId));
  439.     }

  441.     @Override
  442.     public Map<String, SP3Ephemeris> getSatellites() {
  443.         return Collections.unmodifiableMap(satellites);
  444.     }

  446.     /** Get the number of satellites contained in this orbit file.
  447.      * @return the number of satellites
  448.      */
  449.     public int getSatelliteCount() {
  450.         return satellites.size();
  451.     }

  453.     /**
  454.      * Set the formal accuracy for a satellite.
  455.      *
  456.      * @param index    is the index of the satellite.
  457.      * @param accuracy of the satellite, in m.
  458.      */
  459.     void setAccuracy(final int index, final double accuracy) {
  460.         int n = index;
  461.         for (final SP3Ephemeris ephemeris : satellites.values()) {
  462.             if (n == 0) {
  463.                 ephemeris.setAccuracy(accuracy);
  464.                 return;
  465.             }
  466.             n--;
  467.         }
  468.     }

  470.     /**
  471.      * Get the formal accuracy for a satellite.
  472.      *
  473.      * @param index    is the index of the satellite.
  474.      * @return accuracy of the satellite, in m.
  475.      */
  476.     double getAccuracy(final int index) {
  477.         int n = index;
  478.         for (final SP3Ephemeris ephemeris : satellites.values()) {
  479.             if (n == 0) {
  480.                 return ephemeris.getAccuracy();
  481.             }
  482.             n--;
  483.         }
  484.         return Double.NaN;
  485.     }

  487.     /** Tests whether a satellite with the given id is contained in this orbit
  488.      * file.
  489.      * @param satId the satellite id
  490.      * @return {@code true} if the satellite is contained in the file,
  491.      *         {@code false} otherwise
  492.      */
  493.     public boolean containsSatellite(final String satId) {
  494.         return satellites.containsKey(satId);
  495.     }

  497.     /**
  498.      * Adds a new P/V coordinate for a given satellite.
  499.      *
  500.      * @param satId the satellite identifier
  501.      * @param coord the P/V coordinate of the satellite
  502.      */
  503.     void addSatelliteCoordinate(final String satId, final SP3Coordinate coord) {
  504.         satellites.get(satId).coordinates.add(coord);
  505.     }

  507.     /** An ephemeris for a single satellite in a SP3 file. */
  508.     public class SP3Ephemeris implements SatelliteEphemeris, EphemerisSegment {

  510.         /** Satellite ID. */
  511.         private final String id;
  512.         /** Ephemeris Data. */
  513.         private final List<SP3Coordinate> coordinates;
  514.         /** Accuracy in m. */
  515.         private double accuracy;

  517.         /**
  518.          * Create an ephemeris for a single satellite.
  519.          *
  520.          * @param id of the satellite.
  521.          */
  522.         SP3Ephemeris(final String id) {
  523.             this.id = id;
  524.             this.coordinates = new ArrayList<>();
  525.         }

  527.         @Override
  528.         public String getId() {
  529.             return this.id;
  530.         }

  532.         @Override
  533.         public double getMu() {
  534.             return mu;
  535.         }

  537.         @Override
  538.         public String getFrameCenterString() {
  539.             return SP3_FRAME_CENTER_STRING;
  540.         }

  542.         @Override
  543.         public String getFrameString() {
  544.             return getCoordinateSystem();
  545.         }

  547.         @Override
  548.         public Frame getFrame() {
  549.             return frameBuilder.apply(getFrameString());
  550.         }

  552.         @Override
  553.         public String getTimeScaleString() {
  554.             return timeScaleString;
  555.         }

  557.         @Override
  558.         public TimeScale getTimeScale() {
  559.             return timeScale;
  560.         }

  562.         @Override
  563.         public int getInterpolationSamples() {
  564.             return interpolationSamples;
  565.         }

  567.         @Override
  568.         public CartesianDerivativesFilter getAvailableDerivatives() {
  569.             return filter;
  570.         }

  572.         @Override
  573.         public List<SP3Coordinate> getCoordinates() {
  574.             return Collections.unmodifiableList(this.coordinates);
  575.         }

  577.         /** Returns a list containing only {@code this}. */
  578.         @Override
  579.         public List<SP3Ephemeris> getSegments() {
  580.             return Collections.singletonList(this);
  581.         }

  583.         @Override
  584.         public AbsoluteDate getStart() {
  585.             return coordinates.get(0).getDate();
  586.         }

  588.         @Override
  589.         public AbsoluteDate getStop() {
  590.             return coordinates.get(coordinates.size() - 1).getDate();
  591.         }

  593.         @Override
  594.         public BoundedPropagator getPropagator() {
  595.             return EphemerisSegment.super.getPropagator();
  596.         }

  598.         /**
  599.          * Set the accuracy for this satellite.
  600.          *
  601.          * @param accuracy in m.
  602.          */
  603.         void setAccuracy(final double accuracy) {
  604.             this.accuracy = accuracy;
  605.         }

  607.         /**
  608.          * Get the formal accuracy for this satellite.
  609.          *
  610.          * <p>The accuracy is limited by the SP3 standard to be a power of 2 in mm.
  611.          * The value returned here is in meters.</p>
  612.          *
  613.          * @return magnitude of one standard deviation, in m.
  614.          */
  615.         public double getAccuracy() {
  616.             return accuracy;
  617.         }

  619.     }

  621.     /** A single record of position clock and possibly derivatives in an SP3 file. */
  622.     public static class SP3Coordinate extends TimeStampedPVCoordinates {

  624.         /** Serializable UID. */
  625.         private static final long serialVersionUID = 20161116L;
  626.         /** Clock correction in s. */
  627.         private final double clock;
  628.         /** Clock rate in s / s. */
  629.         private final double clockRate;

  631.         /**
  632.          * Create a coordinate with only position.
  633.          *
  634.          * @param date     of validity.
  635.          * @param position of the satellite.
  636.          * @param clock    correction in s.
  637.          */
  638.         SP3Coordinate(final AbsoluteDate date,
  639.                       final Vector3D position,
  640.                       final double clock) {
  641.             this(date, position, Vector3D.ZERO, clock, 0);
  642.         }

  644.         /**
  645.          * Create a coordinate with position and velocity.
  646.          *
  647.          * @param date      of validity.
  648.          * @param position  of the satellite.
  649.          * @param velocity  of the satellite.
  650.          * @param clock     correction in s.
  651.          * @param clockRate in s / s.
  652.          */
  653.         SP3Coordinate(final AbsoluteDate date,
  654.                       final Vector3D position,
  655.                       final Vector3D velocity,
  656.                       final double clock,
  657.                       final double clockRate) {
  658.             super(date, position, velocity, Vector3D.ZERO);
  659.             this.clock = clock;
  660.             this.clockRate = clockRate;
  661.         }

  663.         /**
  664.          * Returns the clock correction value.
  665.          *
  666.          * @return the clock correction in s.
  667.          */
  668.         public double getClockCorrection() {
  669.             return clock;
  670.         }

  672.         /**
  673.          * Returns the clock rate.
  674.          *
  675.          * @return the clock rate of change in s/s.
  676.          */
  677.         public double getClockRateChange() {
  678.             return clockRate;
  679.         }

  681.     }

  683. }
Created with JaCoCo 0.8.2.201808211720