StreamingOemWriter.java

  1. /* Contributed in the public domain.
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.files.ccsds;

  19. import java.io.IOException;
  20. import java.text.DecimalFormat;
  21. import java.text.DecimalFormatSymbols;
  22. import java.util.Arrays;
  23. import java.util.Date;
  24. import java.util.LinkedHashMap;
  25. import java.util.Locale;
  26. import java.util.Map;

  28. import org.hipparchus.exception.LocalizedCoreFormats;
  29. import org.orekit.bodies.CelestialBodyFactory;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.frames.FactoryManagedFrame;
  32. import org.orekit.frames.Frame;
  33. import org.orekit.frames.Predefined;
  34. import org.orekit.frames.VersionedITRF;
  35. import org.orekit.propagation.Propagator;
  36. import org.orekit.propagation.SpacecraftState;
  37. import org.orekit.propagation.sampling.OrekitFixedStepHandler;
  38. import org.orekit.time.AbsoluteDate;
  39. import org.orekit.time.DateTimeComponents;
  40. import org.orekit.time.TimeComponents;
  41. import org.orekit.time.TimeScale;
  42. import org.orekit.time.TimeScalesFactory;
  43. import org.orekit.utils.TimeStampedPVCoordinates;

  45. /**
  46.  * A writer for OEM files.
  47.  *
  48.  * <p> Each instance corresponds to a single OEM file. A new OEM ephemeris segment is
  49.  * started by calling {@link #newSegment(Frame, Map)}.
  50.  *
  51.  * <h3> Metadata </h3>
  52.  *
  53.  * <p> The OEM metadata used by this writer is described in the following table. Many
  54.  * metadata items are optional or have default values so they do not need to be specified.
  55.  * At a minimum the user must supply those values that are required and for which no
  56.  * default exits: {@link Keyword#OBJECT_NAME}, and {@link Keyword#OBJECT_ID}. The usage
  57.  * column in the table indicates where the metadata item is used, either in the OEM header
  58.  * or in the metadata section at the start of an OEM ephemeris segment.
  59.  *
  60.  * <p> The OEM metadata for the whole OEM file is set in the {@link
  61.  * #StreamingOemWriter(Appendable, TimeScale, Map) constructor}. Any of the metadata may
  62.  * be overridden for a particular segment using the {@code metadata} argument to {@link
  63.  * #newSegment(Frame, Map)}.
  64.  *
  65.  * <table>
  66.  *     <thead>
  67.  *         <tr>
  68.  *             <th>Keyword
  69.  *             <th>Usage
  70.  *             <th>Obligatory
  71.  *             <th>Default
  72.  *             <th>Reference
  73.  *    </thead>
  74.  *    <tbody>
  75.  *        <tr>
  76.  *            <td>{@link Keyword#CCSDS_OEM_VERS}
  77.  *            <td>Header
  78.  *            <td>Yes
  79.  *            <td>{@link #CCSDS_OEM_VERS}
  80.  *            <td>Table 5-2
  81.  *        <tr>
  82.  *            <td>{@link Keyword#COMMENT}
  83.  *            <td>Header
  84.  *            <td>No
  85.  *            <td>
  86.  *            <td>Table 5-2
  87.  *        <tr>
  88.  *            <td>{@link Keyword#CREATION_DATE}
  89.  *            <td>Header
  90.  *            <td>Yes
  91.  *            <td>{@link Date#Date() Now}
  92.  *            <td>Table 5.2, 6.5.9
  93.  *        <tr>
  94.  *            <td>{@link Keyword#ORIGINATOR}
  95.  *            <td>Header
  96.  *            <td>Yes
  97.  *            <td>{@link #DEFAULT_ORIGINATOR}
  98.  *            <td>Table 5-2
  99.  *        <tr>
  100.  *            <td>{@link Keyword#OBJECT_NAME}
  101.  *            <td>Segment
  102.  *            <td>Yes
  103.  *            <td>
  104.  *            <td>Table 5-3
  105.  *        <tr>
  106.  *            <td>{@link Keyword#OBJECT_ID}
  107.  *            <td>Segment
  108.  *            <td>Yes
  109.  *            <td>
  110.  *            <td>Table 5-3
  111.  *        <tr>
  112.  *            <td>{@link Keyword#CENTER_NAME}
  113.  *            <td>Segment
  114.  *            <td>Yes
  115.  *            <td>Guessed from the {@link #newSegment(Frame, Map) segment}'s {@code frame}
  116.  *            <td>Table 5-3
  117.  *        <tr>
  118.  *            <td>{@link Keyword#REF_FRAME}
  119.  *            <td>Segment
  120.  *            <td>Yes
  121.  *            <td>Guessed from the {@link #newSegment(Frame, Map) segment}'s {@code frame}
  122.  *            <td>Table 5-3, Annex A
  123.  *        <tr>
  124.  *            <td>{@link Keyword#REF_FRAME_EPOCH}
  125.  *            <td>Segment
  126.  *            <td>No
  127.  *            <td>
  128.  *            <td>Table 5-3, 6.5.9
  129.  *        <tr>
  130.  *            <td>{@link Keyword#TIME_SYSTEM}
  131.  *            <td>Segment
  132.  *            <td>Yes
  133.  *            <td>Guessed from {@code timeScale} set in the
  134.  *                {@link #StreamingOemWriter(Appendable, TimeScale, Map) constructor}.
  135.  *            <td>Table 5-3, Annex A
  136.  *        <tr>
  137.  *            <td>{@link Keyword#START_TIME}
  138.  *            <td>Segment
  139.  *            <td>Yes
  140.  *            <td>Date of initial state in {@link Segment#init(SpacecraftState,
  141.  *                AbsoluteDate, double) Segment.init(...)}
  142.  *            <td>Table 5-3, 6.5.9
  143.  *        <tr>
  144.  *            <td>{@link Keyword#USEABLE_START_TIME}
  145.  *            <td>Segment
  146.  *            <td>No
  147.  *            <td>
  148.  *            <td>Table 5-3, 6.5.9
  149.  *        <tr>
  150.  *            <td>{@link Keyword#STOP_TIME}
  151.  *            <td>Segment
  152.  *            <td>Yes
  153.  *            <td>Target date in {@link Segment#init(SpacecraftState,
  154.  *                AbsoluteDate, double) Segment.init(...)}
  155.  *            <td>Table 5-3, 6.5.9
  156.  *        <tr>
  157.  *            <td>{@link Keyword#USEABLE_STOP_TIME}
  158.  *            <td>Segment
  159.  *            <td>No
  160.  *            <td>
  161.  *            <td>Table 5-3, 6.5.9
  162.  *        <tr>
  163.  *            <td>{@link Keyword#INTERPOLATION}
  164.  *            <td>Segment
  165.  *            <td>No
  166.  *            <td>
  167.  *            <td>Table 5-3
  168.  *        <tr>
  169.  *            <td>{@link Keyword#INTERPOLATION_DEGREE}
  170.  *            <td>Segment
  171.  *            <td>No
  172.  *            <td>
  173.  *            <td>Table 5-3
  174.  *    </tbody>
  175.  *</table>
  176.  *
  177.  * <p> The {@link Keyword#TIME_SYSTEM} must be constant for the whole file and is used
  178.  * to interpret all dates except {@link Keyword#CREATION_DATE}. The guessing algorithm
  179.  * is not guaranteed to work so it is recommended to provide values for {@link
  180.  * Keyword#CENTER_NAME}, {@link Keyword#REF_FRAME}, and {@link Keyword#TIME_SYSTEM} to
  181.  * avoid any bugs associated with incorrect guesses.
  182.  *
  183.  * <p> Standardized values for {@link Keyword#TIME_SYSTEM} are GMST, GPS, ME, MRT, SCLK,
  184.  * TAI, TCB, TDB, TCG, TT, UT1, and UTC. Standardized values for {@link Keyword#REF_FRAME}
  185.  * are EME2000, GCRF, GRC, ICRF, ITRF2000, ITRF-93, ITRF-97, MCI, TDR, TEME, and TOD.
  186.  * Additionally ITRF followed by a four digit year may be used.
  187.  *
  188.  * <h3> Examples </h3>
  189.  *
  190.  * <p> This class can be used as a step handler for a {@link Propagator}, or on its own.
  191.  * Either way the object name and ID must be specified. The following example shows its
  192.  * use as a step handler.
  193.  *
  194.  * <pre>{@code
  195.  * Propagator propagator = ...; // pre-configured propagator
  196.  * Appendable out = ...; // set-up output stream
  197.  * Map<Keyword, String> metadata = new LinkedHashMap<>();
  198.  * metadata.put(Keyword.OBJECT_NAME, "Vanguard");
  199.  * metadata.put(Keyword.OBJECT_ID, "1958-002B");
  200.  * StreamingOemWriter writer = new StreamingOemWriter(out, utc, metadata);
  201.  * writer.writeHeader();
  202.  * Segment segment = writer.newSegment(frame, Collections.emptyMap());
  203.  * propagator.setMasterMode(step, segment);
  204.  * propagator.propagate(startDate, stopDate);
  205.  * }</pre>
  206.  *
  207.  * Alternatively a collection of state vectors can be written without the use of a
  208.  * Propagator. In this case the {@link Keyword#START_TIME} and {@link Keyword#STOP_TIME}
  209.  * need to be specified as part of the metadata.
  210.  *
  211.  * <pre>{@code
  212.  * List<TimeStampedPVCoordinates> states = ...; // pre-generated states
  213.  * Appendable out = ...; // set-up output stream
  214.  * Map<Keyword, String> metadata = new LinkedHashMap<>();
  215.  * metadata.put(Keyword.OBJECT_NAME, "Vanguard");
  216.  * metadata.put(Keyword.OBJECT_ID, "1958-002B");
  217.  * StreamingOemWriter writer = new StreamingOemWriter(out, utc, metadata);
  218.  * writer.writeHeader();
  219.  * // manually set start and stop times for this segment
  220.  * Map<Keyword, String> segmentData = new LinkedHashMap<>();
  221.  * segmentData.put(Keyword.START_TIME, start.toString());
  222.  * segmentData.put(Keyword.STOP_TIME, stop.toString());
  223.  * Segment segment = writer.newSegment(frame, segmentData);
  224.  * segment.writeMetadata(); // output metadata block
  225.  * for (TimeStampedPVCoordinates state : states) {
  226.  *     segment.writeEphemerisLine(state);
  227.  * }
  228.  * }</pre>
  229.  *
  230.  * @author Evan Ward
  231.  * @see <a href="https://public.ccsds.org/Pubs/502x0b2c1.pdf">CCSDS 502.0-B-2 Orbit Data
  232.  *      Messages</a>
  233.  * @see <a href="https://public.ccsds.org/Pubs/500x0g3.pdf">CCSDS 500.0-G-3 Navigation
  234.  *      Data Definitions and Conventions</a>
  235.  * @see OEMWriter
  236.  */
  237. public class StreamingOemWriter {

  239.     /** Version number implemented. **/
  240.     public static final String CCSDS_OEM_VERS = "2.0";
  241.     /** Default value for {@link Keyword#ORIGINATOR}. */
  242.     public static final String DEFAULT_ORIGINATOR = "OREKIT";

  244.     /** New line separator for output file. See 6.3.6. */
  245.     private static final String NEW_LINE = "\n";
  246.     /**
  247.      * Standardized locale to use, to ensure files can be exchanged without
  248.      * internationalization issues.
  249.      */
  250.     private static final Locale STANDARDIZED_LOCALE = Locale.US;
  251.     /** String format used for all key/value pair lines. **/
  252.     private static final String KV_FORMAT = "%s = %s%n";
  253.     /** Factor for converting meters to km. */
  254.     private static final double M_TO_KM = 1e-3;
  255.     /** Suffix of the name of the inertial frame attached to a planet. */
  256.     private static final String INERTIAL_FRAME_SUFFIX = "/inertial";

  258.     /** Output stream. */
  259.     private final Appendable writer;
  260.     /** Metadata for this OEM file. */
  261.     private final Map<Keyword, String> metadata;
  262.     /** Time scale for all dates except {@link Keyword#CREATION_DATE}. */
  263.     private final TimeScale timeScale;

  265.     /**
  266.      * Create an OEM writer than streams data to the given output stream.
  267.      *
  268.      * @param writer    The output stream for the OEM file. Most methods will append data
  269.      *                  to this {@code writer}.
  270.      * @param timeScale for all times in the OEM except {@link Keyword#CREATION_DATE}. See
  271.      *                  Section 5.2.4.5 and Annex A.
  272.      * @param metadata  for the satellite. Can be overridden in {@link #newSegment(Frame,
  273.      *                  Map)} for a specific segment. See {@link StreamingOemWriter}.
  274.      */
  275.     public StreamingOemWriter(final Appendable writer,
  276.                               final TimeScale timeScale,
  277.                               final Map<Keyword, String> metadata) {

  279.         this.writer = writer;
  280.         this.timeScale = timeScale;
  281.         this.metadata = new LinkedHashMap<>(metadata);
  282.         // set default metadata
  283.         this.metadata.putIfAbsent(Keyword.CCSDS_OEM_VERS, CCSDS_OEM_VERS);
  284.         this.metadata.putIfAbsent(Keyword.CREATION_DATE,
  285.                 new AbsoluteDate(new Date(), TimeScalesFactory.getUTC()).toString());
  286.         this.metadata.putIfAbsent(Keyword.ORIGINATOR, DEFAULT_ORIGINATOR);
  287.         this.metadata.putIfAbsent(Keyword.TIME_SYSTEM, timeScale.getName());
  288.     }

  290.     /**
  291.      * Guesses names from Table 5-3 and Annex A.
  292.      *
  293.      * <p> The goal of this method is to perform the opposite mapping of {@link
  294.      * CCSDSFrame}.
  295.      *
  296.      * @param frame a reference frame for ephemeris output.
  297.      * @return the string to use in the OEM file to identify {@code frame}.
  298.      */
  299.     static String guessFrame(final Frame frame) {
  300.         // define some constant strings to make checkstyle happy
  301.         final String tod = "TOD";
  302.         final String itrf = "ITRF";
  303.         // Try to determine the CCSDS name from Annex A by examining the Orekit name.
  304.         final String name = frame.getName();
  305.         if (Arrays.stream(CCSDSFrame.values())
  306.                 .map(CCSDSFrame::name)
  307.                 .anyMatch(name::equals)) {
  308.             // should handle J2000, GCRF, TEME, and some frames created by OEMParser.
  309.             return name;
  310.         } else if (frame instanceof CcsdsModifiedFrame) {
  311.             return ((CcsdsModifiedFrame) frame).getRefFrame();
  312.         } else if ((CelestialBodyFactory.MARS + INERTIAL_FRAME_SUFFIX).equals(name)) {
  313.             return "MCI";
  314.         } else if ((CelestialBodyFactory.SOLAR_SYSTEM_BARYCENTER + INERTIAL_FRAME_SUFFIX)
  315.                 .equals(name)) {
  316.             return "ICRF";
  317.         } else if (name.contains("GTOD")) {
  318.             return "TDR";
  319.         } else if (name.contains(tod)) { // check after GTOD
  320.             return tod;
  321.         } else if (name.contains("Equinox") && name.contains(itrf)) {
  322.             return "GRC";
  323.         } else if (frame instanceof VersionedITRF) {
  324.             return ((VersionedITRF) frame).getITRFVersion().getName().replace("-", "");
  325.         } else if (name.contains("CIO") && name.contains(itrf)) {
  326.             return "ITRF2014";
  327.         } else {
  328.             // don't know how to map it to a CCSDS reference frame
  329.             return name;
  330.         }
  331.     }

  333.     /**
  334.      * Guess the name of the center of the reference frame.
  335.      *
  336.      * @param frame a reference frame for ephemeris output.
  337.      * @return the string to use in the OEM file to describe the origin of {@code frame}.
  338.      */
  339.     static String guessCenter(final Frame frame) {
  340.         final String name = frame.getName();
  341.         if (name.endsWith(INERTIAL_FRAME_SUFFIX) || name.endsWith("/rotating")) {
  342.             return name.substring(0, name.length() - 9).toUpperCase(STANDARDIZED_LOCALE);
  343.         } else if (frame instanceof CcsdsModifiedFrame) {
  344.             return ((CcsdsModifiedFrame) frame).getCenterName();
  345.         } else if (frame.getName().equals(Predefined.ICRF.getName())) {
  346.             return CelestialBodyFactory.SOLAR_SYSTEM_BARYCENTER.toUpperCase(STANDARDIZED_LOCALE);
  347.         } else if (frame.getDepth() == 0 || frame instanceof FactoryManagedFrame) {
  348.             return "EARTH";
  349.         } else {
  350.             return "UNKNOWN";
  351.         }
  352.     }

  354.     /**
  355.      * Write a single key and value to the stream using Key Value Notation (KVN).
  356.      *
  357.      * @param key   the keyword to write
  358.      * @param value the value to write
  359.      * @throws IOException if an I/O error occurs.
  360.      */
  361.     private void writeKeyValue(final Keyword key, final String value) throws IOException {
  362.         writer.append(String.format(STANDARDIZED_LOCALE, KV_FORMAT, key.toString(), value));
  363.     }

  365.     /**
  366.      * Writes the standard OEM header for the file.
  367.      *
  368.      * @throws IOException if the stream cannot write to stream
  369.      */
  370.     public void writeHeader() throws IOException {
  371.         writeKeyValue(Keyword.CCSDS_OEM_VERS, this.metadata.get(Keyword.CCSDS_OEM_VERS));
  372.         final String comment = this.metadata.get(Keyword.COMMENT);
  373.         if (comment != null) {
  374.             writeKeyValue(Keyword.COMMENT, comment);
  375.         }
  376.         writeKeyValue(Keyword.CREATION_DATE, this.metadata.get(Keyword.CREATION_DATE));
  377.         writeKeyValue(Keyword.ORIGINATOR, this.metadata.get(Keyword.ORIGINATOR));
  378.         writer.append(NEW_LINE);
  379.     }

  381.     /**
  382.      * Create a writer for a new OEM ephemeris segment.
  383.      *
  384.      * <p> The returned writer can only write a single ephemeris segment in an OEM. This
  385.      * method must be called to create a writer for each ephemeris segment.
  386.      *
  387.      * @param frame           the reference frame to use for the segment. If this value is
  388.      *                        {@code null} then {@link Segment#handleStep(SpacecraftState,
  389.      *                        boolean)} will throw a {@link NullPointerException} and the
  390.      *                        metadata item {@link Keyword#REF_FRAME} must be specified in
  391.      *                        the metadata.
  392.      * @param segmentMetadata the metadata to use for the segment. Overrides for this
  393.      *                        segment any other source of meta data values. See {@link
  394.      *                        #StreamingOemWriter} for a description of which metadata are
  395.      *                        required and how they are determined.
  396.      * @return a new OEM segment, ready for writing.
  397.      */
  398.     public Segment newSegment(final Frame frame,
  399.                               final Map<Keyword, String> segmentMetadata) {
  400.         final Map<Keyword, String> meta = new LinkedHashMap<>(this.metadata);
  401.         meta.putAll(segmentMetadata);
  402.         if (!meta.containsKey(Keyword.REF_FRAME)) {
  403.             meta.put(Keyword.REF_FRAME, guessFrame(frame));
  404.         }
  405.         if (!meta.containsKey(Keyword.CENTER_NAME)) {
  406.             meta.put(Keyword.CENTER_NAME, guessCenter(frame));
  407.         }
  408.         return new Segment(frame, meta);
  409.     }

  411.     /** A writer for a segment of an OEM. */
  412.     public class Segment implements OrekitFixedStepHandler {

  414.         /** Reference frame of the output states. */
  415.         private final Frame frame;
  416.         /** Metadata for this OEM Segment. */
  417.         private final Map<Keyword, String> metadata;

  419.         /**
  420.          * Create a new segment writer.
  421.          *
  422.          * @param frame    for the output states. Used by {@link #handleStep(SpacecraftState,
  423.          *                 boolean)}.
  424.          * @param metadata to use when writing this segment.
  425.          */
  426.         private Segment(final Frame frame, final Map<Keyword, String> metadata) {
  427.             this.frame = frame;
  428.             this.metadata = metadata;
  429.         }

  431.         /**
  432.          * Write the ephemeris segment metadata.
  433.          *
  434.          * <p> See {@link StreamingOemWriter} for a description of how the metadata is
  435.          * set.
  436.          *
  437.          * @throws IOException if the output stream throws one while writing.
  438.          */
  439.         public void writeMetadata() throws IOException {
  440.             writer.append("META_START").append(NEW_LINE);
  441.             if (this.frame != null) {
  442.                 writer.append("COMMENT ").append("Orekit frame: ")
  443.                         .append(this.frame.toString()).append(NEW_LINE);
  444.             }
  445.             // Table 5.3
  446.             writeKeyValue(Keyword.OBJECT_NAME, this.metadata.get(Keyword.OBJECT_NAME));
  447.             writeKeyValue(Keyword.OBJECT_ID, this.metadata.get(Keyword.OBJECT_ID));
  448.             writeKeyValue(Keyword.CENTER_NAME, this.metadata.get(Keyword.CENTER_NAME));
  449.             writeKeyValue(Keyword.REF_FRAME, this.metadata.get(Keyword.REF_FRAME));
  450.             final String refFrameEpoch = this.metadata.get(Keyword.REF_FRAME_EPOCH);
  451.             if (refFrameEpoch != null) {
  452.                 writeKeyValue(Keyword.REF_FRAME_EPOCH, refFrameEpoch);
  453.             }
  454.             writeKeyValue(Keyword.TIME_SYSTEM, this.metadata.get(Keyword.TIME_SYSTEM));
  455.             writeKeyValue(Keyword.START_TIME, this.metadata.get(Keyword.START_TIME));
  456.             final String usableStartTime = this.metadata.get(Keyword.USEABLE_START_TIME);
  457.             if (usableStartTime != null) {
  458.                 writeKeyValue(Keyword.USEABLE_START_TIME, usableStartTime);
  459.             }
  460.             writeKeyValue(Keyword.STOP_TIME, this.metadata.get(Keyword.STOP_TIME));
  461.             final String usableStopTime = this.metadata.get(Keyword.USEABLE_STOP_TIME);
  462.             if (usableStopTime != null) {
  463.                 writeKeyValue(Keyword.USEABLE_STOP_TIME, usableStopTime);
  464.             }
  465.             final String interpolation = this.metadata.get(Keyword.INTERPOLATION);
  466.             if (interpolation != null) {
  467.                 writeKeyValue(Keyword.INTERPOLATION, interpolation);
  468.             }
  469.             final String interpolationDegree =
  470.                     this.metadata.get(Keyword.INTERPOLATION_DEGREE);
  471.             if (interpolationDegree != null) {
  472.                 writeKeyValue(Keyword.INTERPOLATION_DEGREE, interpolationDegree);
  473.             }
  474.             writer.append("META_STOP").append(NEW_LINE).append(NEW_LINE);
  475.         }

  477.         /**
  478.          * Write a single ephemeris line according to section 5.2.4. This method does not
  479.          * write the optional acceleration terms.
  480.          *
  481.          * @param pv the time, position, and velocity to write.
  482.          * @throws IOException if the output stream throws one while writing.
  483.          */
  484.         public void writeEphemerisLine(final TimeStampedPVCoordinates pv)
  485.                 throws IOException {
  486.             final String epoch = dateToString(pv.getDate().getComponents(timeScale));
  487.             writer.append(epoch).append(" ");
  488.             // output in km, see Section 6.6.2.1
  489.             writer.append(Double.toString(pv.getPosition().getX() * M_TO_KM)).append(" ");
  490.             writer.append(Double.toString(pv.getPosition().getY() * M_TO_KM)).append(" ");
  491.             writer.append(Double.toString(pv.getPosition().getZ() * M_TO_KM)).append(" ");
  492.             writer.append(Double.toString(pv.getVelocity().getX() * M_TO_KM)).append(" ");
  493.             writer.append(Double.toString(pv.getVelocity().getY() * M_TO_KM)).append(" ");
  494.             writer.append(Double.toString(pv.getVelocity().getZ() * M_TO_KM));
  495.             writer.append(NEW_LINE);
  496.         }

  498.         /**
  499.          * {@inheritDoc}
  500.          *
  501.          * <p> Sets the {@link Keyword#START_TIME} and {@link Keyword#STOP_TIME} in this
  502.          * segment's metadata if not already set by the user. Then calls {@link
  503.          * #writeMetadata()} to start the segment.
  504.          */
  505.         @Override
  506.         public void init(final SpacecraftState s0,
  507.                          final AbsoluteDate t,
  508.                          final double step) {
  509.             try {
  510.                 final String start = dateToString(s0.getDate().getComponents(timeScale));
  511.                 final String stop = dateToString(t.getComponents(timeScale));
  512.                 this.metadata.putIfAbsent(Keyword.START_TIME, start);
  513.                 this.metadata.putIfAbsent(Keyword.STOP_TIME, stop);
  514.                 this.writeMetadata();
  515.             } catch (IOException e) {
  516.                 throw new OrekitException(e, LocalizedCoreFormats.SIMPLE_MESSAGE,
  517.                         e.getLocalizedMessage());
  518.             }
  519.         }

  521.         @Override
  522.         public void handleStep(final SpacecraftState s,
  523.                                final boolean isLast) {
  524.             try {
  525.                 writeEphemerisLine(s.getPVCoordinates(this.frame));
  526.             } catch (IOException e) {
  527.                 throw new OrekitException(e, LocalizedCoreFormats.SIMPLE_MESSAGE,
  528.                         e.getLocalizedMessage());
  529.             }

  531.         }

  533.     }

  535.     /**
  536.      * Convert a date to a string with more precision.
  537.      *
  538.      * @param components to convert to a String.
  539.      * @return the String form of {@code date} with at least 9 digits of precision.
  540.      */
  541.     static String dateToString(final DateTimeComponents components) {
  542.         final TimeComponents time = components.getTime();
  543.         final int hour = time.getHour();
  544.         final int minute = time.getMinute();
  545.         final double second = time.getSecond();
  546.         // Decimal formatting classes could be static final if they were thread safe.
  547.         final DecimalFormatSymbols locale = new DecimalFormatSymbols(STANDARDIZED_LOCALE);
  548.         final DecimalFormat twoDigits = new DecimalFormat("00", locale);
  549.         final DecimalFormat precise = new DecimalFormat("00.0########", locale);
  550.         return components.getDate().toString() + "T" + twoDigits.format(hour) + ":" +
  551.                 twoDigits.format(minute) + ":" + precise.format(second);
  552.     }

  554. }
Created with JaCoCo 0.8.2.201808211720