OPMFile.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.  */

  18. package org.orekit.files.ccsds;

  20. import java.util.ArrayList;
  21. import java.util.Collections;
  22. import java.util.List;

  24. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  25. import org.orekit.frames.Frame;
  26. import org.orekit.frames.LOFType;
  27. import org.orekit.orbits.CartesianOrbit;
  28. import org.orekit.orbits.KeplerianOrbit;
  29. import org.orekit.propagation.SpacecraftState;
  30. import org.orekit.time.AbsoluteDate;
  31. import org.orekit.utils.PVCoordinates;

  33. /** This class gathers the informations present in the Orbital Parameter Message (OPM), and contains
  34.  * methods to generate {@link CartesianOrbit}, {@link KeplerianOrbit} or {@link SpacecraftState}.
  35.  * @author sports
  36.  * @since 6.1
  37.  */
  38. public class OPMFile extends OGMFile {

  40.     /** Meta-data. */
  41.     private final ODMMetaData metaData;

  43.     /** Position vector (m). */
  44.     private Vector3D position;

  46.     /** Velocity vector (m/s. */
  47.     private Vector3D velocity;

  49.     /** Maneuvers. */
  50.     private List<Maneuver> maneuvers;

  52.     /** Create a new OPM file object. */
  53.     OPMFile() {
  54.         metaData  = new ODMMetaData(this);
  55.         maneuvers = new ArrayList<Maneuver>();
  56.     }

  58.     /** Get the meta data.
  59.      * @return meta data
  60.      */
  61.     @Override
  62.     public ODMMetaData getMetaData() {
  63.         return metaData;
  64.     }

  66.     /** Get position vector.
  67.      * @return the position vector
  68.      */
  69.     public Vector3D getPosition() {
  70.         return position;
  71.     }

  73.     /** Set position vector.
  74.      * @param position the position vector to be set
  75.      */
  76.     void setPosition(final Vector3D position) {
  77.         this.position = position;
  78.     }

  80.     /** Get velocity vector.
  81.      * @return the velocity vector
  82.      */
  83.     public Vector3D getVelocity() {
  84.         return velocity;
  85.     }

  87.     /** Set velocity vector.
  88.      * @param velocity the velocity vector to be set
  89.      */
  90.     void setVelocity(final Vector3D velocity) {
  91.         this.velocity = velocity;
  92.     }

  94.     /** Get the number of maneuvers present in the OPM.
  95.      * @return the number of maneuvers
  96.      */
  97.     public int getNbManeuvers() {
  98.         return maneuvers.size();
  99.     }

  101.     /** Get a list of all maneuvers.
  102.      * @return unmodifiable list of all maneuvers.
  103.      */
  104.     public List<Maneuver> getManeuvers() {
  105.         return Collections.unmodifiableList(maneuvers);
  106.     }

  108.     /** Get a maneuver.
  109.      * @param index maneuver index, counting from 0
  110.      * @return maneuver
  111.      */
  112.     public Maneuver getManeuver(final int index) {
  113.         return maneuvers.get(index);
  114.     }

  116.     /** Add a maneuver.
  117.      * @param maneuver maneuver to be set
  118.      */
  119.     void addManeuver(final Maneuver maneuver) {
  120.         maneuvers.add(maneuver);
  121.     }

  123.     /** Get boolean testing whether the OPM contains at least one maneuver.
  124.      * @return true if OPM contains at least one maneuver
  125.      *         false otherwise */
  126.     public boolean getHasManeuver() {
  127.         return !maneuvers.isEmpty();
  128.     }

  130.     /** Get the comment for meta-data.
  131.      * @return comment for meta-data
  132.      */
  133.     public List<String> getMetaDataComment() {
  134.         return metaData.getComment();
  135.     }

  137.     /** Get the position/velocity coordinates contained in the OPM.
  138.      * @return the position/velocity coordinates contained in the OPM
  139.      */
  140.     public PVCoordinates getPVCoordinates() {
  141.         return new PVCoordinates(getPosition(), getVelocity());
  142.     }

  144.     /**
  145.      * Generate a {@link CartesianOrbit} from the OPM state vector data. If the reference frame is not
  146.      * pseudo-inertial, an exception is raised.
  147.      * @return the {@link CartesianOrbit} generated from the OPM information
  148.      */
  149.     public CartesianOrbit generateCartesianOrbit() {
  150.         setMuUsed();
  151.         return new CartesianOrbit(getPVCoordinates(), metaData.getFrame(), getEpoch(), getMuUsed());
  152.     }

  154.     /** Generate a {@link KeplerianOrbit} from the OPM Keplerian elements if hasKeplerianElements is true,
  155.      * or from the state vector data otherwise.
  156.      * If the reference frame is not pseudo-inertial, an exception is raised.
  157.      * @return the {@link KeplerianOrbit} generated from the OPM information
  158.      */
  159.     public KeplerianOrbit generateKeplerianOrbit() {
  160.         setMuUsed();
  161.         if (hasKeplerianElements()) {
  162.             return new KeplerianOrbit(getA(), getE(), getI(), getPa(), getRaan(), getAnomaly(),
  163.                                       getAnomalyType(), metaData.getFrame(), getEpoch(), getMuUsed());
  164.         } else {
  165.             return new KeplerianOrbit(getPVCoordinates(), metaData.getFrame(), getEpoch(), getMuUsed());
  166.         }
  167.     }

  169.     /** Generate spacecraft state from the {@link CartesianOrbit} generated by generateCartesianOrbit.
  170.      *  Raises an exception if OPM doesn't contain spacecraft mass information.
  171.      * @return the spacecraft state of the OPM
  172.      */
  173.     public SpacecraftState generateSpacecraftState() {
  174.         return new SpacecraftState(generateCartesianOrbit(), getMass());
  175.     }

  177.     /** Maneuver in an OPM file.
  178.      */
  179.     public static class Maneuver {

  181.         /** Epoch ignition. */
  182.         private AbsoluteDate epochIgnition;

  184.         /** Coordinate system for velocity increment vector, for Local Orbital Frames. */
  185.         private LOFType refLofType;

  187.         /** Coordinate system for velocity increment vector, for absolute frames. */
  188.         private Frame refFrame;

  190.         /** Duration (value is 0 for impulsive maneuver). */
  191.         private double duration;

  193.         /** Mass change during maneuver (value is < 0). */
  194.         private double deltaMass;

  196.         /** Velocity increment. */
  197.         private Vector3D dV;

  199.         /** Maneuvers data comment, each string in the list corresponds to one line of comment. */
  200.         private List<String> comment;

  202.         /** Simple constructor.
  203.          */
  204.         public Maneuver() {
  205.             this.dV      = Vector3D.ZERO;
  206.             this.comment = Collections.emptyList();
  207.         }

  209.         /** Get epoch ignition.
  210.          * @return epoch ignition
  211.          */
  212.         public AbsoluteDate getEpochIgnition() {
  213.             return epochIgnition;
  214.         }

  216.         /** Set epoch ignition.
  217.          * @param epochIgnition epoch ignition
  218.          */
  219.         void setEpochIgnition(final AbsoluteDate epochIgnition) {
  220.             this.epochIgnition = epochIgnition;
  221.         }

  223.         /** Get coordinate system for velocity increment vector, for Local Orbital Frames.
  224.          * @return coordinate system for velocity increment vector, for Local Orbital Frames
  225.          */
  226.         public LOFType getRefLofType() {
  227.             return refLofType;
  228.         }

  230.         /** Set coordinate system for velocity increment vector, for Local Orbital Frames.
  231.          * @param refLofType coordinate system for velocity increment vector, for Local Orbital Frames
  232.          */
  233.         public void setRefLofType(final LOFType refLofType) {
  234.             this.refLofType = refLofType;
  235.             this.refFrame   = null;
  236.         }

  238.         /** Get Coordinate system for velocity increment vector, for absolute frames.
  239.          * @return coordinate system for velocity increment vector, for absolute frames
  240.          */
  241.         public Frame getRefFrame() {
  242.             return refFrame;
  243.         }

  245.         /** Set Coordinate system for velocity increment vector, for absolute frames.
  246.          * @param refFrame coordinate system for velocity increment vector, for absolute frames
  247.          */
  248.         public void setRefFrame(final Frame refFrame) {
  249.             this.refLofType = null;
  250.             this.refFrame   = refFrame;
  251.         }

  253.         /** Get duration (value is 0 for impulsive maneuver).
  254.          * @return duration (value is 0 for impulsive maneuver)
  255.          */
  256.         public double getDuration() {
  257.             return duration;
  258.         }

  260.         /** Set duration (value is 0 for impulsive maneuver).
  261.          * @param duration duration (value is 0 for impulsive maneuver)
  262.          */
  263.         public void setDuration(final double duration) {
  264.             this.duration = duration;
  265.         }

  267.         /** Get mass change during maneuver (value is &lt; 0).
  268.          * @return mass change during maneuver (value is &lt; 0)
  269.          */
  270.         public double getDeltaMass() {
  271.             return deltaMass;
  272.         }

  274.         /** Set mass change during maneuver (value is &lt; 0).
  275.          * @param deltaMass mass change during maneuver (value is &lt; 0)
  276.          */
  277.         public void setDeltaMass(final double deltaMass) {
  278.             this.deltaMass = deltaMass;
  279.         }

  281.         /** Get velocity increment.
  282.          * @return velocity increment
  283.          */
  284.         public Vector3D getDV() {
  285.             return dV;
  286.         }

  288.         /** Set velocity increment.
  289.          * @param dV velocity increment
  290.          */
  291.         public void setdV(final Vector3D dV) {
  292.             this.dV = dV;
  293.         }

  295.         /** Get the maneuvers data comment, each string in the list corresponds to one line of comment.
  296.          * @return maneuvers data comment, each string in the list corresponds to one line of comment
  297.          */
  298.         public List<String> getComment() {
  299.             return Collections.unmodifiableList(comment);
  300.         }

  302.         /** Set the maneuvers data comment, each string in the list corresponds to one line of comment.
  303.          * @param comment maneuvers data comment, each string in the list corresponds to one line of comment
  304.          */
  305.         public void setComment(final List<String> comment) {
  306.             this.comment = new ArrayList<String>(comment);
  307.         }

  309.     }

  311. }
Created with JaCoCo 0.8.5.201910111838