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;
18  
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;
26  
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 {
33  
34      /** Optimally Enclosing Box parent reference frame. */
35      private FrameFacade oebParentFrame;
36  
37      /** Optimally Enclosing Box parent reference frame epoch. */
38      private AbsoluteDate oebParentFrameEpoch;
39  
40      /** Quaternion defining Optimally Enclosing Box. */
41      private final double[] oebQ;
42  
43      /** Maximum physical dimension of Optimally Enclosing Box. */
44      private double oebMax;
45  
46      /** Intermediate physical dimension of Optimally Enclosing Box. */
47      private double oebIntermediate;
48  
49      /** Minimum physical dimension of Optimally Enclosing Box. */
50      private double oebMin;
51  
52      /** Cross-sectional area of Optimally Enclosing Box when viewed along the maximum OEB direction. */
53      private double oebAreaAlongMax;
54  
55      /** Cross-sectional area of Optimally Enclosing Box when viewed along the intermediate OEB direction. */
56      private double oebAreaAlongIntermediate;
57  
58      /** Cross-sectional area of Optimally Enclosing Box when viewed along the minimum OEB direction. */
59      private double oebAreaAlongMin;
60  
61          /** Typical (50th percentile) radar cross-section. */
62      private double rcs;
63  
64      /** Minimum radar cross-section. */
65      private double minRcs;
66  
67      /** Maximum radar cross-section. */
68      private double maxRcs;
69  
70      /** Typical (50th percentile) visual magnitude. */
71      private double vmAbsolute;
72  
73      /** Minimum apparent visual magnitude. */
74      private double vmApparentMin;
75  
76      /** Typical (50th percentile) apparent visual magnitude. */
77      private double vmApparent;
78  
79      /** Maximum apparent visual magnitude. */
80      private double vmApparentMax;
81  
82      /** Typical (50th percentile) coefficient of reflectivity. */
83      private double reflectance;
84  
85      /** Simple constructor.
86       */
87      public CommonPhysicalProperties() {
88  
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     }
108 
109     /** {@inheritDoc} */
110     @Override
111     public void validate(final double version) {
112         super.validate(version);
113     }
114 
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     }
121 
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     }
129 
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     }
136 
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     }
144 
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     }
151 
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     }
160 
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     }
167 
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     }
175 
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     }
182 
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     }
190 
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     }
197 
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     }
205 
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     }
212 
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     }
220 
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     }
227 
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     }
235 
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     }
242 
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     }
250 
251 
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     }
258 
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     }
266 
267     /** Get the minimum radar cross-section.
268      * @return minimum radar cross-section
269      */
270     public double getMinRcs() {
271         return minRcs;
272     }
273 
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     }
281 
282     /** Get the maximum radar cross-section.
283      * @return maximum radar cross-section
284      */
285     public double getMaxRcs() {
286         return maxRcs;
287     }
288 
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     }
296 
297     /** Get the typical (50th percentile) visual magnitude.
298      * @return typical (50th percentile) visual magnitude
299      */
300     public double getVmAbsolute() {
301         return vmAbsolute;
302     }
303 
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     }
311 
312     /** Get the minimum apparent visual magnitude.
313      * @return minimum apparent visual magnitude
314      */
315     public double getVmApparentMin() {
316         return vmApparentMin;
317     }
318 
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     }
326 
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     }
333 
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     }
341 
342     /** Get the maximum apparent visual magnitude.
343      * @return maximum apparent visual magnitude
344      */
345     public double getVmApparentMax() {
346         return vmApparentMax;
347     }
348 
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     }
356 
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     }
363 
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 }