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.AEMFile.AemSatelliteEphemeris;
  31. import org.orekit.files.ccsds.AEMFile.AttitudeEphemeridesBlock;
  32. import org.orekit.files.ccsds.StreamingAemWriter.AEMSegment;
  33. import org.orekit.time.TimeScale;
  34. import org.orekit.utils.TimeStampedAngularCoordinates;

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

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

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

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

  52.     /**
  53.      * Standard default constructor that creates a writer with default
  54.      * configurations.
  55.      */
  56.     public AEMWriter() {
  57.         this(StreamingAemWriter.DEFAULT_ORIGINATOR, null, null);
  58.     }

  60.     /**
  61.      * Constructor used to create a new AEM writer configured with the necessary
  62.      * parameters to successfully fill in all required fields that aren't part
  63.      * of a standard object.
  64.      *
  65.      * @param originator the originator field string
  66.      * @param spaceObjectId the spacecraft ID
  67.      * @param spaceObjectName the space object common name
  68.      */
  69.     public AEMWriter(final String originator, final String spaceObjectId,
  70.                      final String spaceObjectName) {
  71.         this.originator          = originator;
  72.         this.spaceObjectId       = spaceObjectId;
  73.         this.spaceObjectName     = spaceObjectName;
  74.     }

  76.     /**
  77.      * Write the passed in {@link AEMFile} using the passed in {@link Appendable}.
  78.      * @param writer a configured Appendable to feed with text
  79.      * @param aemFile  a populated aem file to serialize into the buffer
  80.      * @throws IOException if any buffer writing operations fail or if the underlying
  81.      *         format doesn't support a configuration in the EphemerisFile
  82.      *         for example having multiple satellites in one file, having
  83.      *         the origin at an unspecified celestial body, etc.)
  84.      */
  85.     public void write(final Appendable writer, final AEMFile aemFile)
  86.         throws IOException {

  88.         if (writer == null) {
  89.             throw new OrekitIllegalArgumentException(OrekitMessages.NULL_ARGUMENT, "writer");
  90.         }

  92.         if (aemFile == null) {
  93.             return;
  94.         }

  96.         final String idToProcess;
  97.         if (spaceObjectId != null) {
  98.             if (aemFile.getSatellites().containsKey(spaceObjectId)) {
  99.                 idToProcess = spaceObjectId;
  100.             } else {
  101.                 throw new OrekitIllegalArgumentException(OrekitMessages.VALUE_NOT_FOUND, spaceObjectId, "ephemerisFile");
  102.             }
  103.         } else if (aemFile.getSatellites().keySet().size() == 1) {
  104.             idToProcess = aemFile.getSatellites().keySet().iterator().next();
  105.         } else {
  106.             throw new OrekitIllegalArgumentException(OrekitMessages.EPHEMERIS_FILE_NO_MULTI_SUPPORT);
  107.         }

  109.         // Get satellite and attitude ephemeris segments to output.
  110.         final AemSatelliteEphemeris          satEphem = aemFile.getSatellites().get(idToProcess);
  111.         final List<AttitudeEphemeridesBlock> segments = satEphem.getSegments();
  112.         if (segments.isEmpty()) {
  113.             // No data -> No output
  114.             return;
  115.         }
  116.         // First segment
  117.         final AttitudeEphemeridesBlock firstSegment = segments.get(0);

  119.         final String objectName = this.spaceObjectName == null ? idToProcess : this.spaceObjectName;
  120.         // Only one time scale per AEM file, see Section 4.2.5.4.2
  121.         final TimeScale timeScale = firstSegment.getTimeScale();
  122.         // Metadata that is constant for the whole AEM file
  123.         final Map<Keyword, String> metadata = new LinkedHashMap<>();
  124.         metadata.put(Keyword.TIME_SYSTEM, firstSegment.getTimeScaleString());
  125.         metadata.put(Keyword.ORIGINATOR,  this.originator);
  126.         // Only one object in an AEM file, see Section 2.3.1
  127.         metadata.put(Keyword.OBJECT_NAME,   objectName);
  128.         metadata.put(Keyword.OBJECT_ID,     idToProcess);
  129.         // Writer for AEM files
  130.         final StreamingAemWriter aemWriter =
  131.                         new StreamingAemWriter(writer, timeScale, metadata);
  132.         aemWriter.writeHeader();

  134.         // Loop on segments
  135.         for (final AttitudeEphemeridesBlock segment : segments) {
  136.             // Segment specific metadata
  137.             metadata.clear();
  138.             metadata.put(Keyword.CENTER_NAME,          segment.getFrameCenterString());
  139.             metadata.put(Keyword.REF_FRAME_A,          segment.getRefFrameAString());
  140.             metadata.put(Keyword.REF_FRAME_B,          segment.getRefFrameBString());
  141.             metadata.put(Keyword.ATTITUDE_DIR,         segment.getAttitudeDirection());
  142.             metadata.put(Keyword.START_TIME,           segment.getStart().toString(timeScale));
  143.             metadata.put(Keyword.STOP_TIME,            segment.getStop().toString(timeScale));
  144.             metadata.put(Keyword.ATTITUDE_TYPE,        segment.getAttitudeType());
  145.             metadata.put(Keyword.INTERPOLATION_METHOD, segment.getInterpolationMethod());
  146.             metadata.put(Keyword.INTERPOLATION_DEGREE, String.valueOf(segment.getInterpolationDegree()));

  148.             final AEMSegment segmentWriter = aemWriter.newSegment(metadata);
  149.             segmentWriter.writeMetadata();
  150.             segmentWriter.startAttitudeBlock();
  151.             // Loop on attitude data
  152.             for (final TimeStampedAngularCoordinates coordinates : segment.getAngularCoordinates()) {
  153.                 segmentWriter.writeAttitudeEphemerisLine(coordinates, segment.isFirst(),
  154.                                                          segment.getAttitudeType(), segment.getRotationOrder());
  155.             }
  156.             segmentWriter.endAttitudeBlock();
  157.         }

  159.     }

  161.     /**
  162.      * Write the passed in {@link AEMFile} to a file at the output path specified.
  163.      * @param outputFilePath a file path that the corresponding file will be written to
  164.      * @param aemFile a populated aem file to serialize into the buffer
  165.      * @throws IOException if any file writing operations fail or if the underlying
  166.      *         format doesn't support a configuration in the EphemerisFile
  167.      *         (for example having multiple satellites in one file, having
  168.      *         the origin at an unspecified celestial body, etc.)
  169.      */
  170.     public void write(final String outputFilePath, final AEMFile aemFile)
  171.         throws IOException {
  172.         try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(outputFilePath), StandardCharsets.UTF_8)) {
  173.             write(writer, aemFile);
  174.         }
  175.     }

  177. }
Created with JaCoCo 0.8.5.201910111838