OrekitEphemerisFile.java

  1. /* Copyright 2016 Applied Defense Solutions (ADS)
  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.  * ADS 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.general;

  19. import java.util.ArrayList;
  20. import java.util.Collections;
  21. import java.util.List;
  22. import java.util.Map;
  23. import java.util.concurrent.ConcurrentHashMap;

  25. import org.orekit.annotation.DefaultDataContext;
  26. import org.orekit.bodies.CelestialBody;
  27. import org.orekit.data.DataContext;
  28. import org.orekit.errors.OrekitIllegalArgumentException;
  29. import org.orekit.errors.OrekitMessages;
  30. import org.orekit.frames.Frame;
  31. import org.orekit.propagation.SpacecraftState;
  32. import org.orekit.time.AbsoluteDate;
  33. import org.orekit.time.TimeScale;
  34. import org.orekit.utils.CartesianDerivativesFilter;
  35. import org.orekit.utils.TimeStampedPVCoordinates;

  37. /**
  38.  * A class for encapsulating Orekit propagators within an {@link EphemerisFile}
  39.  * complaint object that makes for easy serialization to external ephemeris
  40.  * formats like OEM.
  41.  *
  42.  * @author Hank Grabowski
  43.  * @since 9.0
  44.  *
  45.  */
  46. public class OrekitEphemerisFile implements EphemerisFile {

  48.     /** Hashmap of satellite ephemeris. **/
  49.     private final Map<String, OrekitSatelliteEphemeris> satellites;

  51.     /**
  52.      * Standard default constructor.
  53.      */
  54.     public OrekitEphemerisFile() {
  55.         this.satellites = new ConcurrentHashMap<String, OrekitSatelliteEphemeris>();
  56.     }

  58.     /** {@inheritDoc} */
  59.     @Override
  60.     public Map<String, OrekitSatelliteEphemeris> getSatellites() {
  61.         return Collections.unmodifiableMap(satellites);
  62.     }

  64.     /**
  65.      * Adds a new satellite to this object.
  66.      *
  67.      * @param id
  68.      *            ID to use for this satellite
  69.      * @return the new satellite object
  70.      */
  71.     public OrekitSatelliteEphemeris addSatellite(final String id) {
  72.         final OrekitSatelliteEphemeris newSat = new OrekitSatelliteEphemeris(id);
  73.         this.satellites.put(id, newSat);
  74.         return newSat;
  75.     }

  77.     /**
  78.      * Inner class of {@link OrekitEphemerisFile} that defines the
  79.      * {@link OrekitSatelliteEphemeris} corresponding object for this ephemeris type.
  80.      */
  81.     public static class OrekitSatelliteEphemeris implements SatelliteEphemeris {

  83.         /**
  84.          * Defines the default interpolation sample size if it is not specified
  85.          * on a segment.
  86.          **/
  87.         public static final int DEFAULT_INTERPOLATION_SIZE = 7; // TODO change default interpolation size to 2 in 11.0 to be consistent with default interpolation degree in OEMParser

  89.         /** ID of the space object encapsulated here. **/
  90.         private final String id;

  92.         /** Earliest date of this file. **/
  93.         private AbsoluteDate startDate;

  95.         /** Latest date of this file. **/
  96.         private AbsoluteDate stopDate;

  98.         /** List of segments in the file. **/
  99.         private final List<OrekitEphemerisSegment> segments;

  101.         /**
  102.          * Standard constructor for building the satellite Ephemeris object.
  103.          *
  104.          * @param id
  105.          *            the ID of the space object for this data
  106.          */
  107.         public OrekitSatelliteEphemeris(final String id) {
  108.             this.id = id;
  109.             this.segments = new ArrayList<OrekitEphemerisSegment>();
  110.         }

  112.         /** {@inheritDoc} */
  113.         @Override
  114.         public String getId() {
  115.             return id;
  116.         }

  118.         /** {@inheritDoc} */
  119.         @Override
  120.         public double getMu() {
  121.             if (this.segments.size() == 0) {
  122.                 return 0;
  123.             } else {
  124.                 return this.segments.get(0).getMu();
  125.             }
  126.         }

  128.         /** {@inheritDoc} */
  129.         @Override
  130.         public List<? extends EphemerisSegment> getSegments() {
  131.             return Collections.unmodifiableList(this.segments);
  132.         }

  134.         /** {@inheritDoc} */
  135.         @Override
  136.         public AbsoluteDate getStart() {
  137.             return this.startDate;
  138.         }

  140.         /** {@inheritDoc} */
  141.         @Override
  142.         public AbsoluteDate getStop() {
  143.             return this.stopDate;
  144.         }

  146.         /**
  147.          * Injects pre-computed satellite states into this ephemeris file
  148.          * object, returning the generated {@link OrekitEphemerisSegment} that
  149.          * has been stored internally. Defaults the celestial body to earth and
  150.          * the interpolation size to the default.
  151.          *
  152.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  153.          *
  154.          * @param states
  155.          *            a list of {@link SpacecraftState} that will comprise this
  156.          *            new unit.
  157.          * @return the generated {@link OrekitEphemerisSegment}
  158.          * @see #addNewSegment(List, CelestialBody, int, TimeScale)
  159.          */
  160.         @DefaultDataContext
  161.         public OrekitEphemerisSegment addNewSegment(final List<SpacecraftState> states) {
  162.             return this.addNewSegment(states, DEFAULT_INTERPOLATION_SIZE);
  163.         }

  165.         /**
  166.          * Injects pre-computed satellite states into this ephemeris file
  167.          * object, returning the generated {@link OrekitEphemerisSegment} that
  168.          * has been stored internally. Defaults the Celestial Body to be Earths
  169.          *
  170.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  171.          *
  172.          * @param states
  173.          *            a list of {@link SpacecraftState} that will comprise this
  174.          *            new unit.
  175.          * @param interpolationSampleSize
  176.          *            the number of interpolation samples that should be used
  177.          *            when processed by another system
  178.          * @return the generated {@link OrekitEphemerisSegment}
  179.          * @see #addNewSegment(List, CelestialBody, int, TimeScale)
  180.          */
  181.         @DefaultDataContext
  182.         public OrekitEphemerisSegment addNewSegment(final List<SpacecraftState> states,
  183.                 final int interpolationSampleSize) {
  184.             return this.addNewSegment(
  185.                     states,
  186.                     DataContext.getDefault().getCelestialBodies().getEarth(),
  187.                     interpolationSampleSize);
  188.         }

  190.         /**
  191.          * Injects pre-computed satellite states into this ephemeris file
  192.          * object, returning the generated {@link OrekitEphemerisSegment} that
  193.          * has been stored internally.
  194.          *
  195.          * <p>This method uses the {@link DataContext#getDefault() default data context}.
  196.          *
  197.          * @param states
  198.          *            a list of {@link SpacecraftState} that will comprise this
  199.          *            new unit.
  200.          * @param body
  201.          *            the celestial body the state's frames are with respect to
  202.          * @param interpolationSampleSize
  203.          *            the number of interpolation samples that should be used
  204.          *            when processed by another system
  205.          * @return the generated {@link OrekitEphemerisSegment}
  206.          * @see #addNewSegment(List, CelestialBody, int, TimeScale)
  207.          */
  208.         @DefaultDataContext
  209.         public OrekitEphemerisSegment addNewSegment(final List<SpacecraftState> states, final CelestialBody body,
  210.                                                     final int interpolationSampleSize) {
  211.             return addNewSegment(states, body, interpolationSampleSize,
  212.                     DataContext.getDefault().getTimeScales().getUTC());
  213.         }

  215.         /**
  216.          * Injects pre-computed satellite states into this ephemeris file
  217.          * object, returning the generated {@link OrekitEphemerisSegment} that
  218.          * has been stored internally.
  219.          *
  220.          * @param states
  221.          *            a list of {@link SpacecraftState} that will comprise this
  222.          *            new unit.
  223.          * @param body
  224.          *            the celestial body from which the frames are defined
  225.          * @param interpolationSampleSize
  226.          *            the number of interpolation samples that should be used
  227.          *            when processed by another system
  228.          * @param timeScale
  229.          *            the time scale used in the new segment.
  230.          * @return the generated {@link OrekitEphemerisSegment}
  231.          * @since 10.1
  232.          */
  233.         public OrekitEphemerisSegment addNewSegment(final List<SpacecraftState> states,
  234.                                                     final CelestialBody body,
  235.                                                     final int interpolationSampleSize,
  236.                                                     final TimeScale timeScale) {
  237.             final int minimumSampleSize = 2;
  238.             if (states == null || states.size() == 0) {
  239.                 throw new OrekitIllegalArgumentException(OrekitMessages.NULL_ARGUMENT, "states");
  240.             }

  242.             if (interpolationSampleSize < minimumSampleSize) {
  243.                 throw new OrekitIllegalArgumentException(OrekitMessages.NOT_ENOUGH_DATA_FOR_INTERPOLATION,
  244.                         interpolationSampleSize);
  245.             }

  247.             final AbsoluteDate start = states.get(0).getDate();
  248.             final AbsoluteDate stop = states.get(states.size() - 1).getDate();

  250.             if (this.startDate == null || start.compareTo(this.startDate) < 0) {
  251.                 this.startDate = start;
  252.             }

  254.             if (this.stopDate == null || stop.compareTo(this.stopDate) > 0) {
  255.                 this.stopDate = stop;
  256.             }

  258.             final List<TimeStampedPVCoordinates> coordinates = new ArrayList<TimeStampedPVCoordinates>();
  259.             for (SpacecraftState state : states) {
  260.                 coordinates.add(state.getPVCoordinates());
  261.             }

  263.             final Frame frame = states.get(0).getFrame();

  265.             final OrekitEphemerisSegment newSeg = new OrekitEphemerisSegment(coordinates, frame, body.getName(),
  266.                     body.getGM(), timeScale, interpolationSampleSize);
  267.             this.segments.add(newSeg);

  269.             return newSeg;
  270.         }
  271.     }

  273.     public static class OrekitEphemerisSegment implements EphemerisSegment {

  275.         /** Coordinates for this ephemeris segment. **/
  276.         private final List<TimeStampedPVCoordinates> coordinates;

  278.         /** The reference frame for this ephemeris segment. **/
  279.         private final Frame frame;

  281.         /** The name of the frame center. **/
  282.         private final String frameCenterString;

  284.         /** Standard gravitational parameter for the satellite. **/
  285.         private final double mu;

  287.         /** The time scale identifier, as specified in the ephemeris file. **/
  288.         private final String timeScaleString;

  290.         /** The time scale for this segment. **/
  291.         private final TimeScale timeScale;

  293.         /** The number of interpolation samples. */
  294.         private final int interpolationSamples;

  296.         /**
  297.          * constructor for OrekitEphemerisSegment.
  298.          *
  299.          * @param coordinates
  300.          *            coordinates making up the ephemeris for this segment
  301.          * @param frame
  302.          *            the frame the coordinates are in
  303.          * @param frameCenterString
  304.          *            the name of celestial body the frame is attached to
  305.          * @param mu
  306.          *            the gravitational constant used in force model evaluations
  307.          * @param timeScale
  308.          *            the time scale of these ephemeris points
  309.          * @param interpolationSamples
  310.          *            the number of samples to use during interpolation
  311.          */
  312.         public OrekitEphemerisSegment(final List<TimeStampedPVCoordinates> coordinates, final Frame frame,
  313.                 final String frameCenterString, final double mu, final TimeScale timeScale, final int interpolationSamples) {
  314.             super();
  315.             this.coordinates = coordinates;
  316.             this.frame = frame;
  317.             this.frameCenterString = frameCenterString;
  318.             this.mu = mu;
  319.             this.timeScale = timeScale;
  320.             this.timeScaleString = timeScale.getName();
  321.             this.interpolationSamples = interpolationSamples;
  322.         }

  324.         /** {@inheritDoc} */
  325.         @Override
  326.         public double getMu() {
  327.             return mu;
  328.         }

  330.         /** {@inheritDoc} */
  331.         @Override
  332.         public String getFrameCenterString() {
  333.             return frameCenterString;
  334.         }

  336.         /** {@inheritDoc} */
  337.         @Override
  338.         public String getFrameString() {
  339.             return frame.getName();
  340.         }

  342.         /** {@inheritDoc} */
  343.         @Override
  344.         public Frame getFrame() {
  345.             return frame;
  346.         }

  348.         /** {@inheritDoc} */
  349.         @Override
  350.         public Frame getInertialFrame() {
  351.             return frame;
  352.         }

  354.         /** {@inheritDoc} */
  355.         @Override
  356.         public String getTimeScaleString() {
  357.             return timeScaleString;
  358.         }

  360.         /** {@inheritDoc} */
  361.         @Override
  362.         public TimeScale getTimeScale() {
  363.             return timeScale;
  364.         }

  366.         /** {@inheritDoc} */
  367.         @Override
  368.         public int getInterpolationSamples() {
  369.             return interpolationSamples;
  370.         }

  372.         /** {@inheritDoc} */
  373.         @Override
  374.         public CartesianDerivativesFilter getAvailableDerivatives() {
  375.             return CartesianDerivativesFilter.USE_PV;
  376.         }

  378.         /** {@inheritDoc} */
  379.         @Override
  380.         public List<TimeStampedPVCoordinates> getCoordinates() {
  381.             return Collections.unmodifiableList(coordinates);
  382.         }

  384.         /** {@inheritDoc} */
  385.         @Override
  386.         public AbsoluteDate getStart() {
  387.             return coordinates.get(0).getDate();
  388.         }

  390.         /** {@inheritDoc} */
  391.         @Override
  392.         public AbsoluteDate getStop() {
  393.             return coordinates.get(coordinates.size() - 1).getDate();
  394.         }

  396.     }
  397. }
Created with JaCoCo 0.8.6.202009150832