RinexObservationWriter.java

  1. /* Copyright 2023 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.Locale;
  24. import java.util.Map;

  26. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  27. import org.hipparchus.util.FastMath;
  28. import org.orekit.annotation.DefaultDataContext;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitMessages;
  31. import org.orekit.files.rinex.AppliedDCBS;
  32. import org.orekit.files.rinex.AppliedPCVS;
  33. import org.orekit.files.rinex.section.RinexComment;
  34. import org.orekit.files.rinex.section.RinexLabels;
  35. import org.orekit.gnss.ObservationTimeScale;
  36. import org.orekit.gnss.ObservationType;
  37. import org.orekit.gnss.SatInSystem;
  38. import org.orekit.gnss.SatelliteSystem;
  39. import org.orekit.time.AbsoluteDate;
  40. import org.orekit.time.DateTimeComponents;
  41. import org.orekit.time.TimeScale;
  42. import org.orekit.time.TimeScalesFactory;

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

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

  63.     /** Format for one 1 digit integer field. */
  64.     private static final String ONE_DIGIT_INTEGER = "%1d";

  66.     /** Format for one 2 digits integer field. */
  67.     private static final String PADDED_TWO_DIGITS_INTEGER = "%02d";

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

  72.     /** Format for one 4 digits integer field. */
  73.     private static final String PADDED_FOUR_DIGITS_INTEGER = "%04d";

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

  78.     /** Format for one 4 digits integer field. */
  79.     private static final String FOUR_DIGITS_INTEGER = "%4d";

  81.     /** Format for one 6 digits integer field. */
  82.     private static final String SIX_DIGITS_INTEGER = "%6d";

  84.     /** Format for one 8.3 digits float field. */
  85.     private static final String EIGHT_THREE_DIGITS_FLOAT = "%8.3f";

  87.     /** Format for one 8.5 digits float field. */
  88.     private static final String EIGHT_FIVE_DIGITS_FLOAT = "%8.5f";

  90.     /** Format for one 9.4 digits float field. */
  91.     private static final String NINE_FOUR_DIGITS_FLOAT = "%9.4f";

  93.     /** Format for one 10.3 digits float field. */
  94.     private static final String TEN_THREE_DIGITS_FLOAT = "%10.3f";

  96.     /** Format for one 11.7 digits float field. */
  97.     private static final String ELEVEN_SEVEN_DIGITS_FLOAT = "%11.7f";

  99.     /** Format for one 12.9 digits float field. */
  100.     private static final String TWELVE_NINE_DIGITS_FLOAT = "%12.9f";

  102.     /** Format for one 13.7 digits float field. */
  103.     private static final String THIRTEEN_SEVEN_DIGITS_FLOAT = "%13.7f";

  105.     /** Format for one 14.3 digits float field. */
  106.     private static final String FOURTEEN_THREE_DIGITS_FLOAT = "%14.3f";

  108.     /** Format for one 14.4 digits float field. */
  109.     private static final String FOURTEEN_FOUR_DIGITS_FLOAT = "%14.4f";

  111.     /** Format for one 15.12 digits float field. */
  112.     private static final String FIFTEEN_TWELVE_DIGITS_FLOAT = "%15.12f";

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

  119.     /** Destination of generated output. */
  120.     private final Appendable output;

  122.     /** Output name for error messages. */
  123.     private final String outputName;

  125.     /** Time scale for writing dates. */
  126.     private TimeScale timeScale;

  128.     /** Saved header. */
  129.     private RinexObservationHeader savedHeader;

  131.     /** Saved comments. */
  132.     private List<RinexComment> savedComments;

  134.     /** Pending observations. */
  135.     private final List<ObservationDataSet> pending;

  137.     /** Line number. */
  138.     private int lineNumber;

  140.     /** Column number. */
  141.     private int column;

  143.     /** Simple constructor.
  144.      * @param output destination of generated output
  145.      * @param outputName output name for error messages
  146.      */
  147.     public RinexObservationWriter(final Appendable output, final String outputName) {
  148.         this.output        = output;
  149.         this.outputName    = outputName;
  150.         this.savedHeader   = null;
  151.         this.savedComments = Collections.emptyList();
  152.         this.pending       = new ArrayList<>();
  153.         this.lineNumber    = 0;
  154.         this.column        = 0;
  155.     }

  157.     /** {@inheritDoc} */
  158.     @Override
  159.     public void close() throws IOException {
  160.         processPending();
  161.     }

  163.     /** Write a complete observation file.
  164.      * <p>
  165.      * This method calls {@link #prepareComments(List)} and
  166.      * {@link #writeHeader(RinexObservationHeader)} once and then loops on
  167.      * calling {@link #writeObservationDataSet(ObservationDataSet)}
  168.      * for all observation data sets in the file
  169.      * </p>
  170.      * @param rinexObservation Rinex observation file to write
  171.      * @see #writeHeader(RinexObservationHeader)
  172.      * @see #writeObservationDataSet(ObservationDataSet)
  173.      * @exception IOException if an I/O error occurs.
  174.      */
  175.     @DefaultDataContext
  176.     public void writeCompleteFile(final RinexObservation rinexObservation)
  177.         throws IOException {
  178.         prepareComments(rinexObservation.getComments());
  179.         writeHeader(rinexObservation.getHeader());
  180.         for (final ObservationDataSet observationDataSet : rinexObservation.getObservationDataSets()) {
  181.             writeObservationDataSet(observationDataSet);
  182.         }
  183.     }

  185.     /** Prepare comments to be emitted at specified lines.
  186.      * @param comments comments to be emitted
  187.      */
  188.     public void prepareComments(final List<RinexComment> comments) {
  189.         savedComments = comments;
  190.     }

  192.     /** Write header.
  193.      * <p>
  194.      * This method must be called exactly once at the beginning
  195.      * (directly or by {@link #writeCompleteFile(RinexObservation)})
  196.      * </p>
  197.      * @param header header to write
  198.      * @exception IOException if an I/O error occurs.
  199.      */
  200.     @DefaultDataContext
  201.     public void writeHeader(final RinexObservationHeader header)
  202.         throws IOException {

  204.         // check header is written exactly once
  205.         if (savedHeader != null) {
  206.             throw new OrekitException(OrekitMessages.HEADER_ALREADY_WRITTEN, outputName);
  207.         }
  208.         savedHeader = header;
  209.         lineNumber  = 1;

  211.         final ObservationTimeScale observationTimeScale = header.getSatelliteSystem().getObservationTimeScale() != null ?
  212.                                                           header.getSatelliteSystem().getObservationTimeScale() :
  213.                                                           ObservationTimeScale.GPS;
  214.         timeScale = observationTimeScale.getTimeScale(TimeScalesFactory.getTimeScales());

  216.         // RINEX VERSION / TYPE
  217.         outputField("%9.2f", header.getFormatVersion(), 9);
  218.         outputField("",                 20, true);
  219.         outputField("OBSERVATION DATA", 40, true);
  220.         outputField(header.getSatelliteSystem().getKey(), 41);
  221.         finishHeaderLine(RinexLabels.VERSION);

  223.         // PGM / RUN BY / DATE
  224.         outputField(header.getProgramName(), 20, true);
  225.         outputField(header.getRunByName(),   40, true);
  226.         final DateTimeComponents dtc = header.getCreationDateComponents();
  227.         if (header.getFormatVersion() < 3.0 && dtc.getTime().getSecond() < 0.5) {
  228.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getDay(), 42);
  229.             outputField('-', 43);
  230.             outputField(dtc.getDate().getMonthEnum().getUpperCaseAbbreviation(), 46,  true);
  231.             outputField('-', 47);
  232.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getYear() % 100, 49);
  233.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getHour(), 52);
  234.             outputField(':', 53);
  235.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getMinute(), 55);
  236.             outputField(header.getCreationTimeZone(), 58, true);
  237.         } else {
  238.             outputField(PADDED_FOUR_DIGITS_INTEGER, dtc.getDate().getYear(), 44);
  239.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getMonth(), 46);
  240.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getDate().getDay(), 48);
  241.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getHour(), 51);
  242.             outputField(PADDED_TWO_DIGITS_INTEGER, dtc.getTime().getMinute(), 53);
  243.             outputField(PADDED_TWO_DIGITS_INTEGER, (int) FastMath.rint(dtc.getTime().getSecond()), 55);
  244.             outputField(header.getCreationTimeZone(), 59, false);
  245.         }
  246.         finishHeaderLine(RinexLabels.PROGRAM);

  248.         // MARKER NAME
  249.         outputField(header.getMarkerName(), 60, true);
  250.         finishHeaderLine(RinexLabels.MARKER_NAME);

  252.         // MARKER NUMBER
  253.         if (header.getMarkerNumber() != null) {
  254.             outputField(header.getMarkerNumber(), 20, true);
  255.             finishHeaderLine(RinexLabels.MARKER_NUMBER);
  256.         }

  258.         // MARKER TYPE
  259.         if (header.getFormatVersion() >= 2.20) {
  260.             outputField(header.getMarkerType(), 20, true);
  261.             finishHeaderLine(RinexLabels.MARKER_TYPE);
  262.         }

  264.         // OBSERVER / AGENCY
  265.         outputField(header.getObserverName(), 20, true);
  266.         outputField(header.getAgencyName(),   40, true);
  267.         finishHeaderLine(RinexLabels.OBSERVER_AGENCY);

  269.         // REC # / TYPE / VERS
  270.         outputField(header.getReceiverNumber(),  20, true);
  271.         outputField(header.getReceiverType(),    40, true);
  272.         outputField(header.getReceiverVersion(), 60, true);
  273.         finishHeaderLine(RinexLabels.REC_NB_TYPE_VERS);

  275.         // ANT # / TYPE
  276.         outputField(header.getAntennaNumber(), 20, true);
  277.         outputField(header.getAntennaType(),   40, true);
  278.         finishHeaderLine(RinexLabels.ANT_NB_TYPE);

  280.         // APPROX POSITION XYZ
  281.         writeHeaderLine(header.getApproxPos(), RinexLabels.APPROX_POSITION_XYZ);

  283.         // ANTENNA: DELTA H/E/N
  284.         if (!Double.isNaN(header.getAntennaHeight())) {
  285.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getAntennaHeight(),         14);
  286.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getEccentricities().getX(), 28);
  287.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getEccentricities().getY(), 42);
  288.             finishHeaderLine(RinexLabels.ANTENNA_DELTA_H_E_N);
  289.         }

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

  294.         // ANTENNA: PHASECENTER
  295.         if (header.getAntennaPhaseCenter() != null) {
  296.             outputField(header.getPhaseCenterSystem().getKey(), 1);
  297.             outputField("", 2, true);
  298.             outputField(header.getObservationCode(), 5, true);
  299.             outputField(NINE_FOUR_DIGITS_FLOAT,     header.getAntennaPhaseCenter().getX(), 14);
  300.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getAntennaPhaseCenter().getY(), 28);
  301.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, header.getAntennaPhaseCenter().getZ(), 42);
  302.             finishHeaderLine(RinexLabels.ANTENNA_PHASE_CENTER);
  303.         }

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

  308.         // ANTENNA: ZERODIR AZI
  309.         if (!Double.isNaN(header.getAntennaAzimuth())) {
  310.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, FastMath.toDegrees(header.getAntennaAzimuth()), 14);
  311.             finishHeaderLine(RinexLabels.ANTENNA_ZERODIR_AZI);
  312.         }

  314.         // ANTENNA: ZERODIR XYZ
  315.         writeHeaderLine(header.getAntennaZeroDirection(), RinexLabels.ANTENNA_ZERODIR_XYZ);

  317.         // OBS SCALE FACTOR
  318.         if (FastMath.abs(header.getFormatVersion() - 2.20) < 0.001) {
  319.             for (final SatelliteSystem system : SatelliteSystem.values()) {
  320.                 for (final ScaleFactorCorrection sfc : header.getScaleFactorCorrections(system)) {
  321.                     if (sfc != null) {
  322.                         outputField(SIX_DIGITS_INTEGER, (int) FastMath.round(sfc.getCorrection()), 6);
  323.                         outputField(SIX_DIGITS_INTEGER, sfc.getTypesObsScaled().size(), 12);
  324.                         for (int i = 0; i < sfc.getTypesObsScaled().size(); ++i) {
  325.                             outputField(sfc.getTypesObsScaled().get(i).name(), 18 + 6 * i, false);
  326.                         }
  327.                         finishHeaderLine(RinexLabels.OBS_SCALE_FACTOR);
  328.                     }
  329.                 }
  330.             }
  331.         }

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

  336.         // DOI
  337.         writeHeaderLine(header.getDoi(), RinexLabels.DOI);

  339.         // LICENSE OF USE
  340.         writeHeaderLine(header.getLicense(), RinexLabels.LICENSE);

  342.         // STATION INFORMATION
  343.         writeHeaderLine(header.getStationInformation(), RinexLabels.STATION_INFORMATION);

  345.         // SYS / # / OBS TYPES
  346.         for (Map.Entry<SatelliteSystem, List<ObservationType>> entry : header.getTypeObs().entrySet()) {
  347.             if (header.getFormatVersion() < 3.0) {
  348.                 outputField(SIX_DIGITS_INTEGER, entry.getValue().size(), 6);
  349.             } else {
  350.                 outputField(entry.getKey().getKey(), 1);
  351.                 outputField(THREE_DIGITS_INTEGER, entry.getValue().size(), 6);
  352.             }
  353.             for (final ObservationType observationType : entry.getValue()) {
  354.                 int next = column + (header.getFormatVersion() < 3.0 ? 6 : 4);
  355.                 if (next > LABEL_INDEX) {
  356.                     // we need to set up a continuation line
  357.                     finishHeaderLine(header.getFormatVersion() < 3.0 ?
  358.                                      RinexLabels.NB_TYPES_OF_OBSERV :
  359.                                      RinexLabels.SYS_NB_TYPES_OF_OBSERV);
  360.                     outputField("", 6, true);
  361.                     next = column + (header.getFormatVersion() < 3.0 ? 6 : 4);
  362.                 }
  363.                 outputField(observationType.name(), next, false);
  364.             }
  365.             finishHeaderLine(header.getFormatVersion() < 3.0 ?
  366.                              RinexLabels.NB_TYPES_OF_OBSERV :
  367.                              RinexLabels.SYS_NB_TYPES_OF_OBSERV);
  368.         }

  370.         // SIGNAL STRENGTH UNIT
  371.         writeHeaderLine(header.getSignalStrengthUnit(), RinexLabels.SIGNAL_STRENGTH_UNIT);

  373.         // INTERVAL
  374.         if (!Double.isNaN(header.getInterval())) {
  375.             outputField(TEN_THREE_DIGITS_FLOAT, header.getInterval(), 10);
  376.             finishHeaderLine(RinexLabels.INTERVAL);
  377.         }

  379.         // TIME OF FIRST OBS
  380.         final DateTimeComponents dtcFirst = header.getTFirstObs().getComponents(timeScale);
  381.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getDate().getYear(), 6);
  382.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getDate().getMonth(), 12);
  383.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getDate().getDay(), 18);
  384.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getTime().getHour(), 24);
  385.         outputField(SIX_DIGITS_INTEGER,          dtcFirst.getTime().getMinute(), 30);
  386.         outputField(THIRTEEN_SEVEN_DIGITS_FLOAT, dtcFirst.getTime().getSecond(), 43);
  387.         outputField(observationTimeScale.name(), 51, false);
  388.         finishHeaderLine(RinexLabels.TIME_OF_FIRST_OBS);

  390.         // TIME OF LAST OBS
  391.         if (!header.getTLastObs().equals(AbsoluteDate.FUTURE_INFINITY)) {
  392.             final DateTimeComponents dtcLast = header.getTLastObs().getComponents(timeScale);
  393.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getDate().getYear(), 6);
  394.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getDate().getMonth(), 12);
  395.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getDate().getDay(), 18);
  396.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getTime().getHour(), 24);
  397.             outputField(SIX_DIGITS_INTEGER,          dtcLast.getTime().getMinute(), 30);
  398.             outputField(THIRTEEN_SEVEN_DIGITS_FLOAT, dtcLast.getTime().getSecond(), 43);
  399.             outputField(observationTimeScale.name(), 51, false);
  400.             finishHeaderLine(RinexLabels.TIME_OF_LAST_OBS);
  401.         }

  403.         // RCV CLOCK OFFS APPL
  404.         if (header.getClkOffset() >= 0) {
  405.             outputField(SIX_DIGITS_INTEGER, header.getClkOffset(), 6);
  406.             finishHeaderLine(RinexLabels.RCV_CLOCK_OFFS_APPL);
  407.         }

  409.         // SYS / DCBS APPLIED
  410.         for (final AppliedDCBS appliedDCBS : header.getListAppliedDCBS()) {
  411.             outputField(appliedDCBS.getSatelliteSystem().getKey(),  1);
  412.             outputField("",                                         2, true);
  413.             outputField(appliedDCBS.getProgDCBS(),                 20, true);
  414.             outputField(appliedDCBS.getSourceDCBS(),               60, true);
  415.             finishHeaderLine(RinexLabels.SYS_DCBS_APPLIED);
  416.         }

  418.         // SYS / PCVS APPLIED
  419.         for (final AppliedPCVS appliedPCVS : header.getListAppliedPCVS()) {
  420.             outputField(appliedPCVS.getSatelliteSystem().getKey(),  1);
  421.             outputField("",                                         2, true);
  422.             outputField(appliedPCVS.getProgPCVS(),                 20, true);
  423.             outputField(appliedPCVS.getSourcePCVS(),               60, true);
  424.             finishHeaderLine(RinexLabels.SYS_PCVS_APPLIED);
  425.         }

  427.         // SYS / SCALE FACTOR
  428.         if (header.getFormatVersion() >= 3.0) {
  429.             for (final SatelliteSystem system : SatelliteSystem.values()) {
  430.                 for (final ScaleFactorCorrection sfc : header.getScaleFactorCorrections(system)) {
  431.                     if (sfc != null) {
  432.                         outputField(system.getKey(), 1);
  433.                         outputField("", 2, true);
  434.                         outputField(FOUR_DIGITS_INTEGER, (int) FastMath.rint(sfc.getCorrection()), 6);
  435.                         if (sfc.getTypesObsScaled().size() < header.getTypeObs().get(system).size()) {
  436.                             outputField("", 8, true);
  437.                             outputField(TWO_DIGITS_INTEGER,  sfc.getTypesObsScaled().size(), 10);
  438.                             for (ObservationType observationType : sfc.getTypesObsScaled()) {
  439.                                 int next = column + 4;
  440.                                 if (next > LABEL_INDEX) {
  441.                                     // we need to set up a continuation line
  442.                                     finishHeaderLine(RinexLabels.SYS_SCALE_FACTOR);
  443.                                     outputField("", 10, true);
  444.                                     next = column + 4;
  445.                                 }
  446.                                 outputField("", next - 3, true);
  447.                                 outputField(observationType.name(), next, true);
  448.                             }
  449.                         }
  450.                         finishHeaderLine(RinexLabels.SYS_SCALE_FACTOR);
  451.                     }
  452.                 }
  453.             }
  454.         }

  456.         // SYS / PHASE SHIFT
  457.         for (final PhaseShiftCorrection psc : header.getPhaseShiftCorrections()) {
  458.             outputField(psc.getSatelliteSystem().getKey(), 1);
  459.             outputField(psc.getTypeObs().name(), 5, false);
  460.             outputField(EIGHT_FIVE_DIGITS_FLOAT, psc.getCorrection(), 14);
  461.             if (!psc.getSatsCorrected().isEmpty()) {
  462.                 outputField(TWO_DIGITS_INTEGER, psc.getSatsCorrected().size(), 18);
  463.                 for (final SatInSystem sis : psc.getSatsCorrected()) {
  464.                     int next = column + 4;
  465.                     if (next > LABEL_INDEX) {
  466.                         // we need to set up a continuation line
  467.                         finishHeaderLine(RinexLabels.SYS_PHASE_SHIFT);
  468.                         outputField("", 18, true);
  469.                         next = column + 4;
  470.                     }
  471.                     outputField(sis.getSystem().getKey(), next - 2);
  472.                     outputField(PADDED_TWO_DIGITS_INTEGER, sis.getTwoDigitsRinexPRN(), next);
  473.                 }
  474.             }
  475.             finishHeaderLine(RinexLabels.SYS_PHASE_SHIFT);
  476.         }

  478.         if (header.getFormatVersion() >= 3.01) {
  479.             if (!header.getGlonassChannels().isEmpty()) {
  480.                 // GLONASS SLOT / FRQ #
  481.                 outputField(THREE_DIGITS_INTEGER, header.getGlonassChannels().size(), 3);
  482.                 outputField("", 4, true);
  483.                 for (final GlonassSatelliteChannel channel : header.getGlonassChannels()) {
  484.                     int next = column + 7;
  485.                     if (next > LABEL_INDEX) {
  486.                         // we need to set up a continuation line
  487.                         finishHeaderLine(RinexLabels.GLONASS_SLOT_FRQ_NB);
  488.                         outputField("", 4, true);
  489.                         next = column + 7;
  490.                     }
  491.                     outputField(channel.getSatellite().getSystem().getKey(), next - 6);
  492.                     outputField(PADDED_TWO_DIGITS_INTEGER, channel.getSatellite().getPRN(), next - 4);
  493.                     outputField(TWO_DIGITS_INTEGER, channel.getK(), next - 1);
  494.                     outputField("", next, true);
  495.                 }
  496.             }
  497.             finishHeaderLine(RinexLabels.GLONASS_SLOT_FRQ_NB);
  498.         }

  500.         if (header.getFormatVersion() >= 3.0) {
  501.             // GLONASS COD/PHS/BIS
  502.             if (Double.isNaN(header.getC1cCodePhaseBias())) {
  503.                 outputField("", 13, true);
  504.             } else {
  505.                 outputField(ObservationType.C1C.name(), 4, false);
  506.                 outputField("", 5, true);
  507.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC1cCodePhaseBias(), 13);
  508.             }
  509.             if (Double.isNaN(header.getC1pCodePhaseBias())) {
  510.                 outputField("", 26, true);
  511.             } else {
  512.                 outputField(ObservationType.C1P.name(), 17, false);
  513.                 outputField("", 18, true);
  514.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC1pCodePhaseBias(), 26);
  515.             }
  516.             if (Double.isNaN(header.getC2cCodePhaseBias())) {
  517.                 outputField("", 39, true);
  518.             } else {
  519.                 outputField(ObservationType.C2C.name(), 30, false);
  520.                 outputField("", 31, true);
  521.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC2cCodePhaseBias(), 39);
  522.             }
  523.             if (Double.isNaN(header.getC2pCodePhaseBias())) {
  524.                 outputField("", 52, true);
  525.             } else {
  526.                 outputField(ObservationType.C2P.name(), 43, false);
  527.                 outputField("", 44, true);
  528.                 outputField(EIGHT_THREE_DIGITS_FLOAT, header.getC2pCodePhaseBias(), 52);
  529.             }
  530.             finishHeaderLine(RinexLabels.GLONASS_COD_PHS_BIS);
  531.         }

  533.         // LEAP SECONDS
  534.         if (header.getLeapSeconds() > 0) {
  535.             outputField(SIX_DIGITS_INTEGER, header.getLeapSeconds(), 6);
  536.             if (header.getFormatVersion() >= 3.0) {
  537.                 outputField(SIX_DIGITS_INTEGER, header.getLeapSecondsFuture(),  12);
  538.                 outputField(SIX_DIGITS_INTEGER, header.getLeapSecondsWeekNum(), 18);
  539.                 outputField(SIX_DIGITS_INTEGER, header.getLeapSecondsDayNum(),  24);
  540.             }
  541.             finishHeaderLine(RinexLabels.LEAP_SECONDS);
  542.         }

  544.         // # OF SATELLITES
  545.         if (header.getNbSat() >= 0) {
  546.             outputField(SIX_DIGITS_INTEGER, header.getNbSat(), 6);
  547.             finishHeaderLine(RinexLabels.NB_OF_SATELLITES);
  548.         }

  550.         // PRN / # OF OBS
  551.         for (final Map.Entry<SatInSystem, Map<ObservationType, Integer>> entry1 : header.getNbObsPerSat().entrySet()) {
  552.             final SatInSystem sis = entry1.getKey();
  553.             outputField(sis.getSystem().getKey(), 4);
  554.             outputField(PADDED_TWO_DIGITS_INTEGER, sis.getTwoDigitsRinexPRN(), 6);
  555.             for (final Map.Entry<ObservationType, Integer> entry2 : entry1.getValue().entrySet()) {
  556.                 int next = column + 6;
  557.                 if (next > LABEL_INDEX) {
  558.                     // we need to set up a continuation line
  559.                     finishHeaderLine(RinexLabels.PRN_NB_OF_OBS);
  560.                     outputField("", 6, true);
  561.                     next = column + 6;
  562.                 }
  563.                 outputField(SIX_DIGITS_INTEGER, entry2.getValue(), next);
  564.             }
  565.             finishHeaderLine(RinexLabels.PRN_NB_OF_OBS);
  566.         }

  568.         // END OF HEADER
  569.         writeHeaderLine("", RinexLabels.END);

  571.     }

  573.     /** Write one observation data set.
  574.      * <p>
  575.      * Note that this writers output only regular observations, so
  576.      * the event flag is always set to 0
  577.      * </p>
  578.      * @param observationDataSet observation data set to write
  579.      * @exception IOException if an I/O error occurs.
  580.      */
  581.     public void writeObservationDataSet(final ObservationDataSet observationDataSet)
  582.         throws IOException {

  584.         // check header has already been written
  585.         if (savedHeader == null) {
  586.             throw new OrekitException(OrekitMessages.HEADER_NOT_WRITTEN, outputName);
  587.         }

  589.         if (!pending.isEmpty() && observationDataSet.durationFrom(pending.get(0).getDate()) > EPS_DATE) {
  590.             // the specified observation belongs to the next batch
  591.             // we must process the current batch of pending observations
  592.             processPending();
  593.         }

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

  598.     }

  600.     /** Process all pending measurements.
  601.      * @exception IOException if an I/O error occurs.
  602.      */
  603.     private void processPending() throws IOException {

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

  607.             // write the batch of pending observations
  608.             if (savedHeader.getFormatVersion() < 3.0) {
  609.                 writePendingRinex2Observations();
  610.             } else {
  611.                 writePendingRinex34Observations();
  612.             }

  614.             // prepare for next batch
  615.             pending.clear();

  617.         }

  619.     }

  621.     /** Write one observation data set in RINEX 2 format.
  622.      * @exception IOException if an I/O error occurs.
  623.      */
  624.     public void writePendingRinex2Observations() throws IOException {

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

  628.         // EPOCH/SAT
  629.         final DateTimeComponents dtc = first.getDate().getComponents(timeScale);
  630.         outputField("",  1, true);
  631.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getDate().getYear() % 100,    3);
  632.         outputField("",  4, true);
  633.         outputField(TWO_DIGITS_INTEGER,          dtc.getDate().getMonth(),         6);
  634.         outputField("",  7, true);
  635.         outputField(TWO_DIGITS_INTEGER,          dtc.getDate().getDay(),           9);
  636.         outputField("", 10, true);
  637.         outputField(TWO_DIGITS_INTEGER,          dtc.getTime().getHour(),         12);
  638.         outputField("", 13, true);
  639.         outputField(TWO_DIGITS_INTEGER,          dtc.getTime().getMinute(),       15);
  640.         outputField(ELEVEN_SEVEN_DIGITS_FLOAT,   dtc.getTime().getSecond(),       26);

  642.         // event flag
  643.         outputField("", 28, true);
  644.         if (first.getEventFlag() == 0) {
  645.             outputField("", 29, true);
  646.         } else {
  647.             outputField(ONE_DIGIT_INTEGER, first.getEventFlag(), 29);
  648.         }

  650.         // list of satellites and receiver clock offset
  651.         outputField(THREE_DIGITS_INTEGER, pending.size(), 32);
  652.         boolean offsetWritten = false;
  653.         final double  clockOffset   = first.getRcvrClkOffset();
  654.         for (final ObservationDataSet ods : pending) {
  655.             int next = column + 3;
  656.             if (next > 68) {
  657.                 // we need to set up a continuation line
  658.                 if (clockOffset != 0.0) {
  659.                     outputField(TWELVE_NINE_DIGITS_FLOAT, clockOffset, 80);
  660.                 }
  661.                 offsetWritten = true;
  662.                 finishLine();
  663.                 outputField("", 32, true);
  664.                 next = column + 3;
  665.             }
  666.             outputField(ods.getSatellite().getSystem().getKey(), next - 2);
  667.             outputField(PADDED_TWO_DIGITS_INTEGER, ods.getSatellite().getTwoDigitsRinexPRN(), next);
  668.         }
  669.         if (!offsetWritten && clockOffset != 0.0) {
  670.             outputField("", 68, true);
  671.             outputField(TWELVE_NINE_DIGITS_FLOAT, first.getRcvrClkOffset(), 80);
  672.         }
  673.         finishLine();

  675.         // observations per se
  676.         for (final ObservationDataSet ods : pending) {
  677.             for (final ObservationData od : ods.getObservationData()) {
  678.                 int next = column + 16;
  679.                 if (next > 80) {
  680.                     // we need to set up a continuation line
  681.                     finishLine();
  682.                     next = column + 16;
  683.                 }
  684.                 final double scaling = getScaling(od.getObservationType(), ods.getSatellite().getSystem());
  685.                 outputField(FOURTEEN_THREE_DIGITS_FLOAT, scaling * od.getValue(), next - 2);
  686.                 if (od.getLossOfLockIndicator() == 0) {
  687.                     outputField("", next - 1, true);
  688.                 } else {
  689.                     outputField(ONE_DIGIT_INTEGER, od.getLossOfLockIndicator(), next - 1);
  690.                 }
  691.                 if (od.getSignalStrength() == 0) {
  692.                     outputField("", next, true);
  693.                 } else {
  694.                     outputField(ONE_DIGIT_INTEGER, od.getSignalStrength(), next);
  695.                 }
  696.             }
  697.             finishLine();
  698.         }

  700.     }

  702.     /** Write one observation data set in RINEX 3/4 format.
  703.      * @exception IOException if an I/O error occurs.
  704.      */
  705.     public void writePendingRinex34Observations()
  706.         throws IOException {

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

  710.         // EPOCH/SAT
  711.         final DateTimeComponents dtc = first.getDate().getComponents(timeScale);
  712.         outputField(">",  2, true);
  713.         outputField(FOUR_DIGITS_INTEGER,         dtc.getDate().getYear(),    6);
  714.         outputField("",   7, true);
  715.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getDate().getMonth(),   9);
  716.         outputField("",  10, true);
  717.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getDate().getDay(),    12);
  718.         outputField("", 13, true);
  719.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getTime().getHour(),   15);
  720.         outputField("", 16, true);
  721.         outputField(PADDED_TWO_DIGITS_INTEGER,   dtc.getTime().getMinute(), 18);
  722.         outputField(ELEVEN_SEVEN_DIGITS_FLOAT,   dtc.getTime().getSecond(), 29);

  724.         // event flag
  725.         outputField("", 31, true);
  726.         if (first.getEventFlag() == 0) {
  727.             outputField("", 32, true);
  728.         } else {
  729.             outputField(ONE_DIGIT_INTEGER, first.getEventFlag(), 32);
  730.         }

  732.         // number of satellites and receiver clock offset
  733.         outputField(THREE_DIGITS_INTEGER, pending.size(), 35);
  734.         if (first.getRcvrClkOffset() != 0.0) {
  735.             outputField("", 41, true);
  736.             outputField(FIFTEEN_TWELVE_DIGITS_FLOAT, first.getRcvrClkOffset(), 56);
  737.         }
  738.         finishLine();

  740.         // observations per se
  741.         for (final ObservationDataSet ods : pending) {
  742.             outputField(ods.getSatellite().getSystem().getKey(), 1);
  743.             outputField(PADDED_TWO_DIGITS_INTEGER, ods.getSatellite().getTwoDigitsRinexPRN(), 3);
  744.             for (final ObservationData od : ods.getObservationData()) {
  745.                 final int next = column + 16;
  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 header string.
  765.      * @param s string data (may be null)
  766.      * @param label line label
  767.      * @throws IOException if an I/O error occurs.
  768.      */
  769.     private void writeHeaderLine(final String s, final RinexLabels label) throws IOException {
  770.         if (s != null) {
  771.             outputField(s, s.length(), true);
  772.             finishHeaderLine(label);
  773.         }
  774.     }

  776.     /** Write one header vector.
  777.      * @param vector vector data (may be null)
  778.      * @param label line label
  779.      * @throws IOException if an I/O error occurs.
  780.      */
  781.     private void writeHeaderLine(final Vector3D vector, final RinexLabels label) throws IOException {
  782.         if (vector != null) {
  783.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, vector.getX(), 14);
  784.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, vector.getY(), 28);
  785.             outputField(FOURTEEN_FOUR_DIGITS_FLOAT, vector.getZ(), 42);
  786.             finishHeaderLine(label);
  787.         }
  788.     }

  790.     /** Finish one header line.
  791.      * @param label line label
  792.      * @throws IOException if an I/O error occurs.
  793.      */
  794.     private void finishHeaderLine(final RinexLabels label) throws IOException {
  795.         for (int i = column; i < LABEL_INDEX; ++i) {
  796.             output.append(' ');
  797.         }
  798.         output.append(label.getLabel());
  799.         finishLine();
  800.     }

  802.     /** Finish one line.
  803.      * @throws IOException if an I/O error occurs.
  804.      */
  805.     private void finishLine() throws IOException {

  807.         // pending line
  808.         output.append(System.lineSeparator());
  809.         lineNumber++;
  810.         column = 0;

  812.         // emit comments that should be placed at next lines
  813.         for (final RinexComment comment : savedComments) {
  814.             if (comment.getLineNumber() == lineNumber) {
  815.                 outputField(comment.getText(), LABEL_INDEX, true);
  816.                 output.append(RinexLabels.COMMENT.getLabel());
  817.                 output.append(System.lineSeparator());
  818.                 lineNumber++;
  819.                 column = 0;
  820.             } else if (comment.getLineNumber() > lineNumber) {
  821.                 break;
  822.             }
  823.         }

  825.     }

  827.     /** Output one single character field.
  828.      * @param c field value
  829.      * @param next target column for next field
  830.      * @throws IOException if an I/O error occurs.
  831.      */
  832.     private void outputField(final char c, final int next) throws IOException {
  833.         outputField(Character.toString(c), next, false);
  834.     }

  836.     /** Output one integer field.
  837.      * @param format format to use
  838.      * @param value field value
  839.      * @param next target column for next field
  840.      * @throws IOException if an I/O error occurs.
  841.      */
  842.     private void outputField(final String format, final int value, final int next) throws IOException {
  843.         outputField(String.format(Locale.US, format, value), next, false);
  844.     }

  846.     /** Output one double field.
  847.      * @param format format to use
  848.      * @param value field value
  849.      * @param next target column for next field
  850.      * @throws IOException if an I/O error occurs.
  851.      */
  852.     private void outputField(final String format, final double value, final int next) throws IOException {
  853.         if (Double.isNaN(value)) {
  854.             // NaN values are replaced by blank fields
  855.             outputField("", next, true);
  856.         } else {
  857.             outputField(String.format(Locale.US, format, value), next, false);
  858.         }
  859.     }

  861.     /** Output one field.
  862.      * @param field field to output
  863.      * @param next target column for next field
  864.      * @param leftJustified if true, field is left-justified
  865.      * @throws IOException if an I/O error occurs.
  866.      */
  867.     private void outputField(final String field, final int next, final boolean leftJustified) throws IOException {
  868.         final int padding = next - (field == null ? 0 : field.length()) - column;
  869.         if (leftJustified && field != null) {
  870.             output.append(field);
  871.         }
  872.         for (int i = 0; i < padding; ++i) {
  873.             output.append(' ');
  874.         }
  875.         if (!leftJustified && field != null) {
  876.             output.append(field);
  877.         }
  878.         column = next;
  879.     }

  881.     /** Get the scaling factor for an observation.
  882.      * @param type type of observation
  883.      * @param system satellite system for the observation
  884.      * @return scaling factor
  885.      */
  886.     private double getScaling(final ObservationType type, final SatelliteSystem system) {

  888.         for (final ScaleFactorCorrection scaleFactorCorrection : savedHeader.getScaleFactorCorrections(system)) {
  889.             // check if the next Observation Type to read needs to be scaled
  890.             if (scaleFactorCorrection.getTypesObsScaled().contains(type)) {
  891.                 return scaleFactorCorrection.getCorrection();
  892.             }
  893.         }

  895.         // no scaling
  896.         return 1.0;

  898.     }

  900. }
Created with JaCoCo 0.8.11.202310140853