TrajectoryStateHistoryMetadata.java

  1. /* Copyright 2002-2024 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.  */

  18. package org.orekit.files.ccsds.ndm.odm.ocm;

  20. import java.util.List;

  22. import org.orekit.data.DataContext;
  23. import org.orekit.errors.OrekitException;
  24. import org.orekit.errors.OrekitMessages;
  25. import org.orekit.files.ccsds.definitions.BodyFacade;
  26. import org.orekit.files.ccsds.definitions.CelestialBodyFrame;
  27. import org.orekit.files.ccsds.definitions.FrameFacade;
  28. import org.orekit.files.ccsds.ndm.odm.oem.InterpolationMethod;
  29. import org.orekit.files.ccsds.section.CommentsContainer;
  30. import org.orekit.time.AbsoluteDate;
  31. import org.orekit.utils.units.Unit;

  33. /** Metadata for trajectory state history.
  34.  * @author Luc Maisonobe
  35.  * @since 11.0
  36.  */
  37. public class TrajectoryStateHistoryMetadata extends CommentsContainer {

  39.     /** Default interpolation method.
  40.      * @since 12.0
  41.      */
  42.     public static final InterpolationMethod DEFAULT_INTERPOLATION_METHOD = InterpolationMethod.HERMITE;

  44.     /** Default interpolation degree.
  45.      * @since 12.0
  46.      */
  47.     public static final int DEFAULT_INTERPOLATION_DEGREE = 3;

  49.     /** Trajectory identification number. */
  50.     private String trajID;

  52.     /** Identification number of previous trajectory. */
  53.     private String trajPrevID;

  55.     /** Identification number of next trajectory. */
  56.     private String trajNextID;

  58.     /** Basis of this trajectory state time history data. */
  59.     private String trajBasis;

  61.     /** Identification number of the orbit determination or simulation upon which this trajectory is based. */
  62.     private String trajBasisID;

  64.     /** Interpolation method. */
  65.     private InterpolationMethod interpolationMethod;

  67.     /** Interpolation degree. */
  68.     private int interpolationDegree;

  70.     /** Orbit propagator used to generate this trajectory.
  71.      * @since 11.2
  72.      */
  73.     private String propagator;

  75.     /** Origin of reference frame. */
  76.     private BodyFacade center;

  78.     /** Reference frame of the trajectory. */
  79.     private FrameFacade trajReferenceFrame;

  81.     /** Epoch of the trajectory reference frame. */
  82.     private AbsoluteDate trajFrameEpoch;

  84.     /** Start of useable time span covered by ephemerides data, it may be
  85.      * necessary to allow for proper interpolation. */
  86.     private AbsoluteDate useableStartTime;

  88.     /** End of useable time span covered by ephemerides data, it may be
  89.      * necessary to allow for proper interpolation. */
  90.     private AbsoluteDate useableStopTime;

  92.     /** Integer orbit revolution number. */
  93.     private int orbRevNum;

  95.     /** Basis for orbit revolution counter (i.e is first launch/deployment on orbit 0 or 1). */
  96.     private int orbRevNumBasis;

  98.     /** Trajectory element set type. */
  99.     private OrbitElementsType trajType;

  101.     /** Type of averaging (Osculating, mean Brouwer, other...). */
  102.     private String orbAveraging;

  104.     /** Units of trajectory element set. */
  105.     private List<Unit> trajUnits;

  107.     /** Data context.
  108.      * @since 12.0
  109.      */
  110.     private final DataContext dataContext;

  112.     /** Simple constructor.
  113.      * @param epochT0 T0 epoch from file metadata
  114.      * @param dataContext data context
  115.      */
  116.     public TrajectoryStateHistoryMetadata(final AbsoluteDate epochT0, final DataContext dataContext) {
  117.         // we don't call the setXxx() methods in order to avoid
  118.         // calling refuseFurtherComments as a side effect
  119.         trajBasis           = "PREDICTED";
  120.         interpolationMethod = DEFAULT_INTERPOLATION_METHOD;
  121.         interpolationDegree = DEFAULT_INTERPOLATION_DEGREE;
  122.         orbAveraging        = "OSCULATING";
  123.         center              = new BodyFacade("EARTH",
  124.                                              dataContext.getCelestialBodies().getEarth());
  125.         trajReferenceFrame  = new FrameFacade(dataContext.getFrames().getICRF(),
  126.                                               CelestialBodyFrame.ICRF, null, null,
  127.                                               CelestialBodyFrame.ICRF.name());
  128.         trajFrameEpoch      = epochT0;
  129.         trajType            = OrbitElementsType.CARTPV;
  130.         orbRevNum           = -1;
  131.         orbRevNumBasis      = -1;

  133.         this.dataContext    = dataContext;

  135.     }

  137.     /** {@inheritDoc} */
  138.     @Override
  139.     public void validate(final double version) {
  140.         checkMandatoryEntriesExceptOrbitsCounter(version);
  141.         if (orbRevNum >= 0 && orbRevNumBasis < 0) {
  142.             throw new OrekitException(OrekitMessages.UNINITIALIZED_VALUE_FOR_KEY,
  143.                                       TrajectoryStateHistoryMetadataKey.ORB_REVNUM_BASIS.name());
  144.         }
  145.     }

  147.     /** Check is mandatory entries EXCEPT orbits counters have been initialized.
  148.      * <p>
  149.      * This method should throw an exception if some mandatory entry is missing
  150.      * </p>
  151.      * @param version format version
  152.      */
  153.     private void checkMandatoryEntriesExceptOrbitsCounter(final double version) {
  154.         super.validate(version);
  155.         if (trajType != OrbitElementsType.CARTP   &&
  156.             trajType != OrbitElementsType.CARTPV  &&
  157.             trajType != OrbitElementsType.CARTPVA) {
  158.             checkNotNull(orbAveraging, TrajectoryStateHistoryMetadataKey.ORB_AVERAGING.name());
  159.         }
  160.         if (trajUnits != null) {
  161.             Unit.ensureCompatible(trajType.toString(), trajType.getUnits(), false, trajUnits);
  162.         }
  163.     }

  165.     /** Increments a trajectory ID.
  166.      * <p>
  167.      * The trajectory blocks metadata contains three identifiers ({@code TRAJ_ID},
  168.      * {@code TRAJ_PREV_ID}, {@code TRAJ_NEXT_ID}) that link the various blocks together.
  169.      * This helper method allows to update one identifier based on the value of another
  170.      * identifier. The update is performed by looking for an integer suffix at the end
  171.      * of the {@code original} identifier and incrementing it by one, taking care to use
  172.      * at least the same number of digits. If for example the original identifier is set
  173.      * to {@code trajectory 037}, then the updated identifier will be {@code trajectory 038}.
  174.      * </p>
  175.      * <p>
  176.      * This helper function is intended to be used by ephemeris generators like {@link EphemerisOcmWriter}
  177.      * and {@link StreamingOcmWriter}, allowing users to call only {@link #setTrajBasisID(String)}
  178.      * in the trajectory metadata template. The ephemeris generators call {@code
  179.      * template.setTrajNextID(TrajectoryStateHistoryMetadata.incrementTrajID(template.getTrajID()))}
  180.      * before generating each trajectory block and call both {@code template.setTrajPrevID(template.getTrajID()))}
  181.      * and {@code template.setTrajID(template.getTrajNextID()))} after having generated each block.
  182.      * </p>
  183.      * @param original original ID (may be null)
  184.      * @return incremented ID, or null if original was null
  185.      */
  186.     public static String incrementTrajID(final String original) {

  188.         if (original == null) {
  189.             // no trajectory ID at all
  190.             return null;
  191.         }

  193.         // split the ID into prefix and numerical index
  194.         int end = original.length();
  195.         while (end > 0 && Character.isDigit(original.charAt(end - 1))) {
  196.             --end;
  197.         }
  198.         final String prefix   = original.substring(0, end);
  199.         final int    index    = end < original.length() ? Integer.parseInt(original.substring(end)) : 0;

  201.         // build offset index, taking care to use at least the same number of digits
  202.         final String newIndex = String.format(String.format("%%0%dd", original.length() - end),
  203.                                               index + 1);

  205.         return prefix + newIndex;

  207.     }

  209.     /** Get trajectory identification number.
  210.      * @return trajectory identification number
  211.      */
  212.     public String getTrajID() {
  213.         return trajID;
  214.     }

  216.     /** Set trajectory identification number.
  217.      * @param trajID trajectory identification number
  218.      */
  219.     public void setTrajID(final String trajID) {
  220.         refuseFurtherComments();
  221.         this.trajID = trajID;
  222.     }

  224.     /** Get identification number of previous trajectory.
  225.      * @return identification number of previous trajectory
  226.      */
  227.     public String getTrajPrevID() {
  228.         return trajPrevID;
  229.     }

  231.     /** Set identification number of previous trajectory.
  232.      * @param trajPrevID identification number of previous trajectory
  233.      */
  234.     public void setTrajPrevID(final String trajPrevID) {
  235.         refuseFurtherComments();
  236.         this.trajPrevID = trajPrevID;
  237.     }

  239.     /** Get identification number of next trajectory.
  240.      * @return identification number of next trajectory
  241.      */
  242.     public String getTrajNextID() {
  243.         return trajNextID;
  244.     }

  246.     /** Set identification number of next trajectory.
  247.      * @param trajNextID identification number of next trajectory
  248.      */
  249.     public void setTrajNextID(final String trajNextID) {
  250.         refuseFurtherComments();
  251.         this.trajNextID = trajNextID;
  252.     }

  254.     /** Get basis of this trajectory state time history data.
  255.      * @return basis of this trajectory state time history data
  256.      */
  257.     public String getTrajBasis() {
  258.         return trajBasis;
  259.     }

  261.     /** Set basis of this trajectory state time history data.
  262.      * @param trajBasis basis of this trajectory state time history data
  263.      */
  264.     public void setTrajBasis(final String trajBasis) {
  265.         refuseFurtherComments();
  266.         this.trajBasis = trajBasis;
  267.     }

  269.     /** Get identification number of the orbit determination or simulation upon which this trajectory is based.
  270.      * @return identification number of the orbit determination or simulation upon which this trajectory is based
  271.      */
  272.     public String getTrajBasisID() {
  273.         return trajBasisID;
  274.     }

  276.     /** Set identification number of the orbit determination or simulation upon which this trajectory is based.
  277.      * @param trajBasisID identification number of the orbit determination or simulation upon which this trajectory is based
  278.      */
  279.     public void setTrajBasisID(final String trajBasisID) {
  280.         refuseFurtherComments();
  281.         this.trajBasisID = trajBasisID;
  282.     }

  284.     /** Get the interpolation method to be used.
  285.      * @return the interpolation method
  286.      */
  287.     public InterpolationMethod getInterpolationMethod() {
  288.         return interpolationMethod;
  289.     }

  291.     /** Set the interpolation method to be used.
  292.      * @param interpolationMethod the interpolation method to be set
  293.      */
  294.     public void setInterpolationMethod(final InterpolationMethod interpolationMethod) {
  295.         refuseFurtherComments();
  296.         this.interpolationMethod = interpolationMethod;
  297.     }

  299.     /** Get the interpolation degree.
  300.      * @return the interpolation degree
  301.      */
  302.     public int getInterpolationDegree() {
  303.         return interpolationDegree;
  304.     }

  306.     /** Set the interpolation degree.
  307.      * @param interpolationDegree the interpolation degree to be set
  308.      */
  309.     public void setInterpolationDegree(final int interpolationDegree) {
  310.         refuseFurtherComments();
  311.         this.interpolationDegree = interpolationDegree;
  312.     }

  314.     /** Get the orbit propagator used to generate this trajectory.
  315.      * @return orbit propagator used to generate this trajectory
  316.      * @since 11.2
  317.      */
  318.     public String getPropagator() {
  319.         return propagator;
  320.     }

  322.     /** Set the orbit propagator used to generate this trajectory.
  323.      * @param propagator orbit propagator used to generate this trajectory
  324.      * @since 11.2
  325.      */
  326.     public void setPropagator(final String propagator) {
  327.         refuseFurtherComments();
  328.         this.propagator = propagator;
  329.     }

  331.     /** Get the origin of reference frame.
  332.      * @return the origin of reference frame.
  333.      */
  334.     public BodyFacade getCenter() {
  335.         return center;
  336.     }

  338.     /** Set the origin of reference frame.
  339.      * @param center origin of reference frame to be set
  340.      */
  341.     public void setCenter(final BodyFacade center) {
  342.         refuseFurtherComments();
  343.         this.center = center;
  344.     }

  346.     /** Get reference frame of the trajectory.
  347.      * @return reference frame of the trajectory
  348.      */
  349.     public FrameFacade getTrajReferenceFrame() {
  350.         return trajReferenceFrame;
  351.     }

  353.     /** Set reference frame of the trajectory.
  354.      * @param trajReferenceFrame the reference frame to be set
  355.      */
  356.     public void setTrajReferenceFrame(final FrameFacade trajReferenceFrame) {
  357.         refuseFurtherComments();
  358.         this.trajReferenceFrame = trajReferenceFrame;
  359.     }

  361.     /** Get epoch of the {@link #getTrajReferenceFrame() trajectory reference frame}.
  362.      * @return epoch of the {@link #getTrajReferenceFrame() trajectory reference frame}
  363.      */
  364.     public AbsoluteDate getTrajFrameEpoch() {
  365.         return trajFrameEpoch;
  366.     }

  368.     /** Set epoch of the {@link #getTrajReferenceFrame() trajectory reference frame}.
  369.      * @param trajFrameEpoch epoch of the {@link #getTrajReferenceFrame() trajectory reference frame}
  370.      */
  371.     public void setTrajFrameEpoch(final AbsoluteDate trajFrameEpoch) {
  372.         refuseFurtherComments();
  373.         this.trajFrameEpoch = trajFrameEpoch;
  374.     }

  376.     /** Get start of useable time span covered by ephemerides data, it may be
  377.      * necessary to allow for proper interpolation.
  378.      * @return the useable start time
  379.      */
  380.     public AbsoluteDate getUseableStartTime() {
  381.         return useableStartTime;
  382.     }

  384.     /** Set start of useable time span covered by ephemerides data, it may be
  385.      * necessary to allow for proper interpolation.
  386.      * @param useableStartTime the time to be set
  387.      */
  388.     public void setUseableStartTime(final AbsoluteDate useableStartTime) {
  389.         refuseFurtherComments();
  390.         this.useableStartTime = useableStartTime;
  391.     }

  393.     /** Get end of useable time span covered by ephemerides data, it may be
  394.      * necessary to allow for proper interpolation.
  395.      * @return the useable stop time
  396.      */
  397.     public AbsoluteDate getUseableStopTime() {
  398.         return useableStopTime;
  399.     }

  401.     /** Set end of useable time span covered by ephemerides data, it may be
  402.      * necessary to allow for proper interpolation.
  403.      * @param useableStopTime the time to be set
  404.      */
  405.     public void setUseableStopTime(final AbsoluteDate useableStopTime) {
  406.         refuseFurtherComments();
  407.         this.useableStopTime = useableStopTime;
  408.     }

  410.     /** Get the integer orbit revolution number.
  411.      * @return integer orbit revolution number (-1 if not set)
  412.      */
  413.     public int getOrbRevNum() {
  414.         return orbRevNum;
  415.     }

  417.     /** Set the integer orbit revolution number.
  418.      * @param orbRevNum integer orbit revolution number
  419.      */
  420.     public void setOrbRevNum(final int orbRevNum) {
  421.         this.orbRevNum = orbRevNum;
  422.     }

  424.     /** Get the basis for orbit revolution number.
  425.      * <p>
  426.      * This specifies if first launch/deployment is on orbit 0 or 1.
  427.      * </p>
  428.      * @return basis for orbit revolution number (-1 if not set)
  429.      */
  430.     public int getOrbRevNumBasis() {
  431.         return orbRevNumBasis;
  432.     }

  434.     /** Set the basis for orbit revolution number.
  435.      * <p>
  436.      * This specifies if first launch/deployment is on orbit 0 or 1.
  437.      * </p>
  438.      * @param orbRevNumBasis basis for orbit revolution number
  439.      */
  440.     public void setOrbRevNumBasis(final int orbRevNumBasis) {
  441.         this.orbRevNumBasis = orbRevNumBasis;
  442.     }

  444.     /** Get type of averaging (Osculating, mean Brouwer, other.
  445.      * @return type of averaging (Osculating, mean Brouwer, other)
  446.      */
  447.     public String getOrbAveraging() {
  448.         return orbAveraging;
  449.     }

  451.     /** Set type of averaging (Osculating, mean Brouwer, other.
  452.      * @param orbAveraging type of averaging (Osculating, mean Brouwer, other).
  453.      */
  454.     public void setOrbAveraging(final String orbAveraging) {
  455.         refuseFurtherComments();
  456.         this.orbAveraging = orbAveraging;
  457.     }

  459.     /** Get trajectory element set type.
  460.      * @return trajectory element set type
  461.      */
  462.     public OrbitElementsType getTrajType() {
  463.         return trajType;
  464.     }

  466.     /** Set trajectory element set type.
  467.      * @param trajType trajectory element set type
  468.      */
  469.     public void setTrajType(final OrbitElementsType trajType) {
  470.         refuseFurtherComments();
  471.         this.trajType = trajType;
  472.     }

  474.     /** Get trajectory element set units.
  475.      * @return trajectory element set units
  476.      */
  477.     public List<Unit> getTrajUnits() {
  478.         return trajUnits;
  479.     }

  481.     /** Set trajectory element set units.
  482.      * @param trajUnits trajectory element set units
  483.      */
  484.     public void setTrajUnits(final List<Unit> trajUnits) {
  485.         refuseFurtherComments();
  486.         this.trajUnits = trajUnits;
  487.     }

  489.     /** Copy the instance, making sure mandatory fields have been initialized.
  490.      * <p>
  491.      * Dates and orbit counter are not copied.
  492.      * </p>
  493.      * @param version format version
  494.      * @return a new copy
  495.      * @since 12.0
  496.      */
  497.     public TrajectoryStateHistoryMetadata copy(final double version) {

  499.         checkMandatoryEntriesExceptOrbitsCounter(version);

  501.         // allocate new instance
  502.         final TrajectoryStateHistoryMetadata copy = new TrajectoryStateHistoryMetadata(trajFrameEpoch, dataContext);

  504.         // copy comments
  505.         for (String comment : getComments()) {
  506.             copy.addComment(comment);
  507.         }

  509.         // copy metadata
  510.         copy.setTrajPrevID(getTrajPrevID());
  511.         copy.setTrajID(getTrajID());
  512.         copy.setTrajNextID(getTrajNextID());
  513.         copy.setTrajBasis(getTrajBasis());
  514.         copy.setTrajBasisID(getTrajBasisID());
  515.         copy.setInterpolationMethod(getInterpolationMethod());
  516.         copy.setInterpolationDegree(getInterpolationDegree());
  517.         copy.setPropagator(getPropagator());
  518.         copy.setCenter(getCenter());
  519.         copy.setTrajReferenceFrame(getTrajReferenceFrame());
  520.         copy.setTrajFrameEpoch(getTrajFrameEpoch());
  521.         copy.setOrbRevNumBasis(getOrbRevNumBasis());
  522.         copy.setOrbAveraging(getOrbAveraging());
  523.         copy.setTrajType(getTrajType());
  524.         copy.setTrajUnits(getTrajUnits());

  526.         return copy;

  528.     }

  530. }
Created with JaCoCo 0.8.12.202403310830