SP3Writer.java

  1. /* Copyright 2023 Luc Maisonobe
  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.IOException;
  20. import java.util.Iterator;
  21. import java.util.List;
  22. import java.util.Locale;
  23. import java.util.Map;

  25. import org.hipparchus.util.FastMath;
  26. import org.orekit.time.AbsoluteDate;
  27. import org.orekit.time.DateTimeComponents;
  28. import org.orekit.time.TimeScale;
  29. import org.orekit.time.TimeScales;
  30. import org.orekit.utils.CartesianDerivativesFilter;

  32. /** Writer for SP3 file.
  33.  * @author Luc Maisonobe
  34.  * @since 12.0
  35.  */
  36. public class SP3Writer {

  38.     /** End Of Line. */
  39.     private static final String EOL = System.lineSeparator();

  41.     /** Prefix for accuracy lines. */
  42.     private static final String ACCURACY_LINE_PREFIX = "++       ";

  44.     /** Prefix for comment lines. */
  45.     private static final String COMMENT_LINE_PREFIX = "/* ";

  47.     /** Format for accuracy base lines. */
  48.     private static final String ACCURACY_BASE_FORMAT = "%%f %10.7f %12.9f %14.11f %18.15f%n";

  50.     /** Constant additional parameters lines. */
  51.     private static final String ADDITIONAL_PARAMETERS_LINE = "%i    0    0    0    0      0      0      0      0         0";

  53.     /** Format for one 2 digits integer field. */
  54.     private static final String TWO_DIGITS_INTEGER = "%2d";

  56.     /** Format for one 3 digits integer field. */
  57.     private static final String THREE_DIGITS_INTEGER = "%3d";

  59.     /** Format for one 14.6 digits float field. */
  60.     private static final String FOURTEEN_SIX_DIGITS_FLOAT = "%14.6f";

  62.     /** Format for three blanks field. */
  63.     private static final String THREE_BLANKS = "   ";

  65.     /** Time system default line. */
  66.     private static final String TIME_SYSTEM_DEFAULT = "%c cc cc ccc ccc cccc cccc cccc cccc ccccc ccccc ccccc ccccc";

  68.     /** Destination of generated output. */
  69.     private final Appendable output;

  71.     /** Output name for error messages. */
  72.     private final String outputName;

  74.     /** Set of time scales used for parsing dates. */
  75.     private final TimeScales timeScales;

  77.     /** Simple constructor.
  78.      * @param output destination of generated output
  79.      * @param outputName output name for error messages
  80.      * @param timeScales set of time scales used for parsing dates
  81.      */
  82.     public SP3Writer(final Appendable output, final String outputName, final TimeScales timeScales) {
  83.         this.output     = output;
  84.         this.outputName = outputName;
  85.         this.timeScales = timeScales;
  86.     }

  88.     /** Write a SP3 file.
  89.      * @param sp3 SP3 file to write
  90.      * @exception IOException if an I/O error occurs.
  91.      */
  92.     public void write(final SP3 sp3)
  93.         throws IOException {
  94.         sp3.validate(false, outputName);
  95.         writeHeader(sp3.getHeader());

  97.         // set up iterators for all satellites
  98.         final CoordinatesIterator[] iterators = new CoordinatesIterator[sp3.getSatelliteCount()];
  99.         int k = 0;
  100.         for (final Map.Entry<String, SP3Ephemeris> entry : sp3.getSatellites().entrySet()) {
  101.             iterators[k++] = new CoordinatesIterator(entry.getValue());
  102.         }

  104.         final TimeScale timeScale  = sp3.getHeader().getTimeSystem().getTimeScale(timeScales);
  105.         for (AbsoluteDate date = earliest(iterators); !date.equals(AbsoluteDate.FUTURE_INFINITY); date = earliest(iterators)) {

  107.             // epoch
  108.             final DateTimeComponents dtc = date.getComponents(timeScale);
  109.             output.append(String.format(Locale.US, "*  %4d %2d %2d %2d %2d %11.8f%n",
  110.                                         dtc.getDate().getYear(),
  111.                                         dtc.getDate().getMonth(),
  112.                                         dtc.getDate().getDay(),
  113.                                         dtc.getTime().getHour(),
  114.                                         dtc.getTime().getMinute(),
  115.                                         dtc.getTime().getSecond()));

  117.             for (final CoordinatesIterator iter : iterators) {

  119.                 final SP3Coordinate coordinate;
  120.                 if (iter.pending != null &&
  121.                     FastMath.abs(iter.pending.getDate().durationFrom(date)) <= 0.001 * sp3.getHeader().getEpochInterval()) {
  122.                     // the pending coordinate date matches current epoch
  123.                     coordinate = iter.pending;
  124.                     iter.advance();
  125.                 } else {
  126.                     // the pending coordinate  does not match current epoch
  127.                     coordinate = SP3Coordinate.DUMMY;
  128.                 }

  130.                 // position
  131.                 writePosition(sp3.getHeader(), iter.id, coordinate);

  133.                 if (sp3.getHeader().getFilter() != CartesianDerivativesFilter.USE_P) {
  134.                     // velocity
  135.                     writeVelocity(sp3.getHeader(), iter.id, coordinate);
  136.                 }

  138.             }

  140.         }

  142.         output.append("EOF").
  143.                append(EOL);

  145.     }

  147.     /** Find earliest date in ephemerides.
  148.      * @param iterators ephemerides iterators
  149.      * @return earliest date in iterators
  150.      */
  151.     private AbsoluteDate earliest(final CoordinatesIterator[] iterators) {
  152.         AbsoluteDate date = AbsoluteDate.FUTURE_INFINITY;
  153.         for (final CoordinatesIterator iter : iterators) {
  154.             if (iter.pending != null && iter.pending.getDate().isBefore(date)) {
  155.                 date = iter.pending.getDate();
  156.             }
  157.         }
  158.         return date;
  159.     }

  161.     /** Write position.
  162.      * @param header file header
  163.      * @param satId satellite id
  164.      * @param coordinate coordinate
  165.      * @exception IOException if an I/O error occurs.
  166.      */
  167.     private void writePosition(final SP3Header header, final String satId, final SP3Coordinate coordinate)
  168.         throws IOException {

  170.         final StringBuilder lineBuilder = new StringBuilder();

  172.         // position
  173.         lineBuilder.append(String.format(Locale.US, "P%3s%14.6f%14.6f%14.6f",
  174.                                          satId,
  175.                                          SP3Utils.POSITION_UNIT.fromSI(coordinate.getPosition().getX()),
  176.                                          SP3Utils.POSITION_UNIT.fromSI(coordinate.getPosition().getY()),
  177.                                          SP3Utils.POSITION_UNIT.fromSI(coordinate.getPosition().getZ())));

  179.         // clock
  180.         lineBuilder.append(String.format(Locale.US, FOURTEEN_SIX_DIGITS_FLOAT,
  181.                                          SP3Utils.CLOCK_UNIT.fromSI(coordinate.getClockCorrection())));

  183.         // position accuracy
  184.         if (coordinate.getPositionAccuracy() == null) {
  185.             lineBuilder.append(THREE_BLANKS).
  186.                         append(THREE_BLANKS).
  187.                         append(THREE_BLANKS);
  188.         } else {
  189.             lineBuilder.append(' ');
  190.             lineBuilder.append(String.format(Locale.US, TWO_DIGITS_INTEGER,
  191.                                              SP3Utils.indexAccuracy(SP3Utils.POSITION_ACCURACY_UNIT, header.getPosVelBase(),
  192.                                                                     coordinate.getPositionAccuracy().getX())));
  193.             lineBuilder.append(' ');
  194.             lineBuilder.append(String.format(Locale.US, TWO_DIGITS_INTEGER,
  195.                                              SP3Utils.indexAccuracy(SP3Utils.POSITION_ACCURACY_UNIT, header.getPosVelBase(),
  196.                                                                     coordinate.getPositionAccuracy().getY())));
  197.             lineBuilder.append(' ');
  198.             lineBuilder.append(String.format(Locale.US, TWO_DIGITS_INTEGER,
  199.                                              SP3Utils.indexAccuracy(SP3Utils.POSITION_ACCURACY_UNIT, header.getPosVelBase(),
  200.                                                                     coordinate.getPositionAccuracy().getZ())));
  201.         }

  203.         // clock accuracy
  204.         lineBuilder.append(' ');
  205.         if (Double.isNaN(coordinate.getClockAccuracy())) {
  206.             lineBuilder.append(THREE_BLANKS);
  207.         } else {
  208.             lineBuilder.append(String.format(Locale.US, THREE_DIGITS_INTEGER,
  209.                                              SP3Utils.indexAccuracy(SP3Utils.CLOCK_ACCURACY_UNIT, header.getClockBase(),
  210.                                                                     coordinate.getClockAccuracy())));
  211.         }

  213.         // events
  214.         lineBuilder.append(' ');
  215.         lineBuilder.append(coordinate.hasClockEvent()         ? 'E' : ' ');
  216.         lineBuilder.append(coordinate.hasClockPrediction()    ? 'P' : ' ');
  217.         lineBuilder.append(' ');
  218.         lineBuilder.append(' ');
  219.         lineBuilder.append(coordinate.hasOrbitManeuverEvent() ? 'M' : ' ');
  220.         lineBuilder.append(coordinate.hasOrbitPrediction()    ? 'P' : ' ');

  222.         output.append(lineBuilder.toString().trim()).append(EOL);

  224.     }

  226.     /** Write velocity.
  227.      * @param header file header
  228.      * @param satId satellite id
  229.      * @param coordinate coordinate
  230.      * @exception IOException if an I/O error occurs.
  231.      */
  232.     private void writeVelocity(final SP3Header header, final String satId, final SP3Coordinate coordinate)
  233.         throws IOException {

  235.         final StringBuilder lineBuilder = new StringBuilder();
  236.          // velocity
  237.         lineBuilder.append(String.format(Locale.US, "V%3s%14.6f%14.6f%14.6f",
  238.                                          satId,
  239.                                          SP3Utils.VELOCITY_UNIT.fromSI(coordinate.getVelocity().getX()),
  240.                                          SP3Utils.VELOCITY_UNIT.fromSI(coordinate.getVelocity().getY()),
  241.                                          SP3Utils.VELOCITY_UNIT.fromSI(coordinate.getVelocity().getZ())));

  243.         // clock rate
  244.         lineBuilder.append(String.format(Locale.US, FOURTEEN_SIX_DIGITS_FLOAT,
  245.                                          SP3Utils.CLOCK_RATE_UNIT.fromSI(coordinate.getClockRateChange())));

  247.         // velocity accuracy
  248.         if (coordinate.getVelocityAccuracy() == null) {
  249.             lineBuilder.append(THREE_BLANKS).
  250.                         append(THREE_BLANKS).
  251.                         append(THREE_BLANKS);
  252.         } else {
  253.             lineBuilder.append(' ');
  254.             lineBuilder.append(String.format(Locale.US, TWO_DIGITS_INTEGER,
  255.                                              SP3Utils.indexAccuracy(SP3Utils.VELOCITY_ACCURACY_UNIT, header.getPosVelBase(),
  256.                                                                     coordinate.getVelocityAccuracy().getX())));
  257.             lineBuilder.append(' ');
  258.             lineBuilder.append(String.format(Locale.US, TWO_DIGITS_INTEGER,
  259.                                              SP3Utils.indexAccuracy(SP3Utils.VELOCITY_ACCURACY_UNIT, header.getPosVelBase(),
  260.                                                                     coordinate.getVelocityAccuracy().getY())));
  261.             lineBuilder.append(' ');
  262.             lineBuilder.append(String.format(Locale.US, TWO_DIGITS_INTEGER,
  263.                                              SP3Utils.indexAccuracy(SP3Utils.VELOCITY_ACCURACY_UNIT, header.getPosVelBase(),
  264.                                                                     coordinate.getVelocityAccuracy().getZ())));
  265.         }

  267.         // clock rate accuracy
  268.         lineBuilder.append(' ');
  269.         if (Double.isNaN(coordinate.getClockRateAccuracy())) {
  270.             lineBuilder.append(THREE_BLANKS);
  271.         } else {
  272.             lineBuilder.append(String.format(Locale.US, THREE_DIGITS_INTEGER,
  273.                                              SP3Utils.indexAccuracy(SP3Utils.CLOCK_RATE_ACCURACY_UNIT, header.getClockBase(),
  274.                                                                     coordinate.getClockRateAccuracy())));
  275.         }

  277.         output.append(lineBuilder.toString().trim()).append(EOL);

  279.     }

  281.     /** Write header.
  282.      * @param header SP3 header to write
  283.      * @exception IOException if an I/O error occurs.
  284.      */
  285.     private void writeHeader(final SP3Header header)
  286.         throws IOException {
  287.         final TimeScale timeScale = header.getTimeSystem().getTimeScale(timeScales);
  288.         final DateTimeComponents dtc = header.getEpoch().getComponents(timeScale);
  289.         final StringBuilder dataUsedBuilder = new StringBuilder();
  290.         for (final DataUsed du : header.getDataUsed()) {
  291.             if (dataUsedBuilder.length() > 0) {
  292.                 dataUsedBuilder.append('+');
  293.             }
  294.             dataUsedBuilder.append(du.getKey());
  295.         }
  296.         final String dataUsed = dataUsedBuilder.length() <= 5 ?
  297.                                 dataUsedBuilder.toString() :
  298.                                 DataUsed.MIXED.getKey();

  300.         // header first line: version, epoch...
  301.         output.append(String.format(Locale.US, "#%c%c%4d %2d %2d %2d %2d %11.8f %7d %5s %5s %3s %4s%n",
  302.                                     header.getVersion(),
  303.                                     header.getFilter() == CartesianDerivativesFilter.USE_P ? 'P' : 'V',
  304.                                     dtc.getDate().getYear(),
  305.                                     dtc.getDate().getMonth(),
  306.                                     dtc.getDate().getDay(),
  307.                                     dtc.getTime().getHour(),
  308.                                     dtc.getTime().getMinute(),
  309.                                     dtc.getTime().getSecond(),
  310.                                     header.getNumberOfEpochs(),
  311.                                     dataUsed,
  312.                                     header.getCoordinateSystem(),
  313.                                     header.getOrbitTypeKey(),
  314.                                     header.getAgency()));

  316.         // header second line : dates
  317.         output.append(String.format(Locale.US, "## %4d %15.8f %14.8f %5d %15.13f%n",
  318.                                     header.getGpsWeek(),
  319.                                     header.getSecondsOfWeek(),
  320.                                     header.getEpochInterval(),
  321.                                     header.getModifiedJulianDay(),
  322.                                     header.getDayFraction()));

  324.         // list of satellites
  325.         final List<String> satellites = header.getSatIds();
  326.         output.append(String.format(Locale.US, "+  %3d   ", satellites.size()));
  327.         int lines  = 0;
  328.         int column = 9;
  329.         int remaining = satellites.size();
  330.         for (final String satId : satellites) {
  331.             output.append(String.format(Locale.US, "%3s", satId));
  332.             --remaining;
  333.             column += 3;
  334.             if (column >= 60) {
  335.                 // finish line
  336.                 output.append(EOL);
  337.                 ++lines;
  338.                 if (remaining > 0) {
  339.                     // start new line
  340.                     output.append("+        ");
  341.                     column = 9;
  342.                 }
  343.             }
  344.         }
  345.         while (column < 60) {
  346.             output.append(' ').
  347.                    append(' ').
  348.                    append('0');
  349.             column += 3;
  350.         }
  351.         output.append(EOL);
  352.         ++lines;
  353.         while (lines++ < 5) {
  354.             // write extra lines to have at least 85 satellites
  355.             output.append("+          0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0").
  356.                    append(EOL);
  357.         }

  359.         // general accuracy
  360.         output.append(ACCURACY_LINE_PREFIX);
  361.         lines  = 0;
  362.         column = 9;
  363.         remaining = satellites.size();
  364.         for (final String satId : satellites) {
  365.             final double accuracy    = header.getAccuracy(satId);
  366.             final int    accuracyExp = SP3Utils.indexAccuracy(SP3Utils.POSITION_ACCURACY_UNIT, SP3Utils.POS_VEL_BASE_ACCURACY, accuracy);
  367.             output.append(String.format(Locale.US, THREE_DIGITS_INTEGER, accuracyExp));
  368.             --remaining;
  369.             column += 3;
  370.             if (column >= 60) {
  371.                 // finish line
  372.                 output.append(EOL);
  373.                 ++lines;
  374.                 if (remaining > 0) {
  375.                     // start new line
  376.                     output.append(ACCURACY_LINE_PREFIX);
  377.                     column = 9;
  378.                 }
  379.             }
  380.         }
  381.         while (column < 60) {
  382.             output.append(' ').
  383.                    append(' ').
  384.                    append('0');
  385.             column += 3;
  386.         }
  387.         output.append(EOL);
  388.         ++lines;
  389.         while (lines++ < 5) {
  390.             // write extra lines to have at least 85 satellites
  391.             output.append("++         0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0").
  392.                    append(EOL);
  393.         }

  395.         // type
  396.         if (header.getVersion() == 'a') {
  397.             output.append(TIME_SYSTEM_DEFAULT).append(EOL);
  398.         } else {
  399.             output.append(String.format(Locale.US, "%%c %1s  cc %3s ccc cccc cccc cccc cccc ccccc ccccc ccccc ccccc%n",
  400.                                         header.getType().getKey(),
  401.                                         header.getTimeSystem().getKey()));
  402.         }
  403.         output.append(TIME_SYSTEM_DEFAULT).append(EOL);

  405.         // entries accuracy
  406.         output.append(String.format(Locale.US, ACCURACY_BASE_FORMAT,
  407.                                     header.getPosVelBase(), header.getClockBase(), 0.0, 0.0));
  408.         output.append(String.format(Locale.US, ACCURACY_BASE_FORMAT,
  409.                                     0.0, 0.0, 0.0, 0.0));

  411.         // additional parameters
  412.         output.append(ADDITIONAL_PARAMETERS_LINE).append(EOL);
  413.         output.append(ADDITIONAL_PARAMETERS_LINE).append(EOL);

  415.         // comments
  416.         int count = 0;
  417.         for (final String comment : header.getComments()) {
  418.             ++count;
  419.             output.append(COMMENT_LINE_PREFIX).append(comment).append(EOL);
  420.         }
  421.         while (count < 4) {
  422.             // add dummy comments to get at least the four comments specified for versions a, b and c
  423.             ++count;
  424.             output.append(COMMENT_LINE_PREFIX).append(EOL);
  425.         }

  427.     }

  429.     /** Iterator for coordinates. */
  430.     private static class CoordinatesIterator {

  432.         /** Satellite ID. */
  433.         private final String id;

  435.         /** Iterator over segments. */
  436.         private Iterator<SP3Segment> segmentsIterator;

  438.         /** Iterator over coordinates. */
  439.         private Iterator<SP3Coordinate> coordinatesIterator;

  441.         /** Pending coordinate. */
  442.         private SP3Coordinate pending;

  444.         /** Simple constructor.
  445.          * @param ephemeris underlying ephemeris
  446.          */
  447.         CoordinatesIterator(final SP3Ephemeris ephemeris) {
  448.             this.id                  = ephemeris.getId();
  449.             this.segmentsIterator    = ephemeris.getSegments().iterator();
  450.             this.coordinatesIterator = null;
  451.             advance();
  452.         }

  454.         /** Advance to next coordinates.
  455.          */
  456.         private void advance() {

  458.             while (coordinatesIterator == null || !coordinatesIterator.hasNext()) {
  459.                 // we have exhausted previous segment
  460.                 if (segmentsIterator != null && segmentsIterator.hasNext()) {
  461.                     coordinatesIterator = segmentsIterator.next().getCoordinates().iterator();
  462.                 } else {
  463.                     // we have exhausted the ephemeris
  464.                     segmentsIterator = null;
  465.                     pending          = null;
  466.                     return;
  467.                 }
  468.             }

  470.             // retrieve the next entry
  471.             pending = coordinatesIterator.next();

  473.         }

  475.     }

  477. }
Created with JaCoCo 0.8.11.202310140853