AEMWriter.java

  1. /* Copyright 2002-2020 CS GROUP
  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.ccsds;

  19. import java.io.BufferedWriter;
  20. import java.io.IOException;
  21. import java.nio.charset.StandardCharsets;
  22. import java.nio.file.Files;
  23. import java.nio.file.Paths;
  24. import java.util.LinkedHashMap;
  25. import java.util.List;
  26. import java.util.Map;

  28. import org.orekit.errors.OrekitIllegalArgumentException;
  29. import org.orekit.errors.OrekitMessages;
  30. import org.orekit.files.ccsds.StreamingAemWriter.AEMSegment;
  31. import org.orekit.files.general.AttitudeEphemerisFile;
  32. import org.orekit.files.general.AttitudeEphemerisFile.SatelliteAttitudeEphemeris;
  33. import org.orekit.files.general.AttitudeEphemerisFile.AttitudeEphemerisSegment;
  34. import org.orekit.files.general.AttitudeEphemerisFileWriter;
  35. import org.orekit.time.TimeScale;
  36. import org.orekit.utils.TimeStampedAngularCoordinates;

  38. /**
  39.  * A writer for Attitude Ephemeris Messsage (AEM) files.
  40.  * @author Bryan Cazabonne
  41.  * @since 10.2
  42.  */
  43. public class AEMWriter implements AttitudeEphemerisFileWriter {

  45.     /** Originator name, usually the organization and/or country. **/
  46.     private final String originator;

  48.     /** Space object ID, usually an official international designator such as "1998-067A". */
  49.     private final String spaceObjectId;

  51.     /** Space object name, usually a common name for an object like "ISS". **/
  52.     private final String spaceObjectName;

  54.     /** Format for attitude ephemeris data output. */
  55.     private final String attitudeFormat;

  57.     /**
  58.      * Standard default constructor that creates a writer with default configurations
  59.      * including {@link StreamingAemWriter#DEFAULT_ATTITUDE_FORMAT Default formatting}.
  60.      */
  61.     public AEMWriter() {
  62.         this(StreamingAemWriter.DEFAULT_ORIGINATOR, null, null,
  63.              StreamingAemWriter.DEFAULT_ATTITUDE_FORMAT);
  64.     }

  66.     /**
  67.      * Constructor used to create a new AEM writer configured with the necessary parameters
  68.      * to successfully fill in all required fields that aren't part of a standard object
  69.      * and using {@link StreamingAemWriter#DEFAULT_ATTITUDE_FORMAT default formatting}
  70.      * for attitude ephemeris data output.
  71.      *
  72.      * @param originator the originator field string
  73.      * @param spaceObjectId the spacecraft ID
  74.      * @param spaceObjectName the space object common name
  75.      */
  76.     public AEMWriter(final String originator, final String spaceObjectId,
  77.                      final String spaceObjectName) {
  78.         this(originator, spaceObjectId, spaceObjectName,
  79.              StreamingAemWriter.DEFAULT_ATTITUDE_FORMAT);
  80.     }

  82.     /**
  83.      * Constructor used to create a new AEM writer configured with the necessary
  84.      * parameters to successfully fill in all required fields that aren't part
  85.      * of a standard object and user-defined attitude ephemeris data output format.
  86.      *
  87.      * @param originator the originator field string
  88.      * @param spaceObjectId the spacecraft ID
  89.      * @param spaceObjectName the space object common name
  90.      * @param attitudeFormat {@link java.util.Formatter format parameters} for
  91.      *                       attitude ephemeris data output
  92.      * @since 10.3
  93.      */
  94.     public AEMWriter(final String originator, final String spaceObjectId,
  95.                      final String spaceObjectName, final String attitudeFormat) {
  96.         this.originator          = originator;
  97.         this.spaceObjectId       = spaceObjectId;
  98.         this.spaceObjectName     = spaceObjectName;
  99.         this.attitudeFormat      = attitudeFormat;
  100.     }

  102.     /** {@inheritDoc} */
  103.     @Override
  104.     public void write(final Appendable writer, final AttitudeEphemerisFile ephemerisFile)
  105.         throws IOException {

  107.         if (writer == null) {
  108.             throw new OrekitIllegalArgumentException(OrekitMessages.NULL_ARGUMENT, "writer");
  109.         }

  111.         if (ephemerisFile == null) {
  112.             return;
  113.         }

  115.         final String idToProcess;
  116.         if (spaceObjectId != null) {
  117.             if (ephemerisFile.getSatellites().containsKey(spaceObjectId)) {
  118.                 idToProcess = spaceObjectId;
  119.             } else {
  120.                 throw new OrekitIllegalArgumentException(OrekitMessages.VALUE_NOT_FOUND, spaceObjectId, "ephemerisFile");
  121.             }
  122.         } else if (ephemerisFile.getSatellites().keySet().size() == 1) {
  123.             idToProcess = ephemerisFile.getSatellites().keySet().iterator().next();
  124.         } else {
  125.             throw new OrekitIllegalArgumentException(OrekitMessages.EPHEMERIS_FILE_NO_MULTI_SUPPORT);
  126.         }

  128.         // Get satellite and attitude ephemeris segments to output.
  129.         final SatelliteAttitudeEphemeris satEphem = ephemerisFile.getSatellites().get(idToProcess);
  130.         final List<? extends AttitudeEphemerisSegment> segments = satEphem.getSegments();
  131.         if (segments.isEmpty()) {
  132.             // No data -> No output
  133.             return;
  134.         }
  135.         // First segment
  136.         final AttitudeEphemerisSegment firstSegment = segments.get(0);

  138.         final String objectName = this.spaceObjectName == null ? idToProcess : this.spaceObjectName;
  139.         // Only one time scale per AEM file, see Section 4.2.5.4.2
  140.         final TimeScale timeScale = firstSegment.getTimeScale();
  141.         // Metadata that is constant for the whole AEM file
  142.         final Map<Keyword, String> metadata = new LinkedHashMap<>();
  143.         metadata.put(Keyword.TIME_SYSTEM, firstSegment.getTimeScaleString());
  144.         metadata.put(Keyword.ORIGINATOR,  this.originator);
  145.         // Only one object in an AEM file, see Section 2.3.1
  146.         metadata.put(Keyword.OBJECT_NAME,   objectName);
  147.         metadata.put(Keyword.OBJECT_ID,     idToProcess);

  149.         // Header comments. If header comments are presents, they are assembled together in a single line
  150.         if (ephemerisFile instanceof AEMFile) {
  151.             // Cast to OEMFile
  152.             final AEMFile aemFile = (AEMFile) ephemerisFile;
  153.             if (!aemFile.getHeaderComment().isEmpty()) {
  154.                 // Loop on comments
  155.                 final StringBuffer buffer = new StringBuffer();
  156.                 for (String comment : aemFile.getHeaderComment()) {
  157.                     buffer.append(comment);
  158.                 }
  159.                 // Update metadata
  160.                 metadata.put(Keyword.COMMENT, buffer.toString());
  161.             }
  162.         }

  164.         // Writer for AEM files
  165.         final StreamingAemWriter aemWriter =
  166.                         new StreamingAemWriter(writer, timeScale, metadata, attitudeFormat);
  167.         aemWriter.writeHeader();

  169.         // Loop on segments
  170.         for (final AttitudeEphemerisSegment segment : segments) {
  171.             // Segment specific metadata
  172.             metadata.clear();
  173.             metadata.put(Keyword.CENTER_NAME,          segment.getFrameCenterString());
  174.             metadata.put(Keyword.REF_FRAME_A,          segment.getRefFrameAString());
  175.             metadata.put(Keyword.REF_FRAME_B,          segment.getRefFrameBString());
  176.             metadata.put(Keyword.ATTITUDE_DIR,         segment.getAttitudeDirection());
  177.             metadata.put(Keyword.START_TIME,           segment.getStart().toString(timeScale));
  178.             metadata.put(Keyword.STOP_TIME,            segment.getStop().toString(timeScale));
  179.             metadata.put(Keyword.ATTITUDE_TYPE,        segment.getAttitudeType());
  180.             metadata.put(Keyword.INTERPOLATION_METHOD, segment.getInterpolationMethod());
  181.             metadata.put(Keyword.INTERPOLATION_DEGREE,
  182.                          String.valueOf(segment.getInterpolationSamples() - 1));

  184.             final AEMSegment segmentWriter = aemWriter.newSegment(metadata);
  185.             segmentWriter.writeMetadata();
  186.             segmentWriter.startAttitudeBlock();
  187.             // Loop on attitude data
  188.             for (final TimeStampedAngularCoordinates coordinates : segment.getAngularCoordinates()) {
  189.                 segmentWriter.writeAttitudeEphemerisLine(coordinates, segment.isFirst(),
  190.                                                          segment.getAttitudeType(), segment.getRotationOrder());
  191.             }
  192.             segmentWriter.endAttitudeBlock();
  193.         }

  195.     }

  197.     /**
  198.      * Write the passed in {@link AEMFile} using the passed in {@link Appendable}.
  199.      * @param writer a configured Appendable to feed with text
  200.      * @param aemFile a populated aem file to serialize into the buffer
  201.      * @throws IOException if any buffer writing operations fail or if the underlying
  202.      *         format doesn't support a configuration in the EphemerisFile
  203.      *         for example having multiple satellites in one file, having
  204.      *         the origin at an unspecified celestial body, etc.)
  205.      */
  206.     public void write(final Appendable writer, final AEMFile aemFile) throws IOException {
  207.         write(writer, (AttitudeEphemerisFile) aemFile);
  208.     }

  210.     /**
  211.      * Write the passed in {@link AEMFile} to a file at the output path specified.
  212.      * @param outputFilePath a file path that the corresponding file will be written to
  213.      * @param aemFile a populated aem file to serialize into the buffer
  214.      * @throws IOException if any file writing operations fail or if the underlying
  215.      *         format doesn't support a configuration in the EphemerisFile
  216.      *         (for example having multiple satellites in one file, having
  217.      *         the origin at an unspecified celestial body, etc.)
  218.      */
  219.     public void write(final String outputFilePath, final AEMFile aemFile)
  220.         throws IOException {
  221.         try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(outputFilePath), StandardCharsets.UTF_8)) {
  222.             write(writer, (AttitudeEphemerisFile) aemFile);
  223.         }
  224.     }

  226. }
Created with JaCoCo 0.8.6.202009150832