CommonPhysicalProperties.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.  */
  17. package org.orekit.files.ccsds.ndm;

  19. import org.hipparchus.complex.Quaternion;
  20. import org.orekit.files.ccsds.definitions.FrameFacade;
  21. import org.orekit.files.ccsds.definitions.OrbitRelativeFrame;
  22. import org.orekit.files.ccsds.ndm.cdm.AdditionalParameters;
  23. import org.orekit.files.ccsds.ndm.odm.ocm.OrbitPhysicalProperties;
  24. import org.orekit.files.ccsds.section.CommentsContainer;
  25. import org.orekit.time.AbsoluteDate;

  27. /** Container for common physical properties for both {@link OrbitPhysicalProperties} and {@link AdditionalParameters}.
  28.  *
  29.  * @author Maxime Journot
  30.  * @since 11.3
  31.  */
  32. public class CommonPhysicalProperties extends CommentsContainer {

  34.     /** Optimally Enclosing Box parent reference frame. */
  35.     private FrameFacade oebParentFrame;

  37.     /** Optimally Enclosing Box parent reference frame epoch. */
  38.     private AbsoluteDate oebParentFrameEpoch;

  40.     /** Quaternion defining Optimally Enclosing Box. */
  41.     private final double[] oebQ;

  43.     /** Maximum physical dimension of Optimally Enclosing Box. */
  44.     private double oebMax;

  46.     /** Intermediate physical dimension of Optimally Enclosing Box. */
  47.     private double oebIntermediate;

  49.     /** Minimum physical dimension of Optimally Enclosing Box. */
  50.     private double oebMin;

  52.     /** Cross-sectional area of Optimally Enclosing Box when viewed along the maximum OEB direction. */
  53.     private double oebAreaAlongMax;

  55.     /** Cross-sectional area of Optimally Enclosing Box when viewed along the intermediate OEB direction. */
  56.     private double oebAreaAlongIntermediate;

  58.     /** Cross-sectional area of Optimally Enclosing Box when viewed along the minimum OEB direction. */
  59.     private double oebAreaAlongMin;

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

  64.     /** Minimum radar cross-section. */
  65.     private double minRcs;

  67.     /** Maximum radar cross-section. */
  68.     private double maxRcs;

  70.     /** Typical (50th percentile) visual magnitude. */
  71.     private double vmAbsolute;

  73.     /** Minimum apparent visual magnitude. */
  74.     private double vmApparentMin;

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

  79.     /** Maximum apparent visual magnitude. */
  80.     private double vmApparentMax;

  82.     /** Typical (50th percentile) coefficient of reflectivity. */
  83.     private double reflectance;

  85.     /** Simple constructor.
  86.      */
  87.     public CommonPhysicalProperties() {

  89.         oebParentFrame           = new FrameFacade(null, null, OrbitRelativeFrame.RIC, null,
  90.                                                    OrbitRelativeFrame.RIC.name());
  91.         oebParentFrameEpoch      = AbsoluteDate.ARBITRARY_EPOCH;
  92.         oebQ                     = new double[4];
  93.         oebMax                   = Double.NaN;
  94.         oebIntermediate          = Double.NaN;
  95.         oebMin                   = Double.NaN;
  96.         oebAreaAlongMax          = Double.NaN;
  97.         oebAreaAlongIntermediate = Double.NaN;
  98.         oebAreaAlongMin          = Double.NaN;
  99.         rcs                      = Double.NaN;
  100.         minRcs                   = Double.NaN;
  101.         maxRcs                   = Double.NaN;
  102.         vmAbsolute               = Double.NaN;
  103.         vmApparentMin            = Double.NaN;
  104.         vmApparent               = Double.NaN;
  105.         vmApparentMax            = Double.NaN;
  106.         reflectance              = Double.NaN;
  107.     }

  109.     /** {@inheritDoc} */
  110.     @Override
  111.     public void validate(final double version) {
  112.         super.validate(version);
  113.     }

  115.     /** Get the Optimally Enclosing Box parent reference frame.
  116.      * @return Optimally Enclosing Box parent reference frame
  117.      */
  118.     public FrameFacade getOebParentFrame() {
  119.         return oebParentFrame;
  120.     }

  122.     /** Set the Optimally Enclosing Box parent reference frame.
  123.      * @param oebParentFrame Optimally Enclosing Box parent reference frame
  124.      */
  125.     public void setOebParentFrame(final FrameFacade oebParentFrame) {
  126.         refuseFurtherComments();
  127.         this.oebParentFrame = oebParentFrame;
  128.     }

  130.     /** Get the Optimally Enclosing Box parent reference frame epoch.
  131.      * @return Optimally Enclosing Box parent reference frame epoch
  132.      */
  133.     public AbsoluteDate getOebParentFrameEpoch() {
  134.         return oebParentFrameEpoch;
  135.     }

  137.     /** Set the Optimally Enclosing Box parent reference frame epoch.
  138.      * @param oebParentFrameEpoch Optimally Enclosing Box parent reference frame epoch
  139.      */
  140.     public void setOebParentFrameEpoch(final AbsoluteDate oebParentFrameEpoch) {
  141.         refuseFurtherComments();
  142.         this.oebParentFrameEpoch = oebParentFrameEpoch;
  143.     }

  145.     /** Get the quaternion defining Optimally Enclosing Box.
  146.      * @return quaternion defining Optimally Enclosing Box
  147.      */
  148.     public Quaternion getOebQ() {
  149.         return new Quaternion(oebQ[0], oebQ[1], oebQ[2], oebQ[3]);
  150.     }

  152.     /** set the component of quaternion defining Optimally Enclosing Box.
  153.      * @param i index of the component
  154.      * @param qI component of quaternion defining Optimally Enclosing Box
  155.      */
  156.     public void setOebQ(final int i, final double qI) {
  157.         refuseFurtherComments();
  158.         oebQ[i] = qI;
  159.     }

  161.     /** Get the maximum physical dimension of the OEB.
  162.      * @return maximum physical dimension of the OEB.
  163.      */
  164.     public double getOebMax() {
  165.         return oebMax;
  166.     }

  168.     /** Set the maximum physical dimension of the OEB.
  169.      * @param oebMax maximum physical dimension of the OEB.
  170.      */
  171.     public void setOebMax(final double oebMax) {
  172.         refuseFurtherComments();
  173.         this.oebMax = oebMax;
  174.     }

  176.     /** Get the intermediate physical dimension of the OEB.
  177.      * @return intermediate physical dimension of the OEB.
  178.      */
  179.     public double getOebIntermediate() {
  180.         return oebIntermediate;
  181.     }

  183.     /** Set the intermediate physical dimension of the OEB.
  184.      * @param oebIntermediate intermediate physical dimension of the OEB.
  185.      */
  186.     public void setOebIntermediate(final double oebIntermediate) {
  187.         refuseFurtherComments();
  188.         this.oebIntermediate = oebIntermediate;
  189.     }

  191.     /** Get the minimum physical dimension of the OEB.
  192.      * @return dimensions the minimum physical dimension of the OEB.
  193.      */
  194.     public double getOebMin() {
  195.         return oebMin;
  196.     }

  198.     /** Set the minimum physical dimension of the OEB.
  199.      * @param oebMin the minimum physical dimension of the OEB.
  200.      */
  201.     public void setOebMin(final double oebMin) {
  202.         refuseFurtherComments();
  203.         this.oebMin = oebMin;
  204.     }

  206.     /** Get the cross-sectional area of Optimally Enclosing Box when viewed along the maximum OEB direction.
  207.      * @return cross-sectional area of Optimally Enclosing Box when viewed along the maximum OEB direction.
  208.      */
  209.     public double getOebAreaAlongMax() {
  210.         return oebAreaAlongMax;
  211.     }

  213.     /** Set the cross-sectional area of Optimally Enclosing Box when viewed along the maximum OEB direction.
  214.      * @param oebAreaAlongMax cross-sectional area of Optimally Enclosing Box when viewed along the maximum OEB direction.
  215.      */
  216.     public void setOebAreaAlongMax(final double oebAreaAlongMax) {
  217.         refuseFurtherComments();
  218.         this.oebAreaAlongMax = oebAreaAlongMax;
  219.     }

  221.     /** Get the cross-sectional area of Optimally Enclosing Box when viewed along the intermediate OEB direction.
  222.      * @return cross-sectional area of Optimally Enclosing Box when viewed along the intermediate OEB direction.
  223.      */
  224.     public double getOebAreaAlongIntermediate() {
  225.         return oebAreaAlongIntermediate;
  226.     }

  228.     /** Set the cross-sectional area of Optimally Enclosing Box when viewed along the intermediate OEB direction.
  229.      * @param oebAreaAlongIntermediate cross-sectional area of Optimally Enclosing Box when viewed along the intermediate OEB direction.
  230.      */
  231.     public void setOebAreaAlongIntermediate(final double oebAreaAlongIntermediate) {
  232.         refuseFurtherComments();
  233.         this.oebAreaAlongIntermediate = oebAreaAlongIntermediate;
  234.     }

  236.     /** Get the cross-sectional area of Optimally Enclosing Box when viewed along the minimum OEB direction.
  237.      * @return cross-sectional area of Optimally Enclosing Box when viewed along the minimum OEB direction.
  238.      */
  239.     public double getOebAreaAlongMin() {
  240.         return oebAreaAlongMin;
  241.     }

  243.     /** Set the cross-sectional area of Optimally Enclosing Box when viewed along the minimum OEB direction.
  244.      * @param oebAreaAlongMin cross-sectional area of Optimally Enclosing Box when viewed along the minimum OEB direction.
  245.      */
  246.     public void setOebAreaAlongMin(final double oebAreaAlongMin) {
  247.         refuseFurtherComments();
  248.         this.oebAreaAlongMin = oebAreaAlongMin;
  249.     }


  252.     /** Get the typical (50th percentile) radar cross-section.
  253.      * @return typical (50th percentile) radar cross-section
  254.      */
  255.     public double getRcs() {
  256.         return rcs;
  257.     }

  259.     /** Set the typical (50th percentile) radar cross-section.
  260.      * @param rcs typical (50th percentile) radar cross-section
  261.      */
  262.     public void setRcs(final double rcs) {
  263.         refuseFurtherComments();
  264.         this.rcs = rcs;
  265.     }

  267.     /** Get the minimum radar cross-section.
  268.      * @return minimum radar cross-section
  269.      */
  270.     public double getMinRcs() {
  271.         return minRcs;
  272.     }

  274.     /** Set the minimum radar cross-section.
  275.      * @param minRcs minimum radar cross-section
  276.      */
  277.     public void setMinRcs(final double minRcs) {
  278.         refuseFurtherComments();
  279.         this.minRcs = minRcs;
  280.     }

  282.     /** Get the maximum radar cross-section.
  283.      * @return maximum radar cross-section
  284.      */
  285.     public double getMaxRcs() {
  286.         return maxRcs;
  287.     }

  289.     /** Set the maximum radar cross-section.
  290.      * @param maxRcs maximum radar cross-section
  291.      */
  292.     public void setMaxRcs(final double maxRcs) {
  293.         refuseFurtherComments();
  294.         this.maxRcs = maxRcs;
  295.     }

  297.     /** Get the typical (50th percentile) visual magnitude.
  298.      * @return typical (50th percentile) visual magnitude
  299.      */
  300.     public double getVmAbsolute() {
  301.         return vmAbsolute;
  302.     }

  304.     /** Set the typical (50th percentile) visual magnitude.
  305.      * @param vmAbsolute typical (50th percentile) visual magnitude
  306.      */
  307.     public void setVmAbsolute(final double vmAbsolute) {
  308.         refuseFurtherComments();
  309.         this.vmAbsolute = vmAbsolute;
  310.     }

  312.     /** Get the minimum apparent visual magnitude.
  313.      * @return minimum apparent visual magnitude
  314.      */
  315.     public double getVmApparentMin() {
  316.         return vmApparentMin;
  317.     }

  319.     /** Set the minimum apparent visual magnitude.
  320.      * @param vmApparentMin minimum apparent visual magnitude
  321.      */
  322.     public void setVmApparentMin(final double vmApparentMin) {
  323.         refuseFurtherComments();
  324.         this.vmApparentMin = vmApparentMin;
  325.     }

  327.     /** Get the typical (50th percentile) apparent visual magnitude.
  328.      * @return typical (50th percentile) apparent visual magnitude
  329.      */
  330.     public double getVmApparent() {
  331.         return vmApparent;
  332.     }

  334.     /** Set the typical (50th percentile) apparent visual magnitude.
  335.      * @param vmApparent typical (50th percentile) apparent visual magnitude
  336.      */
  337.     public void setVmApparent(final double vmApparent) {
  338.         refuseFurtherComments();
  339.         this.vmApparent = vmApparent;
  340.     }

  342.     /** Get the maximum apparent visual magnitude.
  343.      * @return maximum apparent visual magnitude
  344.      */
  345.     public double getVmApparentMax() {
  346.         return vmApparentMax;
  347.     }

  349.     /** Set the maximum apparent visual magnitude.
  350.      * @param vmApparentMax maximum apparent visual magnitude
  351.      */
  352.     public void setVmApparentMax(final double vmApparentMax) {
  353.         refuseFurtherComments();
  354.         this.vmApparentMax = vmApparentMax;
  355.     }

  357.     /** Get the typical (50th percentile) coefficient of reflectance.
  358.      * @return typical (50th percentile) coefficient of reflectance
  359.      */
  360.     public double getReflectance() {
  361.         return reflectance;
  362.     }

  364.     /** Set the typical (50th percentile) coefficient of reflectance.
  365.      * @param reflectance typical (50th percentile) coefficient of reflectance
  366.      */
  367.     public void setReflectance(final double reflectance) {
  368.         refuseFurtherComments();
  369.         this.reflectance = reflectance;
  370.     }
  371. }
Created with JaCoCo 0.8.12.202403310830