StreamingCpfWriter.java

  1. /* Contributed in the public domain.
  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.ilrs;

  19. import java.io.IOException;
  20. import java.util.Locale;

  22. import org.hipparchus.exception.LocalizedCoreFormats;
  23. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.frames.Frame;
  26. import org.orekit.propagation.Propagator;
  27. import org.orekit.propagation.SpacecraftState;
  28. import org.orekit.propagation.sampling.OrekitFixedStepHandler;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.DateTimeComponents;
  31. import org.orekit.time.TimeScale;
  32. import org.orekit.utils.TimeStampedPVCoordinates;

  34. /**
  35.  * A writer for CPF files.
  36.  *
  37.  * <p> Each instance corresponds to a single CPF file.
  38.  *
  39.  * <p> This class can be used as a step handler for a {@link Propagator}.
  40.  * The following example shows its use as a step handler.
  41.  *
  42.  * <p>
  43.  * <b>Note:</b> By default, only required header keys are wrote (H1 and H2). Furthermore, only position data can be written.
  44.  * Other keys (optionals) are simply ignored.
  45.  * Contributions are welcome to support more fields in the format.
  46.  *
  47.  * @author Bryan Cazabonne
  48.  * @since 10.3
  49.  */
  50. public class StreamingCpfWriter {

  52.     /** New line separator for output file. */
  53.     private static final String NEW_LINE = "\n";

  55.     /** String A2 Format. */
  56.     private static final String A2 = "%2s";

  58.     /** String A3 Format. */
  59.     private static final String A3 = "%3s";

  61.     /** String A4 Format. */
  62.     private static final String A4 = "%4s";

  64.     /** String A8 Format. */
  65.     private static final String A8 = "%8s";

  67.     /** String A10 Format. */
  68.     private static final String A10 = "%10s";

  70.     /** Integer I1 Format. */
  71.     private static final String I1 = "%1d";

  73.     /** Integer I2 Format. */
  74.     private static final String I2 = "%2d";

  76.     /** Integer I3 Format. */
  77.     private static final String I3 = "%3d";

  79.     /** Integer I4 Format. */
  80.     private static final String I4 = "%4d";

  82.     /** Integer I5 Format. */
  83.     private static final String I5 = "%5d";

  85.     /** Real 13.6 Format. */
  86.     private static final String F13_6 = "%13.6f";

  88.     /** Real 17.3 Format. */
  89.     private static final String F17_3 = "%17.3f";

  91.     /** Space. */
  92.     private static final String SPACE = " ";

  94.     /** File format. */
  95.     private static final String FORMAT = "CPF";

  97.     /** Default locale. */
  98.     private static final Locale STANDARDIZED_LOCALE = Locale.US;

  100.     /** Default value for direction flag in position record. */
  101.     private static final int DEFAULT_DIRECTION_FLAG = 0;

  103.     /** Output stream. */
  104.     private final Appendable writer;

  106.     /** Time scale for all dates. */
  107.     private final TimeScale timeScale;

  109.     /** Container for header data. */
  110.     private final CPFHeader header;

  112.     /**
  113.      * Create an OEM writer than streams data to the given output stream.
  114.      *
  115.      * @param writer     the output stream for the CPF file.
  116.      * @param timeScale  for all times in the CPF
  117.      * @param header     container for header data
  118.      */
  119.     public StreamingCpfWriter(final Appendable writer,
  120.                               final TimeScale timeScale,
  121.                               final CPFHeader header) {

  123.         this.writer     = writer;
  124.         this.timeScale  = timeScale;
  125.         this.header     = header;
  126.     }

  128.     /**
  129.      * Writes the CPF header for the file.
  130.      * @throws IOException if the stream cannot write to stream
  131.      */
  132.     public void writeHeader() throws IOException {

  134.         // Write H1
  135.         HeaderLineWriter.H1.write(header, writer, timeScale);
  136.         writer.append(NEW_LINE);

  138.         // Write H2
  139.         HeaderLineWriter.H2.write(header, writer, timeScale);
  140.         writer.append(NEW_LINE);

  142.         // End of header
  143.         writer.append("H9");
  144.         writer.append(NEW_LINE);

  146.     }

  148.     /**
  149.      * Write end of file.
  150.      * @throws IOException if the stream cannot write to stream
  151.      */
  152.     public void writeEndOfFile() throws IOException {
  153.         writer.append("99");
  154.     }

  156.     /**
  157.      * Create a writer for a new CPF ephemeris segment.
  158.      * <p>
  159.      * The returned writer can only write a single ephemeris segment in a CPF.
  160.      * </p>
  161.      * @param frame the reference frame to use for the segment. If this value is
  162.      *              {@code null} then {@link Segment#handleStep(SpacecraftState,
  163.      *              boolean)} will throw a {@link NullPointerException}.
  164.      * @return a new CPF segment, ready for writing.
  165.      */
  166.     public Segment newSegment(final Frame frame) {
  167.         return new Segment(frame);
  168.     }

  170.     /**
  171.      * Write a String value in the file.
  172.      * @param cpfWriter writer
  173.      * @param format format
  174.      * @param value value
  175.      * @throws IOException if value cannot be written
  176.      */
  177.     private static void writeValue(final Appendable cpfWriter, final String format, final String value)
  178.         throws IOException {
  179.         cpfWriter.append(String.format(STANDARDIZED_LOCALE, format, value)).append(SPACE);
  180.     }

  182.     /**
  183.      * Write a integer value in the file.
  184.      * @param cpfWriter writer
  185.      * @param format format
  186.      * @param value value
  187.      * @throws IOException if value cannot be written
  188.      */
  189.     private static void writeValue(final Appendable cpfWriter, final String format, final int value)
  190.         throws IOException {
  191.         cpfWriter.append(String.format(STANDARDIZED_LOCALE, format, value)).append(SPACE);
  192.     }

  194.     /**
  195.      * Write a real value in the file.
  196.      * @param cpfWriter writer
  197.      * @param format format
  198.      * @param value value
  199.      * @throws IOException if value cannot be written
  200.      */
  201.     private static void writeValue(final Appendable cpfWriter, final String format, final double value)
  202.         throws IOException {
  203.         cpfWriter.append(String.format(STANDARDIZED_LOCALE, format, value)).append(SPACE);
  204.     }

  206.     /**
  207.      * Write a String value in the file.
  208.      * @param cpfWriter writer
  209.      * @param format format
  210.      * @param value value
  211.      * @throws IOException if value cannot be writtent
  212.      */
  213.     private static void writeValue(final Appendable cpfWriter, final String format, final boolean value)
  214.         throws IOException {
  215.         // Change to an integer value
  216.         final int intValue = value ? 1 : 0;
  217.         writeValue(cpfWriter, format, intValue);
  218.     }

  220.     /** A writer for a segment of a CPF. */
  221.     public class Segment implements OrekitFixedStepHandler {

  223.         /** Reference frame of the output states. */
  224.         private final Frame frame;

  226.         /**
  227.          * Create a new segment writer.
  228.          *
  229.          * @param frame    for the output states. Used by {@link #handleStep(SpacecraftState,
  230.          *                 boolean)}.
  231.          */
  232.         private Segment(final Frame frame) {
  233.             this.frame = frame;
  234.         }

  236.         /** {@inheritDoc}. */
  237.         @Override
  238.         public void handleStep(final SpacecraftState currentState, final boolean isLast) {
  239.             try {

  241.                 // Write ephemeris line
  242.                 writeEphemerisLine(currentState.getPVCoordinates(frame));

  244.                 // Write end of file
  245.                 if (isLast) {
  246.                     writeEndOfFile();
  247.                 }

  249.             } catch (IOException e) {
  250.                 throw new OrekitException(e, LocalizedCoreFormats.SIMPLE_MESSAGE,
  251.                                           e.getLocalizedMessage());
  252.             }

  254.         }

  256.         /**
  257.          * Write a single ephemeris line This method does not
  258.          * write the velocity terms.
  259.          *
  260.          * @param pv the time, position, and velocity to write.
  261.          * @throws IOException if the output stream throws one while writing.
  262.          */
  263.         public void writeEphemerisLine(final TimeStampedPVCoordinates pv)
  264.             throws IOException {

  266.             // Record type and direction flag
  267.             writeValue(writer, A2, "10");
  268.             writeValue(writer, I1, DEFAULT_DIRECTION_FLAG);

  270.             // Epoch
  271.             final AbsoluteDate epoch = pv.getDate();
  272.             final DateTimeComponents dtc = epoch.getComponents(timeScale);
  273.             writeValue(writer, I5, dtc.getDate().getMJD());
  274.             writeValue(writer, F13_6, dtc.getTime().getSecondsInLocalDay());

  276.             // Leap second flag (default 0)
  277.             writeValue(writer, I2, 0);

  279.             // Position
  280.             final Vector3D position = pv.getPosition();
  281.             writeValue(writer, F17_3, position.getX());
  282.             writeValue(writer, F17_3, position.getY());
  283.             writeValue(writer, F17_3, position.getZ());

  285.             // New line
  286.             writer.append(NEW_LINE);

  288.         }

  290.     }

  292.     /** Writer for specific header lines. */
  293.     public enum HeaderLineWriter {

  295.         /** Header first line. */
  296.         H1("H1") {

  298.             /** {@inheritDoc} */
  299.             @Override
  300.             public void write(final CPFHeader cpfHeader, final Appendable cpfWriter,
  301.                               final TimeScale utc) throws IOException {

  303.                 // write first keys
  304.                 writeValue(cpfWriter, A2, getIdentifier());
  305.                 writeValue(cpfWriter, A3, FORMAT);
  306.                 writeValue(cpfWriter, I2, cpfHeader.getVersion());
  307.                 writeValue(cpfWriter, A3, cpfHeader.getSource());
  308.                 writeValue(cpfWriter, I4, cpfHeader.getProductionEpoch().getYear());
  309.                 writeValue(cpfWriter, I2, cpfHeader.getProductionEpoch().getMonth());
  310.                 writeValue(cpfWriter, I2, cpfHeader.getProductionEpoch().getDay());
  311.                 writeValue(cpfWriter, I2, cpfHeader.getProductionHour());
  312.                 writeValue(cpfWriter, I3, cpfHeader.getSequenceNumber());

  314.                 // check file version
  315.                 if (cpfHeader.getVersion() == 2) {
  316.                     writeValue(cpfWriter, I2, cpfHeader.getSubDailySequenceNumber());
  317.                 }

  319.                 // write last key
  320.                 writeValue(cpfWriter, A10, cpfHeader.getName());

  322.             }

  324.         },

  326.         /** Header second line. */
  327.         H2("H2") {

  329.             /** {@inheritDoc} */
  330.             @Override
  331.             public void write(final CPFHeader cpfHeader, final Appendable cpfWriter,
  332.                               final TimeScale utc) throws IOException {

  334.                 // write identifiers
  335.                 writeValue(cpfWriter, A2, getIdentifier());
  336.                 writeValue(cpfWriter, A8, cpfHeader.getIlrsSatelliteId());
  337.                 writeValue(cpfWriter, A4, cpfHeader.getSic());
  338.                 writeValue(cpfWriter, A8, cpfHeader.getNoradId());

  340.                 // write starting epoch
  341.                 final AbsoluteDate starting = cpfHeader.getStartEpoch();
  342.                 final DateTimeComponents dtcStart = starting.getComponents(utc);
  343.                 writeValue(cpfWriter, I4, dtcStart.getDate().getYear());
  344.                 writeValue(cpfWriter, I2, dtcStart.getDate().getMonth());
  345.                 writeValue(cpfWriter, I2, dtcStart.getDate().getDay());
  346.                 writeValue(cpfWriter, I2, dtcStart.getTime().getHour());
  347.                 writeValue(cpfWriter, I2, dtcStart.getTime().getMinute());
  348.                 writeValue(cpfWriter, I2, (int) dtcStart.getTime().getSecond());

  350.                 // write ending epoch
  351.                 final AbsoluteDate ending = cpfHeader.getStartEpoch();
  352.                 final DateTimeComponents dtcEnd = ending.getComponents(utc);
  353.                 writeValue(cpfWriter, I4, dtcEnd.getDate().getYear());
  354.                 writeValue(cpfWriter, I2, dtcEnd.getDate().getMonth());
  355.                 writeValue(cpfWriter, I2, dtcEnd.getDate().getDay());
  356.                 writeValue(cpfWriter, I2, dtcEnd.getTime().getHour());
  357.                 writeValue(cpfWriter, I2, dtcEnd.getTime().getMinute());
  358.                 writeValue(cpfWriter, I2, (int)  dtcEnd.getTime().getSecond());

  360.                 // write last keys
  361.                 writeValue(cpfWriter, I5, cpfHeader.getStep());
  362.                 writeValue(cpfWriter, I1, cpfHeader.isCompatibleWithTIVs());
  363.                 writeValue(cpfWriter, I1, cpfHeader.getTargetClass());
  364.                 writeValue(cpfWriter, I2, cpfHeader.getRefFrameId());
  365.                 writeValue(cpfWriter, I1, cpfHeader.getRotationalAngleType());
  366.                 writeValue(cpfWriter, I1, cpfHeader.isCenterOfMassCorrectionApplied());
  367.                 if (cpfHeader.getVersion() == 2) {
  368.                     writeValue(cpfWriter, I1, cpfHeader.getTargetLocation());
  369.                 }

  371.             }

  373.         };

  375.         /** Identifier. */
  376.         private final String identifier;

  378.         /** Simple constructor.
  379.          * @param identifier regular expression for identifying line (i.e. first element)
  380.          */
  381.         HeaderLineWriter(final String identifier) {
  382.             this.identifier = identifier;
  383.         }

  385.         /** Write a line.
  386.          * @param cpfHeader container for header data
  387.          * @param cpfWriter writer
  388.          * @param utc utc time scale for dates
  389.          * @throws IOException
  390.          *             if any buffer writing operations fail or if the underlying
  391.          *             format doesn't support a configuration in the file
  392.          */
  393.         public abstract void write(CPFHeader cpfHeader, Appendable cpfWriter, TimeScale utc)  throws IOException;

  395.         /**
  396.          * Get the regular expression for identifying line.
  397.          * @return the regular expression for identifying line
  398.          */
  399.         public String getIdentifier() {
  400.             return identifier;
  401.         }

  403.     }

  405. }
Created with JaCoCo 0.8.6.202009150832