RinexObservationWriter.java

  1. /* Copyright 2022-2025 Thales Alenia Space
  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.rinex.observation;

  19. import java.io.IOException;
  20. import java.util.ArrayList;
  21. import java.util.Collections;
  22. import java.util.List;
  23. import java.util.Map;
  24. import java.util.function.BiFunction;

  26. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  27. import org.hipparchus.util.FastMath;
  28. import org.orekit.annotation.DefaultDataContext;
  29. import org.orekit.data.DataContext;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.errors.OrekitMessages;
  32. import org.orekit.files.rinex.AppliedDCBS;
  33. import org.orekit.files.rinex.AppliedPCVS;
  34. import org.orekit.files.rinex.section.RinexComment;
  35. import org.orekit.files.rinex.section.RinexLabels;
  36. import org.orekit.gnss.ObservationTimeScale;
  37. import org.orekit.gnss.ObservationType;
  38. import org.orekit.gnss.PredefinedObservationType;
  39. import org.orekit.gnss.SatInSystem;
  40. import org.orekit.gnss.SatelliteSystem;
  41. import org.orekit.time.AbsoluteDate;
  42. import org.orekit.time.ClockModel;
  43. import org.orekit.time.ClockTimeScale;
  44. import org.orekit.time.DateTimeComponents;
  45. import org.orekit.time.TimeScale;
  46. import org.orekit.time.TimeScales;
  47. import org.orekit.utils.formatting.FastDoubleFormatter;
  48. import org.orekit.utils.formatting.FastLongFormatter;

  50. /** Writer for Rinex observation file.
  51.  * <p>
  52.  * As RINEX file are organized in batches of observations at some dates,
  53.  * these observations are cached and a new batch is output only when
  54.  * a new date appears when calling {@link #writeObservationDataSet(ObservationDataSet)}
  55.  * or when the file is closed by calling the {@link #close() close} method.
  56.  * Failing to call {@link #close() close} would imply the last batch
  57.  * of measurements is not written. This is the reason why this class implements
  58.  * {@link AutoCloseable}, so the {@link #close() close} method can be called automatically in
  59.  * a {@code try-with-resources} statement.
  60.  * </p>
  61.  * @author Luc Maisonobe
  62.  * @since 12.0
  63.  */
  64. public class RinexObservationWriter implements AutoCloseable {

  66.     /** Index of label in header lines. */
  67.     private static final int LABEL_INDEX = 60;

  69.     /** Format for one 1 digit integer field. */
  70.     private static final FastLongFormatter ONE_DIGIT_INTEGER = new FastLongFormatter(1, false);

  72.     /** Format for one 2 digits integer field. */
  73.     private static final FastLongFormatter PADDED_TWO_DIGITS_INTEGER = new FastLongFormatter(2, true);

  75.     /** Format for one 2 digits integer field. */
  76.     private static final FastLongFormatter TWO_DIGITS_INTEGER = new FastLongFormatter(2, false);

  78.     /** Format for one 4 digits integer field. */
  79.     private static final FastLongFormatter PADDED_FOUR_DIGITS_INTEGER = new FastLongFormatter(4, true);

  81.     /** Format for one 3 digits integer field. */
  82.     private static final FastLongFormatter THREE_DIGITS_INTEGER = new FastLongFormatter(3, false);

  84.     /** Format for one 4 digits integer field. */
  85.     private static final FastLongFormatter FOUR_DIGITS_INTEGER = new FastLongFormatter(4, false);

  87.     /** Format for one 6 digits integer field. */
  88.     private static final FastLongFormatter SIX_DIGITS_INTEGER = new FastLongFormatter(6, false);

  90.     /** Format for one 8.3 digits float field. */
  91.     private static final FastDoubleFormatter EIGHT_THREE_DIGITS_FLOAT = new FastDoubleFormatter(8, 3);

  93.     /** Format for one 8.5 digits float field. */
  94.     private static final FastDoubleFormatter EIGHT_FIVE_DIGITS_FLOAT = new FastDoubleFormatter(8, 5);

  96.     /** Format for one 9.2 digits float field. */
  97.     private static final FastDoubleFormatter NINE_TWO_DIGITS_FLOAT = new FastDoubleFormatter(9, 2);

  99.     /** Format for one 9.4 digits float field. */
  100.     private static final FastDoubleFormatter NINE_FOUR_DIGITS_FLOAT = new FastDoubleFormatter(9, 4);

  102.     /** Format for one 10.3 digits float field. */
  103.     private static final FastDoubleFormatter TEN_THREE_DIGITS_FLOAT = new FastDoubleFormatter(10, 3);

  105.     /** Format for one 11.7 digits float field. */
  106.     private static final FastDoubleFormatter ELEVEN_SEVEN_DIGITS_FLOAT = new FastDoubleFormatter(11, 7);

  108.     /** Format for one 12.9 digits float field. */
  109.     private static final FastDoubleFormatter TWELVE_NINE_DIGITS_FLOAT = new FastDoubleFormatter(12, 9);

  111.     /** Format for one 13.7 digits float field. */
  112.     private static final FastDoubleFormatter THIRTEEN_SEVEN_DIGITS_FLOAT = new FastDoubleFormatter(13, 7);

  114.     /** Format for one 14.3 digits float field. */
  115.     private static final FastDoubleFormatter FOURTEEN_THREE_DIGITS_FLOAT = new FastDoubleFormatter(14, 3);

  117.     /** Format for one 14.4 digits float field. */
  118.     private static final FastDoubleFormatter FOURTEEN_FOUR_DIGITS_FLOAT = new FastDoubleFormatter(14, 4);

  120.     /** Format for one 15.12 digits float field. */
  121.     private static final FastDoubleFormatter FIFTEEN_TWELVE_DIGITS_FLOAT = new FastDoubleFormatter(15, 12);

  123.     /** Threshold for considering measurements are at the sate time.
  124.      * (we know the RINEX files encode dates with a resolution of 0.1µs)
  125.      */
  126.     private static final double EPS_DATE = 1.0e-8;

  128.     /** Destination of generated output. */
  129.     private final Appendable output;

  131.     /** Output name for error messages. */
  132.     private final String outputName;

  134.     /** Receiver clock offset model. */
  135.     private ClockModel receiverClockModel;

  137.     /** Time scale for writing dates. */
  138.     private TimeScale timeScale;

  140.     /** Saved header. */
  141.     private RinexObservationHeader savedHeader;

  143.     /** Saved comments. */
  144.     private List<RinexComment> savedComments;

  146.     /** Pending observations. */
  147.     private final List<ObservationDataSet> pending;

  149.     /** Line number. */
  150.     private int lineNumber;

  152.     /** Column number. */
  153.     private int column;

  155.     /** Set of time scales.
  156.      * @since 13.0
  157.      */
  158.     private final TimeScales timeScales;

  160.     /** Mapper from satellite system to time scales.
  161.      * @since 13.0
  162.      */
  163.     private final BiFunction<SatelliteSystem, TimeScales, ? extends TimeScale> timeScaleBuilder;

  165.     /** Simple constructor.
  166.      * <p>
  167.      * This constructor uses the {@link DataContext#getDefault() default data context}
  168.      * and recognizes only {@link PredefinedObservationType} and {@link SatelliteSystem}
  169.      * with non-null {@link SatelliteSystem#getObservationTimeScale() time scales}
  170.      * (i.e. neither user-defined, nor {@link SatelliteSystem#SBAS}, nor {@link SatelliteSystem#MIXED}).
  171.      * </p>
  172.      * @param output destination of generated output
  173.      * @param outputName output name for error messages
  174.      */
  175.     @DefaultDataContext
  176.     public RinexObservationWriter(final Appendable output, final String outputName) {
  177.         this(output, outputName,
  178.              (system, ts) -> system.getObservationTimeScale() == null ?
  179.                              null :
  180.                              system.getObservationTimeScale().getTimeScale(ts),
  181.              DataContext.getDefault().getTimeScales());
  182.     }

  184.     /** Simple constructor.
  185.      * @param output destination of generated output
  186.      * @param outputName output name for error messages
  187.      * @param timeScaleBuilder mapper from satellite system to time scales (useful for user-defined satellite systems)
  188.      * @param timeScales the set of time scales to use when parsing dates
  189.      * @since 13.0
  190.      */
  191.     public RinexObservationWriter(final Appendable output, final String outputName,
  192.                                   final BiFunction<SatelliteSystem, TimeScales, ? extends TimeScale> timeScaleBuilder,
  193.                                   final TimeScales timeScales) {
  194.         this.output           = output;
  195.         this.outputName       = outputName;
  196.         this.savedHeader      = null;
  197.         this.savedComments    = Collections.emptyList();
  198.         this.pending          = new ArrayList<>();
  199.         this.lineNumber       = 0;
  200.         this.column           = 0;
  201.         this.timeScaleBuilder = timeScaleBuilder;
  202.         this.timeScales       = timeScales;
  203.     }

  205.     /** {@inheritDoc} */
  206.     @Override
  207.     public void close() throws IOException {
  208.         processPending();
  209.     }

  211.     /** Set receiver clock model.
  212.      * @param receiverClockModel receiver clock model
  213.      * @since 12.1
  214.      */
  215.     public void setReceiverClockModel(final ClockModel receiverClockModel) {
  216.         this.receiverClockModel = receiverClockModel;
  217.     }

  219.     /** Write a complete observation file.
  220.      * <p>
  221.      * This method calls {@link #prepareComments(List)} and
  222.      * {@link #writeHeader(RinexObservationHeader)} once and then loops on
  223.      * calling {@link #writeObservationDataSet(ObservationDataSet)}
  224.      * for all observation data sets in the file
  225.      * </p>
  226.      * @param rinexObservation Rinex observation file to write
  227.      * @see #writeHeader(RinexObservationHeader)
  228.      * @see #writeObservationDataSet(ObservationDataSet)
  229.      * @exception IOException if an I/O error occurs.
  230.      */
  231.     @DefaultDataContext
  232.     public void writeCompleteFile(final RinexObservation rinexObservation)
  233.         throws IOException {
  234.         prepareComments(rinexObservation.getComments());
  235.         writeHeader(rinexObservation.getHeader());
  236.         for (final ObservationDataSet observationDataSet : rinexObservation.getObservationDataSets()) {
  237.             writeObservationDataSet(observationDataSet);
  238.         }
  239.     }

  241.     /** Prepare comments to be emitted at specified lines.
  242.      * @param comments comments to be emitted
  243.      */
  244.     public void prepareComments(final List<RinexComment> comments) {
  245.         savedComments = comments;
  246.     }

  248.     /** Write header.
  249.      * <p>
  250.      * This method must be called exactly once at the beginning
  251.      * (directly or by {@link #writeCompleteFile(RinexObservation)})
  252.      * </p>
  253.      * @param header header to write
  254.      * @exception IOException if an I/O error occurs.
  255.      */
  256.     @DefaultDataContext
  257.     public void writeHeader(final RinexObservationHeader header)
  258.         throws IOException {

  260.         // check header is written exactly once
  261.         if (savedHeader != null) {
  262.             throw new OrekitException(OrekitMessages.HEADER_ALREADY_WRITTEN, outputName);
  263.         }
  264.         savedHeader = header;
  265.         lineNumber  = 1;

  267.         final String timeScaleName;
  268.         if (timeScaleBuilder.apply(header.getSatelliteSystem(), timeScales) != null) {
  269.             timeScale     = timeScaleBuilder.apply(header.getSatelliteSystem(), timeScales);
  270.             timeScaleName = "   ";
  271.         } else {
  272.             timeScale     = ObservationTimeScale.GPS.getTimeScale(timeScales);
  273.             timeScaleName = timeScale.getName();
  274.         }
  275.         if (!header.getClockOffsetApplied() && receiverClockModel != null) {
  276.             // getClockOffsetApplied returned false, which means the measurements
  277.             // should *NOT* be put in system time scale, and the receiver has a clock model
  278.             // we have to set up a time scale corresponding to this receiver clock
  279.             // (but we keep the name set earlier despite it is not really relevant anymore)
  280.             timeScale = new ClockTimeScale(timeScale.getName(), timeScale, receiverClockModel);
  281.         }

  283.         // RINEX VERSION / TYPE
  284.         outputField(NINE_TWO_DIGITS_FLOAT, header.getFormatVersion(), 9);
  285.         outputField("",                 20, true);
  286.         outputField("OBSERVATION DATA", 40, true);
  287.         outputField(header.getSatelliteSystem().getKey(), 41);
  288.         finishHeaderLine(RinexLabels.VERSION);

  290.         // PGM / RUN BY / DATE
  291.         outputField(header.getProgramName(), 20, true);
  292.         outputField(header.getRunByName(),   40, true);
  293.         final DateTimeComponents dtc = header.getCreationDateComponents();
  294.         if (header.getFormatVersion() < 3.0 && dtc.getTime().getSecond() < 0.5) {
  295.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getDay(), 42);
  296.             outputField('-', 43);
  297.             outputField(dtc.getDate().getMonthEnum().getUpperCaseAbbreviation(), 46,  true);
  298.             outputField('-', 47);
  299.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getYear() % 100, 49);
  300.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getHour(), 52);
  301.             outputField(':', 53);
  302.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getMinute(), 55);
  303.             outputField(header.getCreationTimeZone(), 58, true);
  304.         } else {
  305.             outputField(PADDED_FOUR_DIGITS_INTEGER, dtc.getDate().getYear(), 44);
  306.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getMonth(), 46);
  307.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getDay(), 48);
  308.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getHour(), 51);
  309.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getMinute(), 53);
  310.             outputField(PADDED_TWO_DIGITS_INTEGER, (int) FastMath.rint(dtc.getTime().getSecond()), 55);
  311.             outputField(header.getCreationTimeZone(), 59, false);
  312.         }
  313.         finishHeaderLine(RinexLabels.PROGRAM);

  315.         // MARKER NAME
  316.         outputField(header.getMarkerName(), 60, true);
  317.         finishHeaderLine(RinexLabels.MARKER_NAME);

  319.         // MARKER NUMBER
  320.         if (header.getMarkerNumber() != null) {
  321.             outputField(header.getMarkerNumber(), 20, true);
  322.             finishHeaderLine(RinexLabels.MARKER_NUMBER);
  323.         }

  325.         // MARKER TYPE
  326.         if (header.getFormatVersion() >= 2.20) {
  327.             outputField(header.getMarkerType(), 20, true);
  328.             finishHeaderLine(RinexLabels.MARKER_TYPE);
  329.         }

  331.         // OBSERVER / AGENCY
  332.         outputField(header.getObserverName(), 20, true);
  333.         outputField(header.getAgencyName(),   60, true);
  334.         finishHeaderLine(RinexLabels.OBSERVER_AGENCY);

  336.         // REC # / TYPE / VERS
  337.         outputField(header.getReceiverNumber(),  20, true);
  338.         outputField(header.getReceiverType(),    40, true);
  339.         outputField(header.getReceiverVersion(), 60, true);
  340.         finishHeaderLine(RinexLabels.REC_NB_TYPE_VERS);

  342.         // ANT # / TYPE
  343.         outputField(header.getAntennaNumber(), 20, true);
  344.         outputField(header.getAntennaType(),   40, true);
  345.         finishHeaderLine(RinexLabels.ANT_NB_TYPE);

  347.         // APPROX POSITION XYZ
  348.         writeHeaderLine(header.getApproxPos(), RinexLabels.APPROX_POSITION_XYZ);

  350.         // ANTENNA: DELTA H/E/N
  351.         if (!Double.isNaN(header.getAntennaHeight())) {
  352.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getAntennaHeight(),         14);
  353.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getEccentricities().getX(), 28);
  354.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getEccentricities().getY(), 42);
  355.             finishHeaderLine(RinexLabels.ANTENNA_DELTA_H_E_N);
  356.         }

  358.         // ANTENNA: DELTA X/Y/Z
  359.         writeHeaderLine(header.getAntennaReferencePoint(), RinexLabels.ANTENNA_DELTA_X_Y_Z);

  361.         // ANTENNA: PHASECENTER
  362.         if (header.getAntennaPhaseCenter() != null) {
  363.             outputField(header.getPhaseCenterSystem().getKey(), 1);
  364.             outputField("", 2, true);
  365.             outputField(header.getObservationCode(), 5, true);
  366.             outputField(NINE_FOUR_DIGITS_FLOAT,     header.getAntennaPhaseCenter().getX(), 14);
  367.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getAntennaPhaseCenter().getY(), 28);
  368.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getAntennaPhaseCenter().getZ(), 42);
  369.             finishHeaderLine(RinexLabels.ANTENNA_PHASE_CENTER);
  370.         }

  372.         // ANTENNA: B.SIGHT XY
  373.         writeHeaderLine(header.getAntennaBSight(), RinexLabels.ANTENNA_B_SIGHT_XYZ);

  375.         // ANTENNA: ZERODIR AZI
  376.         if (!Double.isNaN(header.getAntennaAzimuth())) {
  377.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, FastMath.toDegrees(header.getAntennaAzimuth()), 14);
  378.             finishHeaderLine(RinexLabels.ANTENNA_ZERODIR_AZI);
  379.         }

  381.         // ANTENNA: ZERODIR XYZ
  382.         writeHeaderLine(header.getAntennaZeroDirection(), RinexLabels.ANTENNA_ZERODIR_XYZ);

  384.         // OBS SCALE FACTOR
  385.         if (FastMath.abs(header.getFormatVersion() - 2.20) < 0.001) {
  386.             for (final SatelliteSystem system : SatelliteSystem.values()) {
  387.                 for (final ScaleFactorCorrection sfc : header.getScaleFactorCorrections(system)) {
  388.                     if (sfc != null) {
  389.                         outputField(SIX_DIGITS_INTEGER, (int) FastMath.round(sfc.getCorrection()), 6);
  390.                         outputField(SIX_DIGITS_INTEGER, sfc.getTypesObsScaled().size(), 12);
  391.                         for (int i = 0; i < sfc.getTypesObsScaled().size(); ++i) {
  392.                             outputField(sfc.getTypesObsScaled().get(i).getName(), 18 + 6 * i, false);
  393.                         }
  394.                         finishHeaderLine(RinexLabels.OBS_SCALE_FACTOR);
  395.                     }
  396.                 }
  397.             }
  398.         }

  400.         // CENTER OF MASS: XYZ
  401.         writeHeaderLine(header.getCenterMass(), RinexLabels.CENTER_OF_MASS_XYZ);

  403.         // DOI
  404.         writeHeaderLine(header.getDoi(), RinexLabels.DOI);

  406.         // LICENSE OF USE
  407.         writeHeaderLine(header.getLicense(), RinexLabels.LICENSE);

  409.         // STATION INFORMATION
  410.         writeHeaderLine(header.getStationInformation(), RinexLabels.STATION_INFORMATION);

  412.         // SYS / # / OBS TYPES
  413.         for (Map.Entry<SatelliteSystem, List<ObservationType>> entry : header.getTypeObs().entrySet()) {
  414.             if (header.getFormatVersion() < 3.0) {
  415.                 outputField(SIX_DIGITS_INTEGER, entry.getValue().size(), 6);
  416.             } else {
  417.                 outputField(entry.getKey().getKey(), 1);
  418.                 outputField(THREE_DIGITS_INTEGER, entry.getValue().size(), 6);
  419.             }
  420.             for (final ObservationType observationType : entry.getValue()) {
  421.                 int next = column + (header.getFormatVersion() < 3.0 ? 6 : 4);
  422.                 if (next > LABEL_INDEX) {
  423.                     // we need to set up a continuation line
  424.                     finishHeaderLine(header.getFormatVersion() < 3.0 ?
  425.                                      RinexLabels.NB_TYPES_OF_OBSERV :
  426.                                      RinexLabels.SYS_NB_TYPES_OF_OBSERV);
  427.                     outputField("", 6, true);
  428.                     next = column + (header.getFormatVersion() < 3.0 ? 6 : 4);
  429.                 }
  430.                 outputField(observationType.getName(), next, false);
  431.             }
  432.             finishHeaderLine(header.getFormatVersion() < 3.0 ?
  433.                              RinexLabels.NB_TYPES_OF_OBSERV :
  434.                              RinexLabels.SYS_NB_TYPES_OF_OBSERV);
  435.         }

  437.         // SIGNAL STRENGTH UNIT
  438.         writeHeaderLine(header.getSignalStrengthUnit(), RinexLabels.SIGNAL_STRENGTH_UNIT);

  440.         // INTERVAL
  441.         if (!Double.isNaN(header.getInterval())) {
  442.             outputField(TEN_THREE_DIGITS_FLOAT, header.getInterval(), 10);
  443.             finishHeaderLine(RinexLabels.INTERVAL);
  444.         }

  446.         // TIME OF FIRST OBS
  447.         final DateTimeComponents dtcFirst = header.getTFirstObs().getComponents(timeScale).roundIfNeeded(60, 7);
  448.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getDate().getYear(), 6);
  449.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getDate().getMonth(), 12);
  450.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getDate().getDay(), 18);
  451.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getTime().getHour(), 24);
  452.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getTime().getMinute(), 30);
  453.         outputField(THIRTEEN_SEVEN_DIGITS_FLOAT, dtcFirst.getTime().getSecond(), 43);
  454.         outputField(timeScaleName, 51, false);
  455.         finishHeaderLine(RinexLabels.TIME_OF_FIRST_OBS);

  457.         // TIME OF LAST OBS
  458.         if (!header.getTLastObs().equals(AbsoluteDate.FUTURE_INFINITY)) {
  459.             final DateTimeComponents dtcLast = header.getTLastObs().getComponents(timeScale).roundIfNeeded(60, 7);
  460.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getDate().getYear(), 6);
  461.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getDate().getMonth(), 12);
  462.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getDate().getDay(), 18);
  463.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getTime().getHour(), 24);
  464.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getTime().getMinute(), 30);
  465.             outputField(THIRTEEN_SEVEN_DIGITS_FLOAT, dtcLast.getTime().getSecond(), 43);
  466.             outputField(timeScaleName, 51, false);
  467.             finishHeaderLine(RinexLabels.TIME_OF_LAST_OBS);
  468.         }

  470.         // RCV CLOCK OFFS APPL
  471.         outputField(SIX_DIGITS_INTEGER, header.getClockOffsetApplied() ? 1 : 0, 6);
  472.         finishHeaderLine(RinexLabels.RCV_CLOCK_OFFS_APPL);

  474.         // SYS / DCBS APPLIED
  475.         for (final AppliedDCBS appliedDCBS : header.getListAppliedDCBS()) {
  476.             outputField(appliedDCBS.getSatelliteSystem().getKey(),  1);
  477.             outputField("",                                         2, true);
  478.             outputField(appliedDCBS.getProgDCBS(),                 20, true);
  479.             outputField(appliedDCBS.getSourceDCBS(),               60, true);
  480.             finishHeaderLine(RinexLabels.SYS_DCBS_APPLIED);
  481.         }

  483.         // SYS / PCVS APPLIED
  484.         for (final AppliedPCVS appliedPCVS : header.getListAppliedPCVS()) {
  485.             outputField(appliedPCVS.getSatelliteSystem().getKey(),  1);
  486.             outputField("",                                         2, true);
  487.             outputField(appliedPCVS.getProgPCVS(),                 20, true);
  488.             outputField(appliedPCVS.getSourcePCVS(),               60, true);
  489.             finishHeaderLine(RinexLabels.SYS_PCVS_APPLIED);
  490.         }

  492.         // SYS / SCALE FACTOR
  493.         if (header.getFormatVersion() >= 3.0) {
  494.             for (final SatelliteSystem system : SatelliteSystem.values()) {
  495.                 for (final ScaleFactorCorrection sfc : header.getScaleFactorCorrections(system)) {
  496.                     if (sfc != null) {
  497.                         outputField(system.getKey(), 1);
  498.                         outputField("", 2, true);
  499.                         outputField(FOUR_DIGITS_INTEGER, (int) FastMath.rint(sfc.getCorrection()), 6);
  500.                         if (sfc.getTypesObsScaled().size() < header.getTypeObs().get(system).size()) {
  501.                             outputField("", 8, true);
  502.                             outputField(TWO_DIGITS_INTEGER,  sfc.getTypesObsScaled().size(), 10);
  503.                             for (ObservationType observationType : sfc.getTypesObsScaled()) {
  504.                                 int next = column + 4;
  505.                                 if (next > LABEL_INDEX) {
  506.                                     // we need to set up a continuation line
  507.                                     finishHeaderLine(RinexLabels.SYS_SCALE_FACTOR);
  508.                                     outputField("", 10, true);
  509.                                     next = column + 4;
  510.                                 }
  511.                                 outputField("", next - 3, true);
  512.                                 outputField(observationType.getName(), next, true);
  513.                             }
  514.                         }
  515.                         finishHeaderLine(RinexLabels.SYS_SCALE_FACTOR);
  516.                     }
  517.                 }
  518.             }
  519.         }

  521.         // SYS / PHASE SHIFT
  522.         for (final PhaseShiftCorrection psc : header.getPhaseShiftCorrections()) {
  523.             outputField(psc.getSatelliteSystem().getKey(), 1);
  524.             outputField(psc.getTypeObs().getName(), 5, false);
  525.             outputField(EIGHT_FIVE_DIGITS_FLOAT, psc.getCorrection(), 14);
  526.             if (!psc.getSatsCorrected().isEmpty()) {
  527.                 outputField(TWO_DIGITS_INTEGER, psc.getSatsCorrected().size(), 18);
  528.                 for (final SatInSystem sis : psc.getSatsCorrected()) {
  529.                     int next = column + 4;
  530.                     if (next > LABEL_INDEX) {
  531.                         // we need to set up a continuation line
  532.                         finishHeaderLine(RinexLabels.SYS_PHASE_SHIFT);
  533.                         outputField("", 18, true);
  534.                         next = column + 4;
  535.                     }
  536.                     outputField(sis.toString(), next, false);
  537.                 }
  538.             }
  539.             finishHeaderLine(RinexLabels.SYS_PHASE_SHIFT);
  540.         }

  542.         if (header.getFormatVersion() >= 3.01) {
  543.             if (!header.getGlonassChannels().isEmpty()) {
  544.                 // GLONASS SLOT / FRQ #
  545.                 outputField(THREE_DIGITS_INTEGER, header.getGlonassChannels().size(), 3);
  546.                 outputField("", 4, true);
  547.                 for (final GlonassSatelliteChannel channel : header.getGlonassChannels()) {
  548.                     int next = column + 7;
  549.                     if (next > LABEL_INDEX) {
  550.                         // we need to set up a continuation line
  551.                         finishHeaderLine(RinexLabels.GLONASS_SLOT_FRQ_NB);
  552.                         outputField("", 4, true);
  553.                         next = column + 7;
  554.                     }
  555.                     outputField(channel.getSatellite().getSystem().getKey(), next - 6);
  556.                     outputField(PADDED_TWO_DIGITS_INTEGER, channel.getSatellite().getPRN(), next - 4);
  557.                     outputField(TWO_DIGITS_INTEGER, channel.getK(), next - 1);
  558.                     outputField("", next, true);
  559.                 }
  560.             }
  561.             finishHeaderLine(RinexLabels.GLONASS_SLOT_FRQ_NB);
  562.         }

  564.         if (header.getFormatVersion() >= 3.0) {
  565.             // GLONASS COD/PHS/BIS
  566.             if (Double.isNaN(header.getC1cCodePhaseBias())) {
  567.                 outputField("", 13, true);
  568.             } else {
  569.                 outputField(PredefinedObservationType.C1C.getName(), 4, false);
  570.                 outputField("", 5, true);
  571.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC1cCodePhaseBias(), 13);
  572.             }
  573.             if (Double.isNaN(header.getC1pCodePhaseBias())) {
  574.                 outputField("", 26, true);
  575.             } else {
  576.                 outputField(PredefinedObservationType.C1P.getName(), 17, false);
  577.                 outputField("", 18, true);
  578.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC1pCodePhaseBias(), 26);
  579.             }
  580.             if (Double.isNaN(header.getC2cCodePhaseBias())) {
  581.                 outputField("", 39, true);
  582.             } else {
  583.                 outputField(PredefinedObservationType.C2C.getName(), 30, false);
  584.                 outputField("", 31, true);
  585.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC2cCodePhaseBias(), 39);
  586.             }
  587.             if (Double.isNaN(header.getC2pCodePhaseBias())) {
  588.                 outputField("", 52, true);
  589.             } else {
  590.                 outputField(PredefinedObservationType.C2P.getName(), 43, false);
  591.                 outputField("", 44, true);
  592.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC2pCodePhaseBias(), 52);
  593.             }
  594.             finishHeaderLine(RinexLabels.GLONASS_COD_PHS_BIS);
  595.         }

  597.         // LEAP SECONDS
  598.         if (header.getLeapSeconds() > 0) {
  599.             outputField(SIX_DIGITS_INTEGER, header.getLeapSeconds(), 6);
  600.             if (header.getFormatVersion() >= 3.0) {
  601.                 outputField(SIX_DIGITS_INTEGER, header.getLeapSecondsFuture(),  12);
  602.                 outputField(SIX_DIGITS_INTEGER, header.getLeapSecondsWeekNum(), 18);
  603.                 outputField(SIX_DIGITS_INTEGER, header.getLeapSecondsDayNum(),  24);
  604.             }
  605.             finishHeaderLine(RinexLabels.LEAP_SECONDS);
  606.         }

  608.         // # OF SATELLITES
  609.         if (header.getNbSat() >= 0) {
  610.             outputField(SIX_DIGITS_INTEGER, header.getNbSat(), 6);
  611.             finishHeaderLine(RinexLabels.NB_OF_SATELLITES);
  612.         }

  614.         // PRN / # OF OBS
  615.         for (final Map.Entry<SatInSystem, Map<ObservationType, Integer>> entry1 : header.getNbObsPerSat().entrySet()) {
  616.             final SatInSystem sis = entry1.getKey();
  617.             outputField(sis.toString(), 6, false);
  618.             for (final Map.Entry<ObservationType, Integer> entry2 : entry1.getValue().entrySet()) {
  619.                 int next = column + 6;
  620.                 if (next > LABEL_INDEX) {
  621.                     // we need to set up a continuation line
  622.                     finishHeaderLine(RinexLabels.PRN_NB_OF_OBS);
  623.                     outputField("", 6, true);
  624.                     next = column + 6;
  625.                 }
  626.                 outputField(SIX_DIGITS_INTEGER, entry2.getValue(), next);
  627.             }
  628.             finishHeaderLine(RinexLabels.PRN_NB_OF_OBS);
  629.         }

  631.         // END OF HEADER
  632.         writeHeaderLine("", RinexLabels.END);

  634.     }

  636.     /** Write one observation data set.
  637.      * <p>
  638.      * Note that this writers output only regular observations, so
  639.      * the event flag is always set to 0
  640.      * </p>
  641.      * @param observationDataSet observation data set to write
  642.      * @exception IOException if an I/O error occurs.
  643.      */
  644.     public void writeObservationDataSet(final ObservationDataSet observationDataSet)
  645.         throws IOException {

  647.         // check header has already been written
  648.         if (savedHeader == null) {
  649.             throw new OrekitException(OrekitMessages.HEADER_NOT_WRITTEN, outputName);
  650.         }

  652.         if (!pending.isEmpty() && observationDataSet.durationFrom(pending.get(0).getDate()) > EPS_DATE) {
  653.             // the specified observation belongs to the next batch
  654.             // we must process the current batch of pending observations
  655.             processPending();
  656.         }

  658.         // add the observation to the pending list, so it is written later on
  659.         pending.add(observationDataSet);

  661.     }

  663.     /** Process all pending measurements.
  664.      * @exception IOException if an I/O error occurs.
  665.      */
  666.     private void processPending() throws IOException {

  668.         if (!pending.isEmpty()) {

  670.             // write the batch of pending observations
  671.             if (savedHeader.getFormatVersion() < 3.0) {
  672.                 writePendingRinex2Observations();
  673.             } else {
  674.                 writePendingRinex34Observations();
  675.             }

  677.             // prepare for next batch
  678.             pending.clear();

  680.         }

  682.     }

  684.     /** Write one observation data set in RINEX 2 format.
  685.      * @exception IOException if an I/O error occurs.
  686.      */
  687.     public void writePendingRinex2Observations() throws IOException {

  689.         final ObservationDataSet first = pending.get(0);

  691.         // EPOCH/SAT
  692.         final DateTimeComponents dtc = first.getDate().getComponents(timeScale).roundIfNeeded(60, 7);
  693.         outputField("",  1, true);
  694.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getDate().getYear() % 100,    3);
  695.         outputField("",  4, true);
  696.         outputField(TWO_DIGITS_INTEGER,          dtc.getDate().getMonth(),         6);
  697.         outputField("",  7, true);
  698.         outputField(TWO_DIGITS_INTEGER,          dtc.getDate().getDay(),           9);
  699.         outputField("", 10, true);
  700.         outputField(TWO_DIGITS_INTEGER,          dtc.getTime().getHour(),         12);
  701.         outputField("", 13, true);
  702.         outputField(TWO_DIGITS_INTEGER,          dtc.getTime().getMinute(),       15);
  703.         outputField(ELEVEN_SEVEN_DIGITS_FLOAT,   dtc.getTime().getSecond(),       26);

  705.         // event flag
  706.         outputField("", 28, true);
  707.         if (first.getEventFlag() == 0) {
  708.             outputField("", 29, true);
  709.         } else {
  710.             outputField(ONE_DIGIT_INTEGER, first.getEventFlag(), 29);
  711.         }

  713.         // list of satellites and receiver clock offset
  714.         outputField(THREE_DIGITS_INTEGER, pending.size(), 32);
  715.         boolean offsetWritten = false;
  716.         final double  clockOffset   = first.getRcvrClkOffset();
  717.         for (final ObservationDataSet ods : pending) {
  718.             int next = column + 3;
  719.             if (next > 68) {
  720.                 // we need to set up a continuation line
  721.                 if (clockOffset != 0.0) {
  722.                     outputField(TWELVE_NINE_DIGITS_FLOAT, clockOffset, 80);
  723.                 }
  724.                 offsetWritten = true;
  725.                 finishLine();
  726.                 outputField("", 32, true);
  727.                 next = column + 3;
  728.             }
  729.             outputField(ods.getSatellite().toString(), next, false);
  730.         }
  731.         if (!offsetWritten && clockOffset != 0.0) {
  732.             outputField("", 68, true);
  733.             outputField(TWELVE_NINE_DIGITS_FLOAT, first.getRcvrClkOffset(), 80);
  734.         }
  735.         finishLine();

  737.         // observations per se
  738.         for (final ObservationDataSet ods : pending) {
  739.             for (final ObservationData od : ods.getObservationData()) {
  740.                 int next = column + 16;
  741.                 if (next > 80) {
  742.                     // we need to set up a continuation line
  743.                     finishLine();
  744.                     next = column + 16;
  745.                 }
  746.                 final double scaling = getScaling(od.getObservationType(), ods.getSatellite().getSystem());
  747.                 outputField(FOURTEEN_THREE_DIGITS_FLOAT, scaling * od.getValue(), next - 2);
  748.                 if (od.getLossOfLockIndicator() == 0) {
  749.                     outputField("", next - 1, true);
  750.                 } else {
  751.                     outputField(ONE_DIGIT_INTEGER, od.getLossOfLockIndicator(), next - 1);
  752.                 }
  753.                 if (od.getSignalStrength() == 0) {
  754.                     outputField("", next, true);
  755.                 } else {
  756.                     outputField(ONE_DIGIT_INTEGER, od.getSignalStrength(), next);
  757.                 }
  758.             }
  759.             finishLine();
  760.         }

  762.     }

  764.     /** Write one observation data set in RINEX 3/4 format.
  765.      * @exception IOException if an I/O error occurs.
  766.      */
  767.     public void writePendingRinex34Observations()
  768.         throws IOException {

  770.         final ObservationDataSet first = pending.get(0);

  772.         // EPOCH/SAT
  773.         final DateTimeComponents dtc = first.getDate().getComponents(timeScale).roundIfNeeded(60, 7);
  774.         outputField(">",  2, true);
  775.         outputField(FOUR_DIGITS_INTEGER,         dtc.getDate().getYear(),    6);
  776.         outputField("",   7, true);
  777.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getDate().getMonth(),   9);
  778.         outputField("",  10, true);
  779.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getDate().getDay(),    12);
  780.         outputField("", 13, true);
  781.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getTime().getHour(),   15);
  782.         outputField("", 16, true);
  783.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getTime().getMinute(), 18);
  784.         outputField(ELEVEN_SEVEN_DIGITS_FLOAT,   dtc.getTime().getSecond(), 29);

  786.         // event flag
  787.         outputField("", 31, true);
  788.         if (first.getEventFlag() == 0) {
  789.             outputField("", 32, true);
  790.         } else {
  791.             outputField(ONE_DIGIT_INTEGER, first.getEventFlag(), 32);
  792.         }

  794.         // number of satellites and receiver clock offset
  795.         outputField(THREE_DIGITS_INTEGER, pending.size(), 35);
  796.         if (first.getRcvrClkOffset() != 0.0) {
  797.             outputField("", 41, true);
  798.             outputField(FIFTEEN_TWELVE_DIGITS_FLOAT, first.getRcvrClkOffset(), 56);
  799.         }
  800.         finishLine();

  802.         // observations per se
  803.         for (final ObservationDataSet ods : pending) {
  804.             outputField(ods.getSatellite().toString(), 3, false);
  805.             for (final ObservationData od : ods.getObservationData()) {
  806.                 final int next = column + 16;
  807.                 final double scaling = getScaling(od.getObservationType(), ods.getSatellite().getSystem());
  808.                 outputField(FOURTEEN_THREE_DIGITS_FLOAT, scaling * od.getValue(), next - 2);
  809.                 if (od.getLossOfLockIndicator() == 0) {
  810.                     outputField("", next - 1, true);
  811.                 } else {
  812.                     outputField(ONE_DIGIT_INTEGER, od.getLossOfLockIndicator(), next - 1);
  813.                 }
  814.                 if (od.getSignalStrength() == 0) {
  815.                     outputField("", next, true);
  816.                 } else {
  817.                     outputField(ONE_DIGIT_INTEGER, od.getSignalStrength(), next);
  818.                 }
  819.             }
  820.             finishLine();
  821.         }

  823.     }

  825.     /** Write one header string.
  826.      * @param s string data (may be null)
  827.      * @param label line label
  828.      * @throws IOException if an I/O error occurs.
  829.      */
  830.     private void writeHeaderLine(final String s, final RinexLabels label) throws IOException {
  831.         if (s != null) {
  832.             outputField(s, s.length(), true);
  833.             finishHeaderLine(label);
  834.         }
  835.     }

  837.     /** Write one header vector.
  838.      * @param vector vector data (may be null)
  839.      * @param label line label
  840.      * @throws IOException if an I/O error occurs.
  841.      */
  842.     private void writeHeaderLine(final Vector3D vector, final RinexLabels label) throws IOException {
  843.         if (vector != null) {
  844.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, vector.getX(), 14);
  845.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, vector.getY(), 28);
  846.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, vector.getZ(), 42);
  847.             finishHeaderLine(label);
  848.         }
  849.     }

  851.     /** Finish one header line.
  852.      * @param label line label
  853.      * @throws IOException if an I/O error occurs.
  854.      */
  855.     private void finishHeaderLine(final RinexLabels label) throws IOException {
  856.         for (int i = column; i < LABEL_INDEX; ++i) {
  857.             output.append(' ');
  858.         }
  859.         output.append(label.getLabel());
  860.         finishLine();
  861.     }

  863.     /** Finish one line.
  864.      * @throws IOException if an I/O error occurs.
  865.      */
  866.     private void finishLine() throws IOException {

  868.         // pending line
  869.         output.append(System.lineSeparator());
  870.         lineNumber++;
  871.         column = 0;

  873.         // emit comments that should be placed at next lines
  874.         for (final RinexComment comment : savedComments) {
  875.             if (comment.getLineNumber() == lineNumber) {
  876.                 outputField(comment.getText(), LABEL_INDEX, true);
  877.                 output.append(RinexLabels.COMMENT.getLabel());
  878.                 output.append(System.lineSeparator());
  879.                 lineNumber++;
  880.                 column = 0;
  881.             } else if (comment.getLineNumber() > lineNumber) {
  882.                 break;
  883.             }
  884.         }

  886.     }

  888.     /** Output one single character field.
  889.      * @param c field value
  890.      * @param next target column for next field
  891.      * @throws IOException if an I/O error occurs.
  892.      */
  893.     private void outputField(final char c, final int next) throws IOException {
  894.         outputField(Character.toString(c), next, false);
  895.     }

  897.     /** Output one integer field.
  898.      * @param formatter formatter to use
  899.      * @param value field value
  900.      * @param next target column for next field
  901.      * @throws IOException if an I/O error occurs.
  902.      */
  903.     private void outputField(final FastLongFormatter formatter, final int value, final int next) throws IOException {
  904.         outputField(formatter.toString(value), next, false);
  905.     }

  907.     /** Output one double field.
  908.      * @param formatter formatter to use
  909.      * @param value field value
  910.      * @param next target column for next field
  911.      * @throws IOException if an I/O error occurs.
  912.      */
  913.     private void outputField(final FastDoubleFormatter formatter, final double value, final int next) throws IOException {
  914.         if (Double.isNaN(value)) {
  915.             // NaN values are replaced by blank fields
  916.             outputField("", next, true);
  917.         } else {
  918.             outputField(formatter.toString(value), next, false);
  919.         }
  920.     }

  922.     /** Output one field.
  923.      * @param field field to output
  924.      * @param next target column for next field
  925.      * @param leftJustified if true, field is left-justified
  926.      * @throws IOException if an I/O error occurs.
  927.      */
  928.     private void outputField(final String field, final int next, final boolean leftJustified) throws IOException {
  929.         final int padding = next - (field == null ? 0 : field.length()) - column;
  930.         if (padding < 0) {
  931.             throw new OrekitException(OrekitMessages.FIELD_TOO_LONG, field, next - column);
  932.         }
  933.         if (leftJustified && field != null) {
  934.             output.append(field);
  935.         }
  936.         for (int i = 0; i < padding; ++i) {
  937.             output.append(' ');
  938.         }
  939.         if (!leftJustified && field != null) {
  940.             output.append(field);
  941.         }
  942.         column = next;
  943.     }

  945.     /** Get the scaling factor for an observation.
  946.      * @param type type of observation
  947.      * @param system satellite system for the observation
  948.      * @return scaling factor
  949.      */
  950.     private double getScaling(final ObservationType type, final SatelliteSystem system) {

  952.         for (final ScaleFactorCorrection scaleFactorCorrection : savedHeader.getScaleFactorCorrections(system)) {
  953.             // check if the next Observation Type to read needs to be scaled
  954.             if (scaleFactorCorrection.getTypesObsScaled().contains(type)) {
  955.                 return scaleFactorCorrection.getCorrection();
  956.             }
  957.         }

  959.         // no scaling
  960.         return 1.0;

  962.     }

  964. }
Created with JaCoCo 0.8.12.202403310830