lox_io/ndm/
common.rs

1// SPDX-FileCopyrightText: 2024 Andrei Zisu <matzipan@gmail.com>
2//
3// SPDX-License-Identifier: MPL-2.0
4
5//! Data types shared between different NDM message types
6
7use serde;
8
9#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
10#[serde(default)]
11pub struct AccUnits(#[serde(rename = "$text")] pub String);
12
13#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
14#[serde(default)]
15pub struct AngleUnits(#[serde(rename = "$text")] pub String);
16
17#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
18#[serde(default)]
19pub struct AngleRateUnits(#[serde(rename = "$text")] pub String);
20
21#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
22#[serde(default)]
23pub struct AreaUnits(#[serde(rename = "$text")] pub String);
24
25#[derive(
26    Clone,
27    Debug,
28    Default,
29    PartialEq,
30    serde::Deserialize,
31    serde::Serialize,
32    lox_derive::KvnDeserialize,
33)]
34#[serde(default)]
35pub struct DayIntervalUnits(#[serde(rename = "$text")] pub String);
36
37#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
38#[serde(default)]
39pub struct GmUnits(#[serde(rename = "$text")] pub String);
40
41#[derive(
42    Clone,
43    Debug,
44    Default,
45    PartialEq,
46    serde::Deserialize,
47    serde::Serialize,
48    lox_derive::KvnDeserialize,
49)]
50#[serde(default)]
51pub struct LengthUnits(#[serde(rename = "$text")] pub String);
52
53#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
54#[serde(default)]
55pub struct MassUnits(#[serde(rename = "$text")] pub String);
56
57#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
58#[serde(default)]
59pub struct MomentUnits(#[serde(rename = "$text")] pub String);
60
61#[derive(
62    Clone,
63    Debug,
64    Default,
65    PartialEq,
66    serde::Deserialize,
67    serde::Serialize,
68    lox_derive::KvnDeserialize,
69)]
70#[serde(default)]
71pub struct WkgUnits(#[serde(rename = "$text")] pub String);
72
73#[derive(
74    Clone,
75    Debug,
76    Default,
77    PartialEq,
78    serde::Deserialize,
79    serde::Serialize,
80    lox_derive::KvnDeserialize,
81)]
82#[serde(default)]
83pub struct ObjectDescriptionType(#[serde(rename = "$text")] pub String);
84
85#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
86#[serde(default)]
87pub struct PositionUnits(#[serde(rename = "$text")] pub String);
88
89#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
90#[serde(default)]
91pub struct VelocityUnits(#[serde(rename = "$text")] pub String);
92
93#[derive(
94    Clone,
95    Debug,
96    Default,
97    PartialEq,
98    serde::Deserialize,
99    serde::Serialize,
100    lox_derive::KvnDeserialize,
101)]
102#[serde(default)]
103pub struct Vec3Double(#[serde(rename = "$text")] pub f64);
104
105#[derive(
106    Clone,
107    Debug,
108    Default,
109    PartialEq,
110    serde::Deserialize,
111    serde::Serialize,
112    lox_derive::KvnDeserialize,
113)]
114#[serde(default)]
115pub struct EpochType(#[serde(rename = "$text")] pub String);
116
117#[derive(
118    Clone,
119    Debug,
120    Default,
121    PartialEq,
122    serde::Deserialize,
123    serde::Serialize,
124    lox_derive::KvnDeserialize,
125)]
126#[serde(default)]
127pub struct TimeUnits(#[serde(rename = "$text")] pub String);
128
129#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
130#[serde(default)]
131pub struct NegativeDouble(#[serde(rename = "$text")] pub f64);
132
133#[derive(
134    Clone,
135    Debug,
136    Default,
137    PartialEq,
138    serde::Deserialize,
139    serde::Serialize,
140    lox_derive::KvnDeserialize,
141)]
142#[serde(default)]
143pub struct NonNegativeDouble(#[serde(rename = "$text")] pub f64);
144
145#[derive(
146    Clone,
147    Debug,
148    Default,
149    PartialEq,
150    serde::Deserialize,
151    serde::Serialize,
152    lox_derive::KvnDeserialize,
153)]
154#[serde(default)]
155pub struct PositiveDouble(#[serde(rename = "$text")] pub f64);
156
157#[derive(
158    Clone,
159    Debug,
160    Default,
161    PartialEq,
162    serde::Deserialize,
163    serde::Serialize,
164    lox_derive::KvnDeserialize,
165)]
166#[serde(default)]
167pub struct Range100Type(#[serde(rename = "$text")] pub String);
168
169#[derive(
170    Clone,
171    Debug,
172    Default,
173    PartialEq,
174    serde::Deserialize,
175    serde::Serialize,
176    lox_derive::KvnDeserialize,
177)]
178#[serde(default)]
179pub struct ProbabilityType(#[serde(rename = "$text")] pub String);
180
181#[derive(
182    Clone,
183    Debug,
184    Default,
185    PartialEq,
186    serde::Deserialize,
187    serde::Serialize,
188    lox_derive::KvnDeserialize,
189)]
190#[serde(default)]
191pub struct PercentageUnits(#[serde(rename = "$text")] pub String);
192
193#[derive(
194    Clone,
195    Debug,
196    Default,
197    PartialEq,
198    serde::Deserialize,
199    serde::Serialize,
200    lox_derive::KvnDeserialize,
201)]
202#[serde(default)]
203pub struct TrajBasisType(#[serde(rename = "$text")] pub String);
204
205#[derive(
206    Clone,
207    Debug,
208    Default,
209    PartialEq,
210    serde::Deserialize,
211    serde::Serialize,
212    lox_derive::KvnDeserialize,
213)]
214#[serde(default)]
215pub struct RevNumBasisType(#[serde(rename = "$text")] pub String);
216
217#[derive(
218    Clone,
219    Debug,
220    Default,
221    PartialEq,
222    serde::Deserialize,
223    serde::Serialize,
224    lox_derive::KvnDeserialize,
225)]
226#[serde(default)]
227pub struct CovBasisType(#[serde(rename = "$text")] pub String);
228
229#[derive(
230    Clone,
231    Debug,
232    Default,
233    PartialEq,
234    serde::Deserialize,
235    serde::Serialize,
236    lox_derive::KvnDeserialize,
237)]
238#[serde(default)]
239pub struct ManBasisType(#[serde(rename = "$text")] pub String);
240
241#[derive(
242    Clone,
243    Debug,
244    Default,
245    PartialEq,
246    serde::Deserialize,
247    serde::Serialize,
248    lox_derive::KvnDeserialize,
249)]
250#[serde(default)]
251pub struct ManDcType(#[serde(rename = "$text")] pub String);
252
253#[derive(
254    Clone,
255    Debug,
256    Default,
257    PartialEq,
258    serde::Deserialize,
259    serde::Serialize,
260    lox_derive::KvnDeserialize,
261)]
262#[serde(default)]
263pub struct NumPerYearUnits(#[serde(rename = "$text")] pub String);
264
265#[derive(
266    Clone,
267    Debug,
268    Default,
269    PartialEq,
270    serde::Deserialize,
271    serde::Serialize,
272    lox_derive::KvnDeserialize,
273)]
274#[serde(default)]
275pub struct ThrustUnits(#[serde(rename = "$text")] pub String);
276
277#[derive(
278    Clone,
279    Debug,
280    Default,
281    PartialEq,
282    serde::Deserialize,
283    serde::Serialize,
284    lox_derive::KvnDeserialize,
285)]
286#[serde(default)]
287pub struct CovOrderType(#[serde(rename = "$text")] pub String);
288
289#[derive(
290    Clone,
291    Debug,
292    Default,
293    PartialEq,
294    serde::Deserialize,
295    serde::Serialize,
296    lox_derive::KvnDeserialize,
297)]
298#[serde(default)]
299pub struct GeomagUnits(#[serde(rename = "$text")] pub String);
300
301#[derive(
302    Clone,
303    Debug,
304    Default,
305    PartialEq,
306    serde::Deserialize,
307    serde::Serialize,
308    lox_derive::KvnDeserialize,
309)]
310#[serde(default)]
311pub struct SolarFluxUnits(#[serde(rename = "$text")] pub String);
312
313#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
314#[serde(default)]
315pub struct PositionCovarianceUnits(#[serde(rename = "$text")] pub String);
316
317#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
318#[serde(default)]
319pub struct VelocityCovarianceUnits(#[serde(rename = "$text")] pub String);
320
321#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
322#[serde(default)]
323pub struct PositionVelocityCovarianceUnits(#[serde(rename = "$text")] pub String);
324
325#[derive(
326    Clone,
327    Debug,
328    Default,
329    PartialEq,
330    serde::Deserialize,
331    serde::Serialize,
332    lox_derive::KvnDeserialize,
333)]
334#[serde(default)]
335pub struct OdmHeader {
336    #[serde(rename = "COMMENT")]
337    pub comment_list: Vec<String>,
338    #[serde(rename = "CLASSIFICATION")]
339    pub classification_list: Vec<String>,
340    #[serde(rename = "CREATION_DATE")]
341    pub creation_date: EpochType,
342    #[serde(rename = "ORIGINATOR")]
343    pub originator: String,
344    #[serde(rename = "MESSAGE_ID")]
345    pub message_id: Option<String>,
346}
347
348#[derive(
349    Clone,
350    Debug,
351    Default,
352    PartialEq,
353    serde::Deserialize,
354    serde::Serialize,
355    lox_derive::KvnDeserialize,
356)]
357#[serde(default)]
358#[kvn(value_unit_struct)]
359pub struct AccType {
360    #[serde(rename = "$text")]
361    pub base: f64,
362    #[serde(rename = "@units")]
363    pub units: Option<AccUnits>,
364}
365
366#[derive(
367    Clone,
368    Debug,
369    Default,
370    PartialEq,
371    serde::Deserialize,
372    serde::Serialize,
373    lox_derive::KvnDeserialize,
374)]
375#[serde(default)]
376#[kvn(value_unit_struct)]
377pub struct AngleType {
378    #[serde(rename = "$text")]
379    pub base: f64,
380    #[serde(rename = "@units")]
381    pub units: Option<AngleUnits>,
382}
383
384#[derive(
385    Clone,
386    Debug,
387    Default,
388    PartialEq,
389    serde::Deserialize,
390    serde::Serialize,
391    lox_derive::KvnDeserialize,
392)]
393#[serde(default)]
394#[kvn(value_unit_struct)]
395pub struct AngleRateType {
396    #[serde(rename = "$text")]
397    pub base: f64,
398    #[serde(rename = "@units")]
399    pub units: Option<AngleRateUnits>,
400}
401
402#[derive(
403    Clone,
404    Debug,
405    Default,
406    PartialEq,
407    serde::Deserialize,
408    serde::Serialize,
409    lox_derive::KvnDeserialize,
410)]
411#[serde(default)]
412#[kvn(value_unit_struct)]
413pub struct AreaType {
414    #[serde(rename = "$text")]
415    pub base: NonNegativeDouble,
416    #[serde(rename = "@units")]
417    pub units: Option<AreaUnits>,
418}
419
420#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
421#[serde(default)]
422pub struct DayIntervalType {
423    #[serde(rename = "$text")]
424    pub base: NonNegativeDouble,
425    #[serde(rename = "@units")]
426    pub units: DayIntervalUnits,
427}
428
429#[derive(
430    Clone,
431    Debug,
432    Default,
433    PartialEq,
434    serde::Deserialize,
435    serde::Serialize,
436    lox_derive::KvnDeserialize,
437)]
438#[serde(default)]
439pub struct OcmDayIntervalType {
440    #[serde(rename = "$text")]
441    pub base: NonNegativeDouble,
442    #[serde(rename = "@units")]
443    pub units: Option<DayIntervalUnits>,
444}
445
446#[derive(
447    Clone,
448    Debug,
449    Default,
450    PartialEq,
451    serde::Deserialize,
452    serde::Serialize,
453    lox_derive::KvnDeserialize,
454)]
455#[serde(default)]
456#[kvn(value_unit_struct)]
457pub struct DeltamassType {
458    #[serde(rename = "$text")]
459    pub base: NegativeDouble,
460    #[serde(rename = "@units")]
461    pub units: Option<MassUnits>,
462}
463
464#[derive(
465    Clone,
466    Debug,
467    Default,
468    PartialEq,
469    serde::Deserialize,
470    serde::Serialize,
471    lox_derive::KvnDeserialize,
472)]
473#[serde(default)]
474#[kvn(value_unit_struct)]
475pub struct GmType {
476    #[serde(rename = "$text")]
477    pub base: PositiveDouble,
478    #[serde(rename = "@units")]
479    pub units: Option<GmUnits>,
480}
481
482#[derive(
483    Clone,
484    Debug,
485    Default,
486    PartialEq,
487    serde::Deserialize,
488    serde::Serialize,
489    lox_derive::KvnDeserialize,
490)]
491#[serde(default)]
492#[kvn(value_unit_struct)]
493pub struct InclinationType {
494    #[serde(rename = "$text")]
495    pub base: f64,
496    #[serde(rename = "@units")]
497    pub units: Option<AngleUnits>,
498}
499
500#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
501#[serde(default)]
502pub struct LengthType {
503    #[serde(rename = "$text")]
504    pub base: f64,
505    #[serde(rename = "@units")]
506    pub units: LengthUnits,
507}
508
509#[derive(
510    Clone,
511    Debug,
512    Default,
513    PartialEq,
514    serde::Deserialize,
515    serde::Serialize,
516    lox_derive::KvnDeserialize,
517)]
518#[serde(default)]
519pub struct OcmLengthType {
520    #[serde(rename = "$text")]
521    pub base: f64,
522    #[serde(rename = "@units")]
523    pub units: Option<LengthUnits>,
524}
525
526#[derive(
527    Clone,
528    Debug,
529    Default,
530    PartialEq,
531    serde::Deserialize,
532    serde::Serialize,
533    lox_derive::KvnDeserialize,
534)]
535#[serde(default)]
536#[kvn(value_unit_struct)]
537pub struct MassType {
538    #[serde(rename = "$text")]
539    pub base: NonNegativeDouble,
540    #[serde(rename = "@units")]
541    pub units: Option<MassUnits>,
542}
543
544#[derive(
545    Clone,
546    Debug,
547    Default,
548    PartialEq,
549    serde::Deserialize,
550    serde::Serialize,
551    lox_derive::KvnDeserialize,
552)]
553#[serde(default)]
554#[kvn(value_unit_struct)]
555pub struct MomentType {
556    #[serde(rename = "$text")]
557    pub base: f64,
558    #[serde(rename = "@units")]
559    pub units: Option<MomentUnits>,
560}
561
562#[derive(
563    Clone,
564    Debug,
565    Default,
566    PartialEq,
567    serde::Deserialize,
568    serde::Serialize,
569    lox_derive::KvnDeserialize,
570)]
571#[serde(default)]
572pub struct WkgType {
573    #[serde(rename = "$text")]
574    pub base: NonNegativeDouble,
575    #[serde(rename = "@units")]
576    pub units: WkgUnits,
577}
578
579#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
580#[serde(default)]
581pub struct OdParametersType {
582    #[serde(rename = "COMMENT")]
583    pub comment_list: Vec<String>,
584    #[serde(rename = "TIME_LASTOB_START")]
585    pub time_lastob_start: Option<EpochType>,
586    #[serde(rename = "TIME_LASTOB_END")]
587    pub time_lastob_end: Option<EpochType>,
588    #[serde(rename = "RECOMMENDED_OD_SPAN")]
589    pub recommended_od_span: Option<DayIntervalType>,
590    #[serde(rename = "ACTUAL_OD_SPAN")]
591    pub actual_od_span: Option<DayIntervalType>,
592    #[serde(rename = "OBS_AVAILABLE")]
593    pub obs_available: Option<u64>,
594    #[serde(rename = "OBS_USED")]
595    pub obs_used: Option<u64>,
596    #[serde(rename = "TRACKS_AVAILABLE")]
597    pub tracks_available: Option<u64>,
598    #[serde(rename = "TRACKS_USED")]
599    pub tracks_used: Option<u64>,
600    #[serde(rename = "RESIDUALS_ACCEPTED")]
601    pub residuals_accepted: Option<PercentageType>,
602    #[serde(rename = "WEIGHTED_RMS")]
603    pub weighted_rms: Option<NonNegativeDouble>,
604}
605
606#[derive(
607    Clone,
608    Debug,
609    Default,
610    PartialEq,
611    serde::Deserialize,
612    serde::Serialize,
613    lox_derive::KvnDeserialize,
614)]
615#[serde(default)]
616pub struct SpacecraftParametersType {
617    #[serde(rename = "COMMENT")]
618    pub comment_list: Vec<String>,
619    #[serde(rename = "MASS")]
620    pub mass: Option<MassType>,
621    #[serde(rename = "SOLAR_RAD_AREA")]
622    pub solar_rad_area: Option<AreaType>,
623    #[serde(rename = "SOLAR_RAD_COEFF")]
624    pub solar_rad_coeff: Option<NonNegativeDouble>,
625    #[serde(rename = "DRAG_AREA")]
626    pub drag_area: Option<AreaType>,
627    #[serde(rename = "DRAG_COEFF")]
628    pub drag_coeff: Option<NonNegativeDouble>,
629}
630
631#[derive(
632    Clone,
633    Debug,
634    Default,
635    PartialEq,
636    serde::Deserialize,
637    serde::Serialize,
638    lox_derive::KvnDeserialize,
639)]
640#[serde(default)]
641pub struct StateVectorType {
642    #[serde(rename = "COMMENT")]
643    pub comment_list: Vec<String>,
644    #[serde(rename = "EPOCH")]
645    pub epoch: EpochType,
646    #[serde(rename = "X")]
647    pub x: PositionType,
648    #[serde(rename = "Y")]
649    pub y: PositionType,
650    #[serde(rename = "Z")]
651    pub z: PositionType,
652    #[serde(rename = "X_DOT")]
653    pub x_dot: VelocityType,
654    #[serde(rename = "Y_DOT")]
655    pub y_dot: VelocityType,
656    #[serde(rename = "Z_DOT")]
657    pub z_dot: VelocityType,
658}
659
660#[derive(
661    Clone,
662    Debug,
663    Default,
664    PartialEq,
665    serde::Deserialize,
666    serde::Serialize,
667    lox_derive::KvnDeserialize,
668)]
669#[serde(default)]
670pub struct StateVectorAccType {
671    #[serde(rename = "EPOCH")]
672    pub epoch: EpochType,
673    #[serde(rename = "X")]
674    pub x: PositionType,
675    #[serde(rename = "Y")]
676    pub y: PositionType,
677    #[serde(rename = "Z")]
678    pub z: PositionType,
679    #[serde(rename = "X_DOT")]
680    pub x_dot: VelocityType,
681    #[serde(rename = "Y_DOT")]
682    pub y_dot: VelocityType,
683    #[serde(rename = "Z_DOT")]
684    pub z_dot: VelocityType,
685    #[serde(rename = "X_DDOT")]
686    pub x_ddot: Option<AccType>,
687    #[serde(rename = "Y_DDOT")]
688    pub y_ddot: Option<AccType>,
689    #[serde(rename = "Z_DDOT")]
690    pub z_ddot: Option<AccType>,
691}
692
693#[derive(
694    Clone,
695    Debug,
696    Default,
697    PartialEq,
698    serde::Deserialize,
699    serde::Serialize,
700    lox_derive::KvnDeserialize,
701)]
702#[serde(default)]
703#[kvn(value_unit_struct)]
704pub struct DistanceType {
705    #[serde(rename = "$text")]
706    pub base: f64,
707    #[serde(rename = "@units")]
708    pub units: Option<PositionUnits>,
709}
710
711#[derive(
712    Clone,
713    Debug,
714    Default,
715    PartialEq,
716    serde::Deserialize,
717    serde::Serialize,
718    lox_derive::KvnDeserialize,
719)]
720#[serde(default)]
721#[kvn(value_unit_struct)]
722pub struct PositionType {
723    #[serde(rename = "$text")]
724    pub base: f64,
725    #[serde(rename = "@units")]
726    pub units: Option<PositionUnits>,
727}
728
729#[derive(
730    Clone,
731    Debug,
732    Default,
733    PartialEq,
734    serde::Deserialize,
735    serde::Serialize,
736    lox_derive::KvnDeserialize,
737)]
738#[serde(default)]
739#[kvn(value_unit_struct)]
740pub struct VelocityType {
741    #[serde(rename = "$text")]
742    pub base: f64,
743    #[serde(rename = "@units")]
744    pub units: Option<VelocityUnits>,
745}
746
747#[derive(
748    Clone,
749    Debug,
750    Default,
751    PartialEq,
752    serde::Deserialize,
753    serde::Serialize,
754    lox_derive::KvnDeserialize,
755)]
756#[serde(default)]
757#[kvn(value_unit_struct)]
758pub struct DurationType {
759    #[serde(rename = "$text")]
760    pub base: NonNegativeDouble,
761    #[serde(rename = "@units")]
762    pub units: Option<TimeUnits>,
763}
764
765#[derive(
766    Clone,
767    Debug,
768    Default,
769    PartialEq,
770    serde::Deserialize,
771    serde::Serialize,
772    lox_derive::KvnDeserialize,
773)]
774#[serde(default)]
775pub struct TimeOffsetType {
776    #[serde(rename = "$text")]
777    pub base: f64,
778    #[serde(rename = "@units")]
779    pub units: Option<TimeUnits>,
780}
781
782#[derive(
783    Clone,
784    Debug,
785    Default,
786    PartialEq,
787    serde::Deserialize,
788    serde::Serialize,
789    lox_derive::KvnDeserialize,
790)]
791#[serde(default)]
792pub struct PercentageType {
793    #[serde(rename = "$text")]
794    pub base: Range100Type,
795    #[serde(rename = "@units")]
796    pub units: Option<PercentageUnits>,
797}
798
799#[derive(
800    Clone,
801    Debug,
802    Default,
803    PartialEq,
804    serde::Deserialize,
805    serde::Serialize,
806    lox_derive::KvnDeserialize,
807)]
808#[serde(default)]
809pub struct ManeuverFreqType {
810    #[serde(rename = "$text")]
811    pub base: NonNegativeDouble,
812    #[serde(rename = "@units")]
813    pub units: Option<NumPerYearUnits>,
814}
815
816#[derive(
817    Clone,
818    Debug,
819    Default,
820    PartialEq,
821    serde::Deserialize,
822    serde::Serialize,
823    lox_derive::KvnDeserialize,
824)]
825#[serde(default)]
826pub struct ThrustType {
827    #[serde(rename = "$text")]
828    pub base: f64,
829    #[serde(rename = "@units")]
830    pub units: Option<ThrustUnits>,
831}
832
833#[derive(
834    Clone,
835    Debug,
836    Default,
837    PartialEq,
838    serde::Deserialize,
839    serde::Serialize,
840    lox_derive::KvnDeserialize,
841)]
842#[serde(default)]
843pub struct GeomagType {
844    #[serde(rename = "$text")]
845    pub base: f64,
846    #[serde(rename = "@units")]
847    pub units: Option<GeomagUnits>,
848}
849
850#[derive(
851    Clone,
852    Debug,
853    Default,
854    PartialEq,
855    serde::Deserialize,
856    serde::Serialize,
857    lox_derive::KvnDeserialize,
858)]
859#[serde(default)]
860pub struct SolarFluxType {
861    #[serde(rename = "$text")]
862    pub base: f64,
863    #[serde(rename = "@units")]
864    pub units: Option<SolarFluxUnits>,
865}
866
867#[derive(
868    Clone,
869    Debug,
870    Default,
871    PartialEq,
872    serde::Deserialize,
873    serde::Serialize,
874    lox_derive::KvnDeserialize,
875)]
876#[serde(default)]
877pub struct OemCovarianceMatrixType {
878    #[serde(rename = "COMMENT")]
879    pub comment_list: Vec<String>,
880    #[serde(rename = "EPOCH")]
881    pub epoch: EpochType,
882    #[serde(rename = "COV_REF_FRAME")]
883    pub cov_ref_frame: Option<String>,
884    #[serde(rename = "CX_X")]
885    pub cx_x: PositionCovarianceType,
886    #[serde(rename = "CY_X")]
887    pub cy_x: PositionCovarianceType,
888    #[serde(rename = "CY_Y")]
889    pub cy_y: PositionCovarianceType,
890    #[serde(rename = "CZ_X")]
891    pub cz_x: PositionCovarianceType,
892    #[serde(rename = "CZ_Y")]
893    pub cz_y: PositionCovarianceType,
894    #[serde(rename = "CZ_Z")]
895    pub cz_z: PositionCovarianceType,
896    #[serde(rename = "CX_DOT_X")]
897    pub cx_dot_x: PositionVelocityCovarianceType,
898    #[serde(rename = "CX_DOT_Y")]
899    pub cx_dot_y: PositionVelocityCovarianceType,
900    #[serde(rename = "CX_DOT_Z")]
901    pub cx_dot_z: PositionVelocityCovarianceType,
902    #[serde(rename = "CX_DOT_X_DOT")]
903    pub cx_dot_x_dot: VelocityCovarianceType,
904    #[serde(rename = "CY_DOT_X")]
905    pub cy_dot_x: PositionVelocityCovarianceType,
906    #[serde(rename = "CY_DOT_Y")]
907    pub cy_dot_y: PositionVelocityCovarianceType,
908    #[serde(rename = "CY_DOT_Z")]
909    pub cy_dot_z: PositionVelocityCovarianceType,
910    #[serde(rename = "CY_DOT_X_DOT")]
911    pub cy_dot_x_dot: VelocityCovarianceType,
912    #[serde(rename = "CY_DOT_Y_DOT")]
913    pub cy_dot_y_dot: VelocityCovarianceType,
914    #[serde(rename = "CZ_DOT_X")]
915    pub cz_dot_x: PositionVelocityCovarianceType,
916    #[serde(rename = "CZ_DOT_Y")]
917    pub cz_dot_y: PositionVelocityCovarianceType,
918    #[serde(rename = "CZ_DOT_Z")]
919    pub cz_dot_z: PositionVelocityCovarianceType,
920    #[serde(rename = "CZ_DOT_X_DOT")]
921    pub cz_dot_x_dot: VelocityCovarianceType,
922    #[serde(rename = "CZ_DOT_Y_DOT")]
923    pub cz_dot_y_dot: VelocityCovarianceType,
924    #[serde(rename = "CZ_DOT_Z_DOT")]
925    pub cz_dot_z_dot: VelocityCovarianceType,
926}
927
928#[derive(
929    Clone,
930    Debug,
931    Default,
932    PartialEq,
933    serde::Deserialize,
934    serde::Serialize,
935    lox_derive::KvnDeserialize,
936)]
937#[serde(default)]
938pub struct OpmCovarianceMatrixType {
939    #[serde(rename = "COMMENT")]
940    pub comment_list: Vec<String>,
941    #[serde(rename = "COV_REF_FRAME")]
942    pub cov_ref_frame: Option<String>,
943    #[serde(rename = "CX_X")]
944    pub cx_x: PositionCovarianceType,
945    #[serde(rename = "CY_X")]
946    pub cy_x: PositionCovarianceType,
947    #[serde(rename = "CY_Y")]
948    pub cy_y: PositionCovarianceType,
949    #[serde(rename = "CZ_X")]
950    pub cz_x: PositionCovarianceType,
951    #[serde(rename = "CZ_Y")]
952    pub cz_y: PositionCovarianceType,
953    #[serde(rename = "CZ_Z")]
954    pub cz_z: PositionCovarianceType,
955    #[serde(rename = "CX_DOT_X")]
956    pub cx_dot_x: PositionVelocityCovarianceType,
957    #[serde(rename = "CX_DOT_Y")]
958    pub cx_dot_y: PositionVelocityCovarianceType,
959    #[serde(rename = "CX_DOT_Z")]
960    pub cx_dot_z: PositionVelocityCovarianceType,
961    #[serde(rename = "CX_DOT_X_DOT")]
962    pub cx_dot_x_dot: VelocityCovarianceType,
963    #[serde(rename = "CY_DOT_X")]
964    pub cy_dot_x: PositionVelocityCovarianceType,
965    #[serde(rename = "CY_DOT_Y")]
966    pub cy_dot_y: PositionVelocityCovarianceType,
967    #[serde(rename = "CY_DOT_Z")]
968    pub cy_dot_z: PositionVelocityCovarianceType,
969    #[serde(rename = "CY_DOT_X_DOT")]
970    pub cy_dot_x_dot: VelocityCovarianceType,
971    #[serde(rename = "CY_DOT_Y_DOT")]
972    pub cy_dot_y_dot: VelocityCovarianceType,
973    #[serde(rename = "CZ_DOT_X")]
974    pub cz_dot_x: PositionVelocityCovarianceType,
975    #[serde(rename = "CZ_DOT_Y")]
976    pub cz_dot_y: PositionVelocityCovarianceType,
977    #[serde(rename = "CZ_DOT_Z")]
978    pub cz_dot_z: PositionVelocityCovarianceType,
979    #[serde(rename = "CZ_DOT_X_DOT")]
980    pub cz_dot_x_dot: VelocityCovarianceType,
981    #[serde(rename = "CZ_DOT_Y_DOT")]
982    pub cz_dot_y_dot: VelocityCovarianceType,
983    #[serde(rename = "CZ_DOT_Z_DOT")]
984    pub cz_dot_z_dot: VelocityCovarianceType,
985}
986
987#[derive(
988    Clone,
989    Debug,
990    Default,
991    PartialEq,
992    serde::Deserialize,
993    serde::Serialize,
994    lox_derive::KvnDeserialize,
995)]
996#[serde(default)]
997#[kvn(value_unit_struct)]
998pub struct PositionCovarianceType {
999    #[serde(rename = "$text")]
1000    pub base: f64,
1001    #[serde(rename = "@units")]
1002    pub units: Option<PositionCovarianceUnits>,
1003}
1004
1005#[derive(
1006    Clone,
1007    Debug,
1008    Default,
1009    PartialEq,
1010    serde::Deserialize,
1011    serde::Serialize,
1012    lox_derive::KvnDeserialize,
1013)]
1014#[serde(default)]
1015#[kvn(value_unit_struct)]
1016pub struct VelocityCovarianceType {
1017    #[serde(rename = "$text")]
1018    pub base: f64,
1019    #[serde(rename = "@units")]
1020    pub units: Option<VelocityCovarianceUnits>,
1021}
1022
1023#[derive(
1024    Clone,
1025    Debug,
1026    Default,
1027    PartialEq,
1028    serde::Deserialize,
1029    serde::Serialize,
1030    lox_derive::KvnDeserialize,
1031)]
1032#[serde(default)]
1033#[kvn(value_unit_struct)]
1034pub struct PositionVelocityCovarianceType {
1035    #[serde(rename = "$text")]
1036    pub base: f64,
1037    #[serde(rename = "@units")]
1038    pub units: Option<PositionVelocityCovarianceUnits>,
1039}
1040
1041#[derive(
1042    Clone,
1043    Debug,
1044    Default,
1045    PartialEq,
1046    serde::Deserialize,
1047    serde::Serialize,
1048    lox_derive::KvnDeserialize,
1049)]
1050#[serde(default)]
1051pub struct UserDefinedType {
1052    #[serde(rename = "COMMENT")]
1053    pub comment_list: Vec<String>,
1054    #[serde(rename = "USER_DEFINED")]
1055    pub user_defined_list: Vec<UserDefinedParameterType>,
1056}
1057
1058#[derive(
1059    Clone,
1060    Debug,
1061    Default,
1062    PartialEq,
1063    serde::Deserialize,
1064    serde::Serialize,
1065    lox_derive::KvnDeserialize,
1066)]
1067#[serde(default)]
1068pub struct UserDefinedParameterType {
1069    #[serde(rename = "$text")]
1070    pub base: String,
1071    #[serde(rename = "@parameter")]
1072    pub parameter: String,
1073}
lox_io/ndm/common.rs

lox_io/ndm/
common.rs
