PhysicalProperties.java

  1. /* Copyright 2002-2022 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.ArrayList;
  21. import java.util.List;

  23. import org.hipparchus.complex.Quaternion;
  24. import org.hipparchus.linear.MatrixUtils;
  25. import org.hipparchus.linear.RealMatrix;
  26. import org.orekit.files.ccsds.definitions.FrameFacade;
  27. import org.orekit.files.ccsds.definitions.OrbitRelativeFrame;
  28. import org.orekit.files.ccsds.section.CommentsContainer;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.utils.Constants;

  32. /** Spacecraft physical properties.
  33.  * @author Luc Maisonobe
  34.  * @since 11.0
  35.  */
  36. public class PhysicalProperties extends CommentsContainer {

  38.     /** Satellite manufacturer name. */
  39.     private String manufacturer;

  41.     /** Bus model name. */
  42.     private String busModel;

  44.     /** Other space objects this object is docked to. */
  45.     private List<String> dockedWith;

  47.     /** Attitude-independent drag cross-sectional area, not already into attitude-dependent area along OEB. */
  48.     private double dragConstantArea;

  50.     /** Nominal drag coefficient. */
  51.     private double dragCoefficient;

  53.     /** Drag coefficient 1σ uncertainty. */
  54.     private double dragUncertainty;

  56.     /** Total mass at beginning of life. */
  57.     private double initialWetMass;

  59.     /** Total mass at T₀. */
  60.     private double wetMass;

  62.     /** Mass without propellant. */
  63.     private double dryMass;

  65.     /** Optimally Enclosing Box parent reference frame. */
  66.     private FrameFacade oebParentFrame;

  68.     /** Optimally Enclosing Box parent reference frame epoch. */
  69.     private AbsoluteDate oebParentFrameEpoch;

  71.     /** Quaternion defining Optimally Enclosing Box. */
  72.     private final double[] oebQ;

  74.     /** Dimensions of Optimally Enclosing Box along X-OEB (i.e max). */
  75.     private double oebMax;

  77.     /** Dimensions of Optimally Enclosing Box along Y-OEB (i.e intermediate). */
  78.     private double oebIntermediate;

  80.     /** Dimensions of Optimally Enclosing Box along Z-OEB (i.e min). */
  81.     private double oebMin;

  83.     /** Cross-sectional area of Optimally Enclosing Box along X-OEB. */
  84.     private double oebAreaAlongMax;

  86.     /** Cross-sectional area of Optimally Enclosing Box along Y-OEB. */
  87.     private double oebAreaAlongIntermediate;

  89.     /** Cross-sectional area of Optimally Enclosing Box along Z-OEB. */
  90.     private double oebAreaAlongMin;

  92.     /** Minimum cross-sectional area for collision probability estimation purposes. */
  93.     private double minAreaForCollisionProbability;

  95.     /** Maximum cross-sectional area for collision probability estimation purposes. */
  96.     private double maxAreaForCollisionProbability;

  98.     /** Typical (50th percentile) cross-sectional area for collision probability estimation purposes. */
  99.     private double typAreaForCollisionProbability;

  101.     /** Typical (50th percentile) radar cross-section. */
  102.     private double rcs;

  104.     /** Minimum radar cross-section. */
  105.     private double minRcs;

  107.     /** Maximum radar cross-section. */
  108.     private double maxRcs;

  110.     /** Attitude-independent SRP area, not already into attitude-dependent area along OEB. */
  111.     private double srpConstantArea;

  113.     /** Nominal SRP coefficient. */
  114.     private double srpCoefficient;

  116.     /** SRP coefficient 1σ uncertainty. */
  117.     private double srpUncertainty;

  119.     /** Typical (50th percentile) visual magnitude. */
  120.     private double vmAbsolute;

  122.     /** Minimum apparent visual magnitude. */
  123.     private double vmApparentMin;

  125.     /** Typical (50th percentile) apparent visual magnitude. */
  126.     private double vmApparent;

  128.     /** Maximum apparent visual magnitude. */
  129.     private double vmApparentMax;

  131.     /** Typical (50th percentile) coefficient of reflectivity. */
  132.     private double reflectivity;

  134.     /** Attitude control mode. */
  135.     private String attitudeControlMode;

  137.     /** Type of actuator for attitude control. */
  138.     private String attitudeActuatorType;

  140.     /** Accuracy of attitude knowledge. */
  141.     private double attitudeKnowledgeAccuracy;

  143.     /** Accuracy of attitude control. */
  144.     private double attitudeControlAccuracy;

  146.     /** Overall accuracy of spacecraft to maintain attitude. */
  147.     private double attitudePointingAccuracy;

  149.     /** Average average frequency of orbit or attitude maneuvers (in SI units, hence per second). */
  150.     private double maneuversFrequency;

  152.     /** Maximum composite thrust the spacecraft can accomplish. */
  153.     private double maxThrust;

  155.     /** Total ΔV capability at beginning of life. */
  156.     private double bolDv;

  158.     /** Total ΔV remaining for spacecraft. */
  159.     private double remainingDv;

  161.     /** Inertia matrix. */
  162.     private RealMatrix inertiaMatrix;

  164.     /** Simple constructor.
  165.      * @param epochT0 T0 epoch from file metadata
  166.      */
  167.     PhysicalProperties(final AbsoluteDate epochT0) {
  168.         // we don't call the setXxx() methods in order to avoid
  169.         // calling refuseFurtherComments as a side effect
  170.         dockedWith                     = new ArrayList<>();
  171.         dragConstantArea                  = Double.NaN;
  172.         dragCoefficient         = Double.NaN;
  173.         dragUncertainty                = 0.0;
  174.         initialWetMass                    = Double.NaN;
  175.         wetMass                           = Double.NaN;
  176.         dryMass                        = Double.NaN;
  177.         oebParentFrame                 = new FrameFacade(null, null, OrbitRelativeFrame.RIC, null,
  178.                                                          OrbitRelativeFrame.RIC.name());
  179.         oebParentFrameEpoch            = epochT0;
  180.         oebQ                           = new double[4];
  181.         oebMax                         = Double.NaN;
  182.         oebIntermediate                = Double.NaN;
  183.         oebMin                         = Double.NaN;
  184.         oebAreaAlongMax                = Double.NaN;
  185.         oebAreaAlongIntermediate       = Double.NaN;
  186.         oebAreaAlongMin                = Double.NaN;
  187.         minAreaForCollisionProbability = Double.NaN;
  188.         maxAreaForCollisionProbability = Double.NaN;
  189.         typAreaForCollisionProbability = Double.NaN;
  190.         rcs                            = Double.NaN;
  191.         minRcs                         = Double.NaN;
  192.         maxRcs                         = Double.NaN;
  193.         srpConstantArea                = Double.NaN;
  194.         srpCoefficient          = Double.NaN;
  195.         srpUncertainty                 = Double.NaN;
  196.         vmAbsolute                     = Double.NaN;
  197.         vmApparentMin                  = Double.NaN;
  198.         vmApparent                     = Double.NaN;
  199.         vmApparentMax                  = Double.NaN;
  200.         reflectivity                   = Double.NaN;
  201.         attitudeKnowledgeAccuracy      = Double.NaN;
  202.         attitudeControlAccuracy        = Double.NaN;
  203.         attitudePointingAccuracy       = Double.NaN;
  204.         maneuversFrequency             = Double.NaN;
  205.         maxThrust                      = Double.NaN;
  206.         bolDv                          = Double.NaN;
  207.         remainingDv                    = Double.NaN;
  208.         inertiaMatrix                  = MatrixUtils.createRealMatrix(3, 3);
  209.     }

  211.     /** Get manufacturer name.
  212.      * @return manufacturer name
  213.      */
  214.     public String getManufacturer() {
  215.         return manufacturer;
  216.     }

  218.     /** Set manufacturer name.
  219.      * @param manufacturer manufacturer name
  220.      */
  221.     public void setManufacturer(final String manufacturer) {
  222.         refuseFurtherComments();
  223.         this.manufacturer = manufacturer;
  224.     }

  226.     /** Get the bus model name.
  227.      * @return bus model name
  228.      */
  229.     public String getBusModel() {
  230.         return busModel;
  231.     }

  233.     /** Set the bus model name.
  234.      * @param busModel bus model name
  235.      */
  236.     public void setBusModel(final String busModel) {
  237.         refuseFurtherComments();
  238.         this.busModel = busModel;
  239.     }

  241.     /** Get the other space objects this object is docked to.
  242.      * @return the oother space objects this object is docked to
  243.      */
  244.     public List<String> getDockedWith() {
  245.         return dockedWith;
  246.     }

  248.     /** Set the other space objects this object is docked to.
  249.      * @param dockedWith the other space objects this object is docked to
  250.      */
  251.     public void setDockedWith(final List<String> dockedWith) {
  252.         refuseFurtherComments();
  253.         this.dockedWith = dockedWith;
  254.     }

  256.     /** Get the attitude-independent drag cross-sectional area, not already into attitude-dependent area along OEB.
  257.      * @return attitude-independent drag cross-sectional area, not already into attitude-dependent area along OEB
  258.      */
  259.     public double getDragConstantArea() {
  260.         return dragConstantArea;
  261.     }

  263.     /** Set the attitude-independent drag cross-sectional area, not already into attitude-dependent area along OEB.
  264.      * @param dragConstantArea attitude-independent drag cross-sectional area, not already into attitude-dependent area along OEB
  265.      */
  266.     public void setDragConstantArea(final double dragConstantArea) {
  267.         refuseFurtherComments();
  268.         this.dragConstantArea = dragConstantArea;
  269.     }

  271.     /** Get the nominal drag coefficient.
  272.      * @return the nominal drag coefficient
  273.      */
  274.     public double getDragCoefficient() {
  275.         return dragCoefficient;
  276.     }

  278.     /** Set the the nominal drag coefficient.
  279.      * @param dragCoefficient the nominal drag coefficient
  280.      */
  281.     public void setDragCoefficient(final double dragCoefficient) {
  282.         refuseFurtherComments();
  283.         this.dragCoefficient = dragCoefficient;
  284.     }

  286.     /** Get the drag coefficient 1σ uncertainty.
  287.      * @return drag coefficient 1σ uncertainty (in %)
  288.      */
  289.     public double getDragUncertainty() {
  290.         return dragUncertainty;
  291.     }

  293.     /** Set the drag coefficient 1σ uncertainty.
  294.      * @param dragUncertainty drag coefficient 1σ uncertainty (in %)
  295.      */
  296.     public void setDragUncertainty(final double dragUncertainty) {
  297.         refuseFurtherComments();
  298.         this.dragUncertainty = dragUncertainty;
  299.     }

  301.     /** Get the total mass at beginning of life.
  302.      * @return total mass at beginning of life
  303.      */
  304.     public double getInitialWetMass() {
  305.         return initialWetMass;
  306.     }

  308.     /** Set the total mass at beginning of life.
  309.      * @param initialWetMass total mass at beginning of life
  310.      */
  311.     public void setInitialWetMass(final double initialWetMass) {
  312.         refuseFurtherComments();
  313.         this.initialWetMass = initialWetMass;
  314.     }

  316.     /** Get the total mass at T₀.
  317.      * @return total mass at T₀
  318.      */
  319.     public double getWetMass() {
  320.         return wetMass;
  321.     }

  323.     /** Set the total mass at T₀.
  324.      * @param wetMass total mass at T₀
  325.      */
  326.     public void setWetMass(final double wetMass) {
  327.         refuseFurtherComments();
  328.         this.wetMass = wetMass;
  329.     }

  331.     /** Get the mass without propellant.
  332.      * @return mass without propellant
  333.      */
  334.     public double getDryMass() {
  335.         return dryMass;
  336.     }

  338.     /** Set the mass without propellant.
  339.      * @param dryMass mass without propellant
  340.      */
  341.     public void setDryMass(final double dryMass) {
  342.         refuseFurtherComments();
  343.         this.dryMass = dryMass;
  344.     }

  346.     /** Get the Optimally Enclosing Box parent reference frame.
  347.      * @return Optimally Enclosing Box parent reference frame
  348.      */
  349.     public FrameFacade getOebParentFrame() {
  350.         return oebParentFrame;
  351.     }

  353.     /** Set the Optimally Enclosing Box parent reference frame.
  354.      * @param oebParentFrame Optimally Enclosing Box parent reference frame
  355.      */
  356.     public void setOebParentFrame(final FrameFacade oebParentFrame) {
  357.         refuseFurtherComments();
  358.         this.oebParentFrame = oebParentFrame;
  359.     }

  361.     /** Get the Optimally Enclosing Box parent reference frame epoch.
  362.      * @return Optimally Enclosing Box parent reference frame epoch
  363.      */
  364.     public AbsoluteDate getOebParentFrameEpoch() {
  365.         return oebParentFrameEpoch;
  366.     }

  368.     /** Set the Optimally Enclosing Box parent reference frame epoch.
  369.      * @param oebParentFrameEpoch Optimally Enclosing Box parent reference frame epoch
  370.      */
  371.     public void setOebParentFrameEpoch(final AbsoluteDate oebParentFrameEpoch) {
  372.         refuseFurtherComments();
  373.         this.oebParentFrameEpoch = oebParentFrameEpoch;
  374.     }

  376.     /** Get the quaternion defining Optimally Enclosing Box.
  377.      * @return quaternion defining Optimally Enclosing Box
  378.      */
  379.     public Quaternion getOebQ() {
  380.         return new Quaternion(oebQ[0], oebQ[1], oebQ[2], oebQ[3]);
  381.     }

  383.     /** set the component of quaternion defining Optimally Enclosing Box.
  384.      * @param i index of the component
  385.      * @param qI component of quaternion defining Optimally Enclosing Box
  386.      */
  387.     public void setOebQ(final int i, final double qI) {
  388.         refuseFurtherComments();
  389.         oebQ[i] = qI;
  390.     }

  392.     /** Get the dimensions of Optimally Enclosing Box along X-OEB (i.e max).
  393.      * @return dimensions of Optimally Enclosing Box along X-OEB (i.e max)
  394.      */
  395.     public double getOebMax() {
  396.         return oebMax;
  397.     }

  399.     /** Set the dimensions of Optimally Enclosing Box along X-OEB (i.e max).
  400.      * @param oebMax dimensions of Optimally Enclosing Box along X-OEB (i.e max)
  401.      */
  402.     public void setOebMax(final double oebMax) {
  403.         refuseFurtherComments();
  404.         this.oebMax = oebMax;
  405.     }

  407.     /** Get the dimensions of Optimally Enclosing Box along Y-OEB (i.e intermediate).
  408.      * @return dimensions of Optimally Enclosing Box along Y-OEB (i.e intermediate).
  409.      */
  410.     public double getOebIntermediate() {
  411.         return oebIntermediate;
  412.     }

  414.     /** Set the dimensions of Optimally Enclosing Box along Y-OEB (i.e intermediate).
  415.      * @param oebIntermediate dimensions of Optimally Enclosing Box along Y-OEB (i.e intermediate).
  416.      */
  417.     public void setOebIntermediate(final double oebIntermediate) {
  418.         refuseFurtherComments();
  419.         this.oebIntermediate = oebIntermediate;
  420.     }

  422.     /** Get the dimensions of Optimally Enclosing Box along Z-OEB (i.e min).
  423.      * @return dimensions of Optimally Enclosing Box along Z-OEB (i.e min)
  424.      */
  425.     public double getOebMin() {
  426.         return oebMin;
  427.     }

  429.     /** Set the dimensions of Optimally Enclosing Box along Z-OEB (i.e min).
  430.      * @param oebMin dimensions of Optimally Enclosing Box along Z-OEB (i.e min)
  431.      */
  432.     public void setOebMin(final double oebMin) {
  433.         refuseFurtherComments();
  434.         this.oebMin = oebMin;
  435.     }

  437.     /** Get the cross-sectional area of Optimally Enclosing Box along X-OEB.
  438.      * @return cross-sectional area of Optimally Enclosing Box along X-OEB
  439.      */
  440.     public double getOebAreaAlongMax() {
  441.         return oebAreaAlongMax;
  442.     }

  444.     /** Set the cross-sectional area of Optimally Enclosing Box along X-OEB.
  445.      * @param oebAreaAlongMax cross-sectional area of Optimally Enclosing Box along X-OEB
  446.      */
  447.     public void setOebAreaAlongMax(final double oebAreaAlongMax) {
  448.         refuseFurtherComments();
  449.         this.oebAreaAlongMax = oebAreaAlongMax;
  450.     }

  452.     /** Get the cross-sectional area of Optimally Enclosing Box along Y-OEB.
  453.      * @return cross-sectional area of Optimally Enclosing Box along Y-OEB
  454.      */
  455.     public double getOebAreaAlongIntermediate() {
  456.         return oebAreaAlongIntermediate;
  457.     }

  459.     /** Set the cross-sectional area of Optimally Enclosing Box along Y-OEB.
  460.      * @param oebAreaAlongIntermediate cross-sectional area of Optimally Enclosing Box along X-OEB
  461.      */
  462.     public void setOebAreaAlongIntermediate(final double oebAreaAlongIntermediate) {
  463.         refuseFurtherComments();
  464.         this.oebAreaAlongIntermediate = oebAreaAlongIntermediate;
  465.     }

  467.     /** Get the cross-sectional area of Optimally Enclosing Box along Z-OEB.
  468.      * @return cross-sectional area of Optimally Enclosing Box along X-OEB
  469.      */
  470.     public double getOebAreaAlongMin() {
  471.         return oebAreaAlongMin;
  472.     }

  474.     /** Set the cross-sectional area of Optimally Enclosing Box along Z-OEB.
  475.      * @param oebAreaAlongMin cross-sectional area of Optimally Enclosing Box along X-OEB
  476.      */
  477.     public void setOebAreaAlongMin(final double oebAreaAlongMin) {
  478.         refuseFurtherComments();
  479.         this.oebAreaAlongMin = oebAreaAlongMin;
  480.     }

  482.     /** Get the minimum cross-sectional area for collision probability estimation purposes.
  483.      * @return minimum cross-sectional area for collision probability estimation purposes
  484.      */
  485.     public double getMinAreaForCollisionProbability() {
  486.         return minAreaForCollisionProbability;
  487.     }

  489.     /** Set the minimum cross-sectional area for collision probability estimation purposes.
  490.      * @param minAreaForCollisionProbability minimum cross-sectional area for collision probability estimation purposes
  491.      */
  492.     public void setMinAreaForCollisionProbability(final double minAreaForCollisionProbability) {
  493.         refuseFurtherComments();
  494.         this.minAreaForCollisionProbability = minAreaForCollisionProbability;
  495.     }

  497.     /** Get the maximum cross-sectional area for collision probability estimation purposes.
  498.      * @return maximum cross-sectional area for collision probability estimation purposes
  499.      */
  500.     public double getMaxAreaForCollisionProbability() {
  501.         return maxAreaForCollisionProbability;
  502.     }

  504.     /** Set the maximum cross-sectional area for collision probability estimation purposes.
  505.      * @param maxAreaForCollisionProbability maximum cross-sectional area for collision probability estimation purposes
  506.      */
  507.     public void setMaxAreaForCollisionProbability(final double maxAreaForCollisionProbability) {
  508.         refuseFurtherComments();
  509.         this.maxAreaForCollisionProbability = maxAreaForCollisionProbability;
  510.     }

  512.     /** Get the typical (50th percentile) cross-sectional area for collision probability estimation purposes.
  513.      * @return typical (50th percentile) cross-sectional area for collision probability estimation purposes
  514.      */
  515.     public double getTypAreaForCollisionProbability() {
  516.         return typAreaForCollisionProbability;
  517.     }

  519.     /** Get the typical (50th percentile) cross-sectional area for collision probability estimation purposes.
  520.      * @param typAreaForCollisionProbability typical (50th percentile) cross-sectional area for collision probability estimation purposes
  521.      */
  522.     public void setTypAreaForCollisionProbability(final double typAreaForCollisionProbability) {
  523.         refuseFurtherComments();
  524.         this.typAreaForCollisionProbability = typAreaForCollisionProbability;
  525.     }

  527.     /** Get the typical (50th percentile) radar cross-section.
  528.      * @return typical (50th percentile) radar cross-section
  529.      */
  530.     public double getRcs() {
  531.         return rcs;
  532.     }

  534.     /** Set the typical (50th percentile) radar cross-section.
  535.      * @param rcs typical (50th percentile) radar cross-section
  536.      */
  537.     public void setRcs(final double rcs) {
  538.         refuseFurtherComments();
  539.         this.rcs = rcs;
  540.     }

  542.     /** Get the minimum radar cross-section.
  543.      * @return minimum radar cross-section
  544.      */
  545.     public double getMinRcs() {
  546.         return minRcs;
  547.     }

  549.     /** Set the minimum radar cross-section.
  550.      * @param minRcs minimum radar cross-section
  551.      */
  552.     public void setMinRcs(final double minRcs) {
  553.         refuseFurtherComments();
  554.         this.minRcs = minRcs;
  555.     }

  557.     /** Get the maximum radar cross-section.
  558.      * @return maximum radar cross-section
  559.      */
  560.     public double getMaxRcs() {
  561.         return maxRcs;
  562.     }

  564.     /** Set the maximum radar cross-section.
  565.      * @param maxRcs maximum radar cross-section
  566.      */
  567.     public void setMaxRcs(final double maxRcs) {
  568.         refuseFurtherComments();
  569.         this.maxRcs = maxRcs;
  570.     }

  572.     /** Get the attitude-independent SRP area, not already into attitude-dependent area along OEB.
  573.      * @return attitude-independent SRP area, not already into attitude-dependent area along OEB
  574.      */
  575.     public double getSrpConstantArea() {
  576.         return srpConstantArea;
  577.     }

  579.     /** Set the attitude-independent SRP area, not already into attitude-dependent area along OEB.
  580.      * @param srpConstantArea attitude-independent SRP area, not already into attitude-dependent area along OEB
  581.      */
  582.     public void setSrpConstantArea(final double srpConstantArea) {
  583.         refuseFurtherComments();
  584.         this.srpConstantArea = srpConstantArea;
  585.     }

  587.     /** Get the nominal SRP coefficient.
  588.      * @return nominal SRP coefficient
  589.      */
  590.     public double getSrpCoefficient() {
  591.         return srpCoefficient;
  592.     }

  594.     /** Set the nominal SRP coefficient.
  595.      * @param srpCoefficient nominal SRP coefficient
  596.      */
  597.     public void setSrpCoefficient(final double srpCoefficient) {
  598.         refuseFurtherComments();
  599.         this.srpCoefficient = srpCoefficient;
  600.     }

  602.     /** Get the SRP coefficient 1σ uncertainty.
  603.      * @return SRP coefficient 1σ uncertainty
  604.      */
  605.     public double getSrpUncertainty() {
  606.         return srpUncertainty;
  607.     }

  609.     /** Set the SRP coefficient 1σ uncertainty.
  610.      * @param srpUncertainty SRP coefficient 1σ uncertainty.
  611.      */
  612.     public void setSrpUncertainty(final double srpUncertainty) {
  613.         refuseFurtherComments();
  614.         this.srpUncertainty = srpUncertainty;
  615.     }

  617.     /** Get the typical (50th percentile) visual magnitude.
  618.      * @return typical (50th percentile) visual magnitude
  619.      */
  620.     public double getVmAbsolute() {
  621.         return vmAbsolute;
  622.     }

  624.     /** Set the typical (50th percentile) visual magnitude.
  625.      * @param vmAbsolute typical (50th percentile) visual magnitude
  626.      */
  627.     public void setVmAbsolute(final double vmAbsolute) {
  628.         refuseFurtherComments();
  629.         this.vmAbsolute = vmAbsolute;
  630.     }

  632.     /** Get the minimum apparent visual magnitude.
  633.      * @return minimum apparent visual magnitude
  634.      */
  635.     public double getVmApparentMin() {
  636.         return vmApparentMin;
  637.     }

  639.     /** Set the minimum apparent visual magnitude.
  640.      * @param vmApparentMin minimum apparent visual magnitude
  641.      */
  642.     public void setVmApparentMin(final double vmApparentMin) {
  643.         refuseFurtherComments();
  644.         this.vmApparentMin = vmApparentMin;
  645.     }

  647.     /** Get the typical (50th percentile) apparent visual magnitude.
  648.      * @return typical (50th percentile) apparent visual magnitude
  649.      */
  650.     public double getVmApparent() {
  651.         return vmApparent;
  652.     }

  654.     /** Set the typical (50th percentile) apparent visual magnitude.
  655.      * @param vmApparent typical (50th percentile) apparent visual magnitude
  656.      */
  657.     public void setVmApparent(final double vmApparent) {
  658.         refuseFurtherComments();
  659.         this.vmApparent = vmApparent;
  660.     }

  662.     /** Get the maximum apparent visual magnitude.
  663.      * @return maximum apparent visual magnitude
  664.      */
  665.     public double getVmApparentMax() {
  666.         return vmApparentMax;
  667.     }

  669.     /** Set the maximum apparent visual magnitude.
  670.      * @param vmApparentMax maximum apparent visual magnitude
  671.      */
  672.     public void setVmApparentMax(final double vmApparentMax) {
  673.         refuseFurtherComments();
  674.         this.vmApparentMax = vmApparentMax;
  675.     }

  677.     /** Get the typical (50th percentile) coefficient of reflectivity.
  678.      * @return typical (50th percentile) coefficient of reflectivity
  679.      */
  680.     public double getReflectivity() {
  681.         return reflectivity;
  682.     }

  684.     /** Set the typical (50th percentile) coefficient of reflectivity.
  685.      * @param reflectivity typical (50th percentile) coefficient of reflectivity
  686.      */
  687.     public void setReflectivity(final double reflectivity) {
  688.         refuseFurtherComments();
  689.         this.reflectivity = reflectivity;
  690.     }

  692.     /** Get the attitude control mode.
  693.      * @return attitude control mode
  694.      */
  695.     public String getAttitudeControlMode() {
  696.         return attitudeControlMode;
  697.     }

  699.     /** Set the attitude control mode.
  700.      * @param attitudeControlMode attitude control mode
  701.      */
  702.     public void setAttitudeControlMode(final String attitudeControlMode) {
  703.         refuseFurtherComments();
  704.         this.attitudeControlMode = attitudeControlMode;
  705.     }

  707.     /** Get the type of actuator for attitude control.
  708.      * @return type of actuator for attitude control
  709.      */
  710.     public String getAttitudeActuatorType() {
  711.         return attitudeActuatorType;
  712.     }

  714.     /** Set the type of actuator for attitude control.
  715.      * @param attitudeActuatorType type of actuator for attitude control
  716.      */
  717.     public void setAttitudeActuatorType(final String attitudeActuatorType) {
  718.         refuseFurtherComments();
  719.         this.attitudeActuatorType = attitudeActuatorType;
  720.     }

  722.     /** Get the accuracy of attitude knowledge.
  723.      * @return accuracy of attitude knowledge
  724.      */
  725.     public double getAttitudeKnowledgeAccuracy() {
  726.         return attitudeKnowledgeAccuracy;
  727.     }

  729.     /** Set the accuracy of attitude knowledge.
  730.      * @param attitudeKnowledgeAccuracy accuracy of attitude knowledge
  731.      */
  732.     public void setAttitudeKnowledgeAccuracy(final double attitudeKnowledgeAccuracy) {
  733.         refuseFurtherComments();
  734.         this.attitudeKnowledgeAccuracy = attitudeKnowledgeAccuracy;
  735.     }

  737.     /** Get the accuracy of attitude control.
  738.      * @return accuracy of attitude control
  739.      */
  740.     public double getAttitudeControlAccuracy() {
  741.         return attitudeControlAccuracy;
  742.     }

  744.     /** Set the accuracy of attitude control.
  745.      * @param attitudeControlAccuracy accuracy of attitude control
  746.      */
  747.     public void setAttitudeControlAccuracy(final double attitudeControlAccuracy) {
  748.         refuseFurtherComments();
  749.         this.attitudeControlAccuracy = attitudeControlAccuracy;
  750.     }

  752.     /** Get the overall accuracy of spacecraft to maintain attitude.
  753.      * @return overall accuracy of spacecraft to maintain attitude
  754.      */
  755.     public double getAttitudePointingAccuracy() {
  756.         return attitudePointingAccuracy;
  757.     }

  759.     /** Set the overall accuracy of spacecraft to maintain attitude.
  760.      * @param attitudePointingAccuracy overall accuracy of spacecraft to maintain attitude
  761.      */
  762.     public void setAttitudePointingAccuracy(final double attitudePointingAccuracy) {
  763.         refuseFurtherComments();
  764.         this.attitudePointingAccuracy = attitudePointingAccuracy;
  765.     }

  767.     /** Get the average number of orbit or attitude maneuvers per year.
  768.      * @return average number of orbit or attitude maneuvers per year.
  769.      */
  770.     public double getManeuversPerYear() {
  771.         return maneuversFrequency * Constants.JULIAN_YEAR;
  772.     }

  774.     /** Get the average frequency of orbit or attitude maneuvers (in SI units, hence per second).
  775.      * @return average frequency of orbit or attitude maneuvers (in SI units, hence per second).
  776.      */
  777.     public double getManeuversFrequency() {
  778.         return maneuversFrequency;
  779.     }

  781.     /** Set the average frequency of orbit or attitude maneuvers (in SI units, hence per second).
  782.      * @param maneuversFrequency average frequency of orbit or attitude (in SI units, hence per second).
  783.      */
  784.     public void setManeuversFrequency(final double maneuversFrequency) {
  785.         refuseFurtherComments();
  786.         this.maneuversFrequency = maneuversFrequency;
  787.     }

  789.     /** Get the maximum composite thrust the spacecraft can accomplish.
  790.      * @return maximum composite thrust the spacecraft can accomplish
  791.      */
  792.     public double getMaxThrust() {
  793.         return maxThrust;
  794.     }

  796.     /** Set the maximum composite thrust the spacecraft can accomplish.
  797.      * @param maxThrust maximum composite thrust the spacecraft can accomplish
  798.      */
  799.     public void setMaxThrust(final double maxThrust) {
  800.         refuseFurtherComments();
  801.         this.maxThrust = maxThrust;
  802.     }

  804.     /** Get the total ΔV capability at beginning of life.
  805.      * @return total ΔV capability at beginning of life
  806.      */
  807.     public double getBolDv() {
  808.         return bolDv;
  809.     }

  811.     /** Set the total ΔV capability at beginning of life.
  812.      * @param bolDv total ΔV capability at beginning of life
  813.      */
  814.     public void setBolDv(final double bolDv) {
  815.         refuseFurtherComments();
  816.         this.bolDv = bolDv;
  817.     }

  819.     /** Get the total ΔV remaining for spacecraft.
  820.      * @return total ΔV remaining for spacecraft
  821.      */
  822.     public double getRemainingDv() {
  823.         return remainingDv;
  824.     }

  826.     /** Set the total ΔV remaining for spacecraft.
  827.      * @param remainingDv total ΔV remaining for spacecraft
  828.      */
  829.     public void setRemainingDv(final double remainingDv) {
  830.         refuseFurtherComments();
  831.         this.remainingDv = remainingDv;
  832.     }

  834.     /** Get the inertia matrix.
  835.      * @return the inertia matrix
  836.      */
  837.     public RealMatrix getInertiaMatrix() {
  838.         return inertiaMatrix;
  839.     }

  841.     /** Set an entry in the inertia matrix.
  842.      * <p>
  843.      * Both I(j, k) and I(k, j) are set.
  844.      * </p>
  845.      * @param j row index (must be between 0 and 3 (inclusive)
  846.      * @param k column index (must be between 0 and 3 (inclusive)
  847.      * @param entry value of the matrix entry
  848.      */
  849.     public void setInertiaMatrixEntry(final int j, final int k, final double entry) {
  850.         refuseFurtherComments();
  851.         inertiaMatrix.setEntry(j, k, entry);
  852.         inertiaMatrix.setEntry(k, j, entry);
  853.     }

  855. }
Created with JaCoCo 0.8.7.202105040129