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.VersionedITRF;
  34. import org.orekit.propagation.Propagator;
  35. import org.orekit.propagation.SpacecraftState;
  36. import org.orekit.propagation.sampling.OrekitFixedStepHandler;
  37. import org.orekit.time.AbsoluteDate;
  38. import org.orekit.time.DateTimeComponents;
  39. import org.orekit.time.TimeComponents;
  40. import org.orekit.time.TimeScale;
  41. import org.orekit.time.TimeScalesFactory;
  42. import org.orekit.utils.TimeStampedPVCoordinates;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  530.         }

  532.     }

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

  553. }
Created with JaCoCo 0.7.9.201702052155