Line data Source code
1 :
2 : /*
3 : * ALMA - Atacama Large Millimeter Array
4 : * (c) European Southern Observatory, 2002
5 : * (c) Associated Universities Inc., 2002
6 : * Copyright by ESO (in the framework of the ALMA collaboration),
7 : * Copyright by AUI (in the framework of the ALMA collaboration),
8 : * All rights reserved.
9 : *
10 : * This library is free software; you can redistribute it and/or
11 : * modify it under the terms of the GNU Lesser General Public
12 : * License as published by the Free software Foundation; either
13 : * version 2.1 of the License, or (at your option) any later version.
14 : *
15 : * This library is distributed in the hope that it will be useful,
16 : * but WITHOUT ANY WARRANTY, without even the implied warranty of
17 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : * Lesser General Public License for more details.
19 : *
20 : * You should have received a copy of the GNU Lesser General Public
21 : * License along with this library; if not, write to the Free Software
22 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 : * MA 02111-1307 USA
24 : *
25 : * Warning!
26 : * --------------------------------------------------------------------
27 : * | This is generated code! Do not modify this file. |
28 : * | If you do, all changes will be lost when the file is re-generated. |
29 : * --------------------------------------------------------------------
30 : *
31 : * File DelayModelRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/DelayModelRow.h>
39 : #include <alma/ASDM/DelayModelTable.h>
40 :
41 : #include <alma/ASDM/AntennaTable.h>
42 : #include <alma/ASDM/AntennaRow.h>
43 :
44 : #include <alma/ASDM/SpectralWindowTable.h>
45 : #include <alma/ASDM/SpectralWindowRow.h>
46 :
47 : #include <alma/ASDM/FieldTable.h>
48 : #include <alma/ASDM/FieldRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::DelayModelRow;
53 : using asdm::DelayModelTable;
54 :
55 : using asdm::AntennaTable;
56 : using asdm::AntennaRow;
57 :
58 : using asdm::SpectralWindowTable;
59 : using asdm::SpectralWindowRow;
60 :
61 : using asdm::FieldTable;
62 : using asdm::FieldRow;
63 :
64 :
65 : #include <alma/ASDM/Parser.h>
66 :
67 : #include <alma/ASDM/EnumerationParser.h>
68 : #include <alma/ASDM/ASDMValuesParser.h>
69 :
70 : #include <alma/ASDM/InvalidArgumentException.h>
71 :
72 : using namespace std;
73 :
74 : namespace asdm {
75 0 : DelayModelRow::~DelayModelRow() {
76 0 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 0 : DelayModelTable &DelayModelRow::getTable() const {
82 0 : return table;
83 : }
84 :
85 0 : bool DelayModelRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 0 : void DelayModelRow::isAdded(bool added) {
90 0 : hasBeenAdded = added;
91 0 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::DelayModelRowIDL;
95 : #endif
96 :
97 : #ifndef WITHOUT_ACS
98 : /**
99 : * Return this row in the form of an IDL struct.
100 : * @return The values of this row as a DelayModelRowIDL struct.
101 : */
102 : DelayModelRowIDL *DelayModelRow::toIDL() const {
103 : DelayModelRowIDL *x = new DelayModelRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->timeInterval = timeInterval.toIDLArrayTimeInterval();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 : x->numPoly = numPoly;
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 : x->phaseDelay.length(phaseDelay.size());
136 : for (unsigned int i = 0; i < phaseDelay.size(); ++i) {
137 :
138 :
139 : x->phaseDelay[i] = phaseDelay.at(i);
140 :
141 :
142 : }
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 : x->phaseDelayRate.length(phaseDelayRate.size());
153 : for (unsigned int i = 0; i < phaseDelayRate.size(); ++i) {
154 :
155 :
156 : x->phaseDelayRate[i] = phaseDelayRate.at(i);
157 :
158 :
159 : }
160 :
161 :
162 :
163 :
164 :
165 :
166 :
167 :
168 :
169 : x->groupDelay.length(groupDelay.size());
170 : for (unsigned int i = 0; i < groupDelay.size(); ++i) {
171 :
172 :
173 : x->groupDelay[i] = groupDelay.at(i);
174 :
175 :
176 : }
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 : x->groupDelayRate.length(groupDelayRate.size());
187 : for (unsigned int i = 0; i < groupDelayRate.size(); ++i) {
188 :
189 :
190 : x->groupDelayRate[i] = groupDelayRate.at(i);
191 :
192 :
193 : }
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 : x->timeOriginExists = timeOriginExists;
202 :
203 :
204 :
205 : x->timeOrigin = timeOrigin.toIDLArrayTime();
206 :
207 :
208 :
209 :
210 :
211 :
212 :
213 : x->atmosphericGroupDelayExists = atmosphericGroupDelayExists;
214 :
215 :
216 :
217 :
218 : x->atmosphericGroupDelay = atmosphericGroupDelay;
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 : x->atmosphericGroupDelayRateExists = atmosphericGroupDelayRateExists;
228 :
229 :
230 :
231 :
232 : x->atmosphericGroupDelayRate = atmosphericGroupDelayRate;
233 :
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 : x->geometricDelayExists = geometricDelayExists;
242 :
243 :
244 :
245 :
246 : x->geometricDelay = geometricDelay;
247 :
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 : x->geometricDelayRateExists = geometricDelayRateExists;
256 :
257 :
258 :
259 :
260 : x->geometricDelayRate = geometricDelayRate;
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 : x->numLOExists = numLOExists;
270 :
271 :
272 :
273 :
274 : x->numLO = numLO;
275 :
276 :
277 :
278 :
279 :
280 :
281 :
282 :
283 : x->LOOffsetExists = LOOffsetExists;
284 :
285 :
286 :
287 : x->LOOffset.length(LOOffset.size());
288 : for (unsigned int i = 0; i < LOOffset.size(); ++i) {
289 :
290 : x->LOOffset[i] = LOOffset.at(i).toIDLFrequency();
291 :
292 : }
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 : x->LOOffsetRateExists = LOOffsetRateExists;
301 :
302 :
303 :
304 : x->LOOffsetRate.length(LOOffsetRate.size());
305 : for (unsigned int i = 0; i < LOOffsetRate.size(); ++i) {
306 :
307 : x->LOOffsetRate[i] = LOOffsetRate.at(i).toIDLFrequency();
308 :
309 : }
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 : x->dispersiveDelayExists = dispersiveDelayExists;
318 :
319 :
320 :
321 :
322 : x->dispersiveDelay = dispersiveDelay;
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 :
331 : x->dispersiveDelayRateExists = dispersiveDelayRateExists;
332 :
333 :
334 :
335 :
336 : x->dispersiveDelayRate = dispersiveDelayRate;
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 : x->atmosphericDryDelayExists = atmosphericDryDelayExists;
346 :
347 :
348 :
349 :
350 : x->atmosphericDryDelay = atmosphericDryDelay;
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 : x->atmosphericWetDelayExists = atmosphericWetDelayExists;
360 :
361 :
362 :
363 :
364 : x->atmosphericWetDelay = atmosphericWetDelay;
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 : x->padDelayExists = padDelayExists;
374 :
375 :
376 :
377 :
378 : x->padDelay = padDelay;
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 : x->antennaDelayExists = antennaDelayExists;
388 :
389 :
390 :
391 :
392 : x->antennaDelay = antennaDelay;
393 :
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 : x->numReceptorExists = numReceptorExists;
402 :
403 :
404 :
405 :
406 : x->numReceptor = numReceptor;
407 :
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 : x->polarizationTypeExists = polarizationTypeExists;
416 :
417 :
418 :
419 : x->polarizationType.length(polarizationType.size());
420 : for (unsigned int i = 0; i < polarizationType.size(); ++i) {
421 :
422 :
423 : x->polarizationType[i] = polarizationType.at(i);
424 :
425 :
426 : }
427 :
428 :
429 :
430 :
431 :
432 :
433 :
434 : x->electronicDelayExists = electronicDelayExists;
435 :
436 :
437 :
438 : x->electronicDelay.length(electronicDelay.size());
439 : for (unsigned int i = 0; i < electronicDelay.size(); ++i) {
440 :
441 :
442 : x->electronicDelay[i] = electronicDelay.at(i);
443 :
444 :
445 : }
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 : x->electronicDelayRateExists = electronicDelayRateExists;
454 :
455 :
456 :
457 : x->electronicDelayRate.length(electronicDelayRate.size());
458 : for (unsigned int i = 0; i < electronicDelayRate.size(); ++i) {
459 :
460 :
461 : x->electronicDelayRate[i] = electronicDelayRate.at(i);
462 :
463 :
464 : }
465 :
466 :
467 :
468 :
469 :
470 :
471 :
472 : x->receiverDelayExists = receiverDelayExists;
473 :
474 :
475 :
476 : x->receiverDelay.length(receiverDelay.size());
477 : for (unsigned int i = 0; i < receiverDelay.size(); ++i) {
478 :
479 :
480 : x->receiverDelay[i] = receiverDelay.at(i);
481 :
482 :
483 : }
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 : x->IFDelayExists = IFDelayExists;
492 :
493 :
494 :
495 : x->IFDelay.length(IFDelay.size());
496 : for (unsigned int i = 0; i < IFDelay.size(); ++i) {
497 :
498 :
499 : x->IFDelay[i] = IFDelay.at(i);
500 :
501 :
502 : }
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 : x->LODelayExists = LODelayExists;
511 :
512 :
513 :
514 : x->LODelay.length(LODelay.size());
515 : for (unsigned int i = 0; i < LODelay.size(); ++i) {
516 :
517 :
518 : x->LODelay[i] = LODelay.at(i);
519 :
520 :
521 : }
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 : x->crossPolarizationDelayExists = crossPolarizationDelayExists;
530 :
531 :
532 :
533 :
534 : x->crossPolarizationDelay = crossPolarizationDelay;
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 :
546 :
547 :
548 :
549 : x->antennaId = antennaId.toIDLTag();
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 :
558 :
559 :
560 : x->fieldId = fieldId.toIDLTag();
561 :
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 :
570 :
571 : x->spectralWindowId = spectralWindowId.toIDLTag();
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 : return x;
586 :
587 : }
588 :
589 : void DelayModelRow::toIDL(asdmIDL::DelayModelRowIDL& x) const {
590 : // Set the x's fields.
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 : x.timeInterval = timeInterval.toIDLArrayTimeInterval();
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 :
608 :
609 : x.numPoly = numPoly;
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 :
618 :
619 :
620 : x.phaseDelay.length(phaseDelay.size());
621 : for (unsigned int i = 0; i < phaseDelay.size(); ++i) {
622 :
623 :
624 : x.phaseDelay[i] = phaseDelay.at(i);
625 :
626 :
627 : }
628 :
629 :
630 :
631 :
632 :
633 :
634 :
635 :
636 :
637 : x.phaseDelayRate.length(phaseDelayRate.size());
638 : for (unsigned int i = 0; i < phaseDelayRate.size(); ++i) {
639 :
640 :
641 : x.phaseDelayRate[i] = phaseDelayRate.at(i);
642 :
643 :
644 : }
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 : x.groupDelay.length(groupDelay.size());
655 : for (unsigned int i = 0; i < groupDelay.size(); ++i) {
656 :
657 :
658 : x.groupDelay[i] = groupDelay.at(i);
659 :
660 :
661 : }
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 :
671 : x.groupDelayRate.length(groupDelayRate.size());
672 : for (unsigned int i = 0; i < groupDelayRate.size(); ++i) {
673 :
674 :
675 : x.groupDelayRate[i] = groupDelayRate.at(i);
676 :
677 :
678 : }
679 :
680 :
681 :
682 :
683 :
684 :
685 :
686 : x.timeOriginExists = timeOriginExists;
687 :
688 :
689 :
690 : x.timeOrigin = timeOrigin.toIDLArrayTime();
691 :
692 :
693 :
694 :
695 :
696 :
697 :
698 : x.atmosphericGroupDelayExists = atmosphericGroupDelayExists;
699 :
700 :
701 :
702 :
703 : x.atmosphericGroupDelay = atmosphericGroupDelay;
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 : x.atmosphericGroupDelayRateExists = atmosphericGroupDelayRateExists;
713 :
714 :
715 :
716 :
717 : x.atmosphericGroupDelayRate = atmosphericGroupDelayRate;
718 :
719 :
720 :
721 :
722 :
723 :
724 :
725 :
726 : x.geometricDelayExists = geometricDelayExists;
727 :
728 :
729 :
730 :
731 : x.geometricDelay = geometricDelay;
732 :
733 :
734 :
735 :
736 :
737 :
738 :
739 :
740 : x.geometricDelayRateExists = geometricDelayRateExists;
741 :
742 :
743 :
744 :
745 : x.geometricDelayRate = geometricDelayRate;
746 :
747 :
748 :
749 :
750 :
751 :
752 :
753 :
754 : x.numLOExists = numLOExists;
755 :
756 :
757 :
758 :
759 : x.numLO = numLO;
760 :
761 :
762 :
763 :
764 :
765 :
766 :
767 :
768 : x.LOOffsetExists = LOOffsetExists;
769 :
770 :
771 :
772 : x.LOOffset.length(LOOffset.size());
773 : for (unsigned int i = 0; i < LOOffset.size(); ++i) {
774 :
775 : x.LOOffset[i] = LOOffset.at(i).toIDLFrequency();
776 :
777 : }
778 :
779 :
780 :
781 :
782 :
783 :
784 :
785 : x.LOOffsetRateExists = LOOffsetRateExists;
786 :
787 :
788 :
789 : x.LOOffsetRate.length(LOOffsetRate.size());
790 : for (unsigned int i = 0; i < LOOffsetRate.size(); ++i) {
791 :
792 : x.LOOffsetRate[i] = LOOffsetRate.at(i).toIDLFrequency();
793 :
794 : }
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 : x.dispersiveDelayExists = dispersiveDelayExists;
803 :
804 :
805 :
806 :
807 : x.dispersiveDelay = dispersiveDelay;
808 :
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 : x.dispersiveDelayRateExists = dispersiveDelayRateExists;
817 :
818 :
819 :
820 :
821 : x.dispersiveDelayRate = dispersiveDelayRate;
822 :
823 :
824 :
825 :
826 :
827 :
828 :
829 :
830 : x.atmosphericDryDelayExists = atmosphericDryDelayExists;
831 :
832 :
833 :
834 :
835 : x.atmosphericDryDelay = atmosphericDryDelay;
836 :
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 : x.atmosphericWetDelayExists = atmosphericWetDelayExists;
845 :
846 :
847 :
848 :
849 : x.atmosphericWetDelay = atmosphericWetDelay;
850 :
851 :
852 :
853 :
854 :
855 :
856 :
857 :
858 : x.padDelayExists = padDelayExists;
859 :
860 :
861 :
862 :
863 : x.padDelay = padDelay;
864 :
865 :
866 :
867 :
868 :
869 :
870 :
871 :
872 : x.antennaDelayExists = antennaDelayExists;
873 :
874 :
875 :
876 :
877 : x.antennaDelay = antennaDelay;
878 :
879 :
880 :
881 :
882 :
883 :
884 :
885 :
886 : x.numReceptorExists = numReceptorExists;
887 :
888 :
889 :
890 :
891 : x.numReceptor = numReceptor;
892 :
893 :
894 :
895 :
896 :
897 :
898 :
899 :
900 : x.polarizationTypeExists = polarizationTypeExists;
901 :
902 :
903 :
904 : x.polarizationType.length(polarizationType.size());
905 : for (unsigned int i = 0; i < polarizationType.size(); ++i) {
906 :
907 :
908 : x.polarizationType[i] = polarizationType.at(i);
909 :
910 :
911 : }
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 : x.electronicDelayExists = electronicDelayExists;
920 :
921 :
922 :
923 : x.electronicDelay.length(electronicDelay.size());
924 : for (unsigned int i = 0; i < electronicDelay.size(); ++i) {
925 :
926 :
927 : x.electronicDelay[i] = electronicDelay.at(i);
928 :
929 :
930 : }
931 :
932 :
933 :
934 :
935 :
936 :
937 :
938 : x.electronicDelayRateExists = electronicDelayRateExists;
939 :
940 :
941 :
942 : x.electronicDelayRate.length(electronicDelayRate.size());
943 : for (unsigned int i = 0; i < electronicDelayRate.size(); ++i) {
944 :
945 :
946 : x.electronicDelayRate[i] = electronicDelayRate.at(i);
947 :
948 :
949 : }
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 : x.receiverDelayExists = receiverDelayExists;
958 :
959 :
960 :
961 : x.receiverDelay.length(receiverDelay.size());
962 : for (unsigned int i = 0; i < receiverDelay.size(); ++i) {
963 :
964 :
965 : x.receiverDelay[i] = receiverDelay.at(i);
966 :
967 :
968 : }
969 :
970 :
971 :
972 :
973 :
974 :
975 :
976 : x.IFDelayExists = IFDelayExists;
977 :
978 :
979 :
980 : x.IFDelay.length(IFDelay.size());
981 : for (unsigned int i = 0; i < IFDelay.size(); ++i) {
982 :
983 :
984 : x.IFDelay[i] = IFDelay.at(i);
985 :
986 :
987 : }
988 :
989 :
990 :
991 :
992 :
993 :
994 :
995 : x.LODelayExists = LODelayExists;
996 :
997 :
998 :
999 : x.LODelay.length(LODelay.size());
1000 : for (unsigned int i = 0; i < LODelay.size(); ++i) {
1001 :
1002 :
1003 : x.LODelay[i] = LODelay.at(i);
1004 :
1005 :
1006 : }
1007 :
1008 :
1009 :
1010 :
1011 :
1012 :
1013 :
1014 : x.crossPolarizationDelayExists = crossPolarizationDelayExists;
1015 :
1016 :
1017 :
1018 :
1019 : x.crossPolarizationDelay = crossPolarizationDelay;
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 :
1029 :
1030 :
1031 :
1032 :
1033 :
1034 : x.antennaId = antennaId.toIDLTag();
1035 :
1036 :
1037 :
1038 :
1039 :
1040 :
1041 :
1042 :
1043 :
1044 :
1045 : x.fieldId = fieldId.toIDLTag();
1046 :
1047 :
1048 :
1049 :
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 : x.spectralWindowId = spectralWindowId.toIDLTag();
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 :
1064 :
1065 :
1066 :
1067 :
1068 :
1069 :
1070 : }
1071 : #endif
1072 :
1073 :
1074 : #ifndef WITHOUT_ACS
1075 : /**
1076 : * Fill the values of this row from the IDL struct DelayModelRowIDL.
1077 : * @param x The IDL struct containing the values used to fill this row.
1078 : */
1079 : void DelayModelRow::setFromIDL (DelayModelRowIDL x){
1080 : try {
1081 : // Fill the values from x.
1082 :
1083 :
1084 :
1085 :
1086 :
1087 :
1088 : setTimeInterval(ArrayTimeInterval (x.timeInterval));
1089 :
1090 :
1091 :
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 : setNumPoly(x.numPoly);
1099 :
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 :
1108 : phaseDelay .clear();
1109 : for (unsigned int i = 0; i <x.phaseDelay.length(); ++i) {
1110 :
1111 : phaseDelay.push_back(x.phaseDelay[i]);
1112 :
1113 : }
1114 :
1115 :
1116 :
1117 :
1118 :
1119 :
1120 :
1121 :
1122 :
1123 : phaseDelayRate .clear();
1124 : for (unsigned int i = 0; i <x.phaseDelayRate.length(); ++i) {
1125 :
1126 : phaseDelayRate.push_back(x.phaseDelayRate[i]);
1127 :
1128 : }
1129 :
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 : groupDelay .clear();
1139 : for (unsigned int i = 0; i <x.groupDelay.length(); ++i) {
1140 :
1141 : groupDelay.push_back(x.groupDelay[i]);
1142 :
1143 : }
1144 :
1145 :
1146 :
1147 :
1148 :
1149 :
1150 :
1151 :
1152 :
1153 : groupDelayRate .clear();
1154 : for (unsigned int i = 0; i <x.groupDelayRate.length(); ++i) {
1155 :
1156 : groupDelayRate.push_back(x.groupDelayRate[i]);
1157 :
1158 : }
1159 :
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 : timeOriginExists = x.timeOriginExists;
1167 : if (x.timeOriginExists) {
1168 :
1169 :
1170 :
1171 : setTimeOrigin(ArrayTime (x.timeOrigin));
1172 :
1173 :
1174 :
1175 : }
1176 :
1177 :
1178 :
1179 :
1180 :
1181 : atmosphericGroupDelayExists = x.atmosphericGroupDelayExists;
1182 : if (x.atmosphericGroupDelayExists) {
1183 :
1184 :
1185 :
1186 : setAtmosphericGroupDelay(x.atmosphericGroupDelay);
1187 :
1188 :
1189 :
1190 : }
1191 :
1192 :
1193 :
1194 :
1195 :
1196 : atmosphericGroupDelayRateExists = x.atmosphericGroupDelayRateExists;
1197 : if (x.atmosphericGroupDelayRateExists) {
1198 :
1199 :
1200 :
1201 : setAtmosphericGroupDelayRate(x.atmosphericGroupDelayRate);
1202 :
1203 :
1204 :
1205 : }
1206 :
1207 :
1208 :
1209 :
1210 :
1211 : geometricDelayExists = x.geometricDelayExists;
1212 : if (x.geometricDelayExists) {
1213 :
1214 :
1215 :
1216 : setGeometricDelay(x.geometricDelay);
1217 :
1218 :
1219 :
1220 : }
1221 :
1222 :
1223 :
1224 :
1225 :
1226 : geometricDelayRateExists = x.geometricDelayRateExists;
1227 : if (x.geometricDelayRateExists) {
1228 :
1229 :
1230 :
1231 : setGeometricDelayRate(x.geometricDelayRate);
1232 :
1233 :
1234 :
1235 : }
1236 :
1237 :
1238 :
1239 :
1240 :
1241 : numLOExists = x.numLOExists;
1242 : if (x.numLOExists) {
1243 :
1244 :
1245 :
1246 : setNumLO(x.numLO);
1247 :
1248 :
1249 :
1250 : }
1251 :
1252 :
1253 :
1254 :
1255 :
1256 : LOOffsetExists = x.LOOffsetExists;
1257 : if (x.LOOffsetExists) {
1258 :
1259 :
1260 :
1261 : LOOffset .clear();
1262 : for (unsigned int i = 0; i <x.LOOffset.length(); ++i) {
1263 :
1264 : LOOffset.push_back(Frequency (x.LOOffset[i]));
1265 :
1266 : }
1267 :
1268 :
1269 :
1270 : }
1271 :
1272 :
1273 :
1274 :
1275 :
1276 : LOOffsetRateExists = x.LOOffsetRateExists;
1277 : if (x.LOOffsetRateExists) {
1278 :
1279 :
1280 :
1281 : LOOffsetRate .clear();
1282 : for (unsigned int i = 0; i <x.LOOffsetRate.length(); ++i) {
1283 :
1284 : LOOffsetRate.push_back(Frequency (x.LOOffsetRate[i]));
1285 :
1286 : }
1287 :
1288 :
1289 :
1290 : }
1291 :
1292 :
1293 :
1294 :
1295 :
1296 : dispersiveDelayExists = x.dispersiveDelayExists;
1297 : if (x.dispersiveDelayExists) {
1298 :
1299 :
1300 :
1301 : setDispersiveDelay(x.dispersiveDelay);
1302 :
1303 :
1304 :
1305 : }
1306 :
1307 :
1308 :
1309 :
1310 :
1311 : dispersiveDelayRateExists = x.dispersiveDelayRateExists;
1312 : if (x.dispersiveDelayRateExists) {
1313 :
1314 :
1315 :
1316 : setDispersiveDelayRate(x.dispersiveDelayRate);
1317 :
1318 :
1319 :
1320 : }
1321 :
1322 :
1323 :
1324 :
1325 :
1326 : atmosphericDryDelayExists = x.atmosphericDryDelayExists;
1327 : if (x.atmosphericDryDelayExists) {
1328 :
1329 :
1330 :
1331 : setAtmosphericDryDelay(x.atmosphericDryDelay);
1332 :
1333 :
1334 :
1335 : }
1336 :
1337 :
1338 :
1339 :
1340 :
1341 : atmosphericWetDelayExists = x.atmosphericWetDelayExists;
1342 : if (x.atmosphericWetDelayExists) {
1343 :
1344 :
1345 :
1346 : setAtmosphericWetDelay(x.atmosphericWetDelay);
1347 :
1348 :
1349 :
1350 : }
1351 :
1352 :
1353 :
1354 :
1355 :
1356 : padDelayExists = x.padDelayExists;
1357 : if (x.padDelayExists) {
1358 :
1359 :
1360 :
1361 : setPadDelay(x.padDelay);
1362 :
1363 :
1364 :
1365 : }
1366 :
1367 :
1368 :
1369 :
1370 :
1371 : antennaDelayExists = x.antennaDelayExists;
1372 : if (x.antennaDelayExists) {
1373 :
1374 :
1375 :
1376 : setAntennaDelay(x.antennaDelay);
1377 :
1378 :
1379 :
1380 : }
1381 :
1382 :
1383 :
1384 :
1385 :
1386 : numReceptorExists = x.numReceptorExists;
1387 : if (x.numReceptorExists) {
1388 :
1389 :
1390 :
1391 : setNumReceptor(x.numReceptor);
1392 :
1393 :
1394 :
1395 : }
1396 :
1397 :
1398 :
1399 :
1400 :
1401 : polarizationTypeExists = x.polarizationTypeExists;
1402 : if (x.polarizationTypeExists) {
1403 :
1404 :
1405 :
1406 : polarizationType .clear();
1407 : for (unsigned int i = 0; i <x.polarizationType.length(); ++i) {
1408 :
1409 : polarizationType.push_back(x.polarizationType[i]);
1410 :
1411 : }
1412 :
1413 :
1414 :
1415 : }
1416 :
1417 :
1418 :
1419 :
1420 :
1421 : electronicDelayExists = x.electronicDelayExists;
1422 : if (x.electronicDelayExists) {
1423 :
1424 :
1425 :
1426 : electronicDelay .clear();
1427 : for (unsigned int i = 0; i <x.electronicDelay.length(); ++i) {
1428 :
1429 : electronicDelay.push_back(x.electronicDelay[i]);
1430 :
1431 : }
1432 :
1433 :
1434 :
1435 : }
1436 :
1437 :
1438 :
1439 :
1440 :
1441 : electronicDelayRateExists = x.electronicDelayRateExists;
1442 : if (x.electronicDelayRateExists) {
1443 :
1444 :
1445 :
1446 : electronicDelayRate .clear();
1447 : for (unsigned int i = 0; i <x.electronicDelayRate.length(); ++i) {
1448 :
1449 : electronicDelayRate.push_back(x.electronicDelayRate[i]);
1450 :
1451 : }
1452 :
1453 :
1454 :
1455 : }
1456 :
1457 :
1458 :
1459 :
1460 :
1461 : receiverDelayExists = x.receiverDelayExists;
1462 : if (x.receiverDelayExists) {
1463 :
1464 :
1465 :
1466 : receiverDelay .clear();
1467 : for (unsigned int i = 0; i <x.receiverDelay.length(); ++i) {
1468 :
1469 : receiverDelay.push_back(x.receiverDelay[i]);
1470 :
1471 : }
1472 :
1473 :
1474 :
1475 : }
1476 :
1477 :
1478 :
1479 :
1480 :
1481 : IFDelayExists = x.IFDelayExists;
1482 : if (x.IFDelayExists) {
1483 :
1484 :
1485 :
1486 : IFDelay .clear();
1487 : for (unsigned int i = 0; i <x.IFDelay.length(); ++i) {
1488 :
1489 : IFDelay.push_back(x.IFDelay[i]);
1490 :
1491 : }
1492 :
1493 :
1494 :
1495 : }
1496 :
1497 :
1498 :
1499 :
1500 :
1501 : LODelayExists = x.LODelayExists;
1502 : if (x.LODelayExists) {
1503 :
1504 :
1505 :
1506 : LODelay .clear();
1507 : for (unsigned int i = 0; i <x.LODelay.length(); ++i) {
1508 :
1509 : LODelay.push_back(x.LODelay[i]);
1510 :
1511 : }
1512 :
1513 :
1514 :
1515 : }
1516 :
1517 :
1518 :
1519 :
1520 :
1521 : crossPolarizationDelayExists = x.crossPolarizationDelayExists;
1522 : if (x.crossPolarizationDelayExists) {
1523 :
1524 :
1525 :
1526 : setCrossPolarizationDelay(x.crossPolarizationDelay);
1527 :
1528 :
1529 :
1530 : }
1531 :
1532 :
1533 :
1534 :
1535 :
1536 :
1537 :
1538 :
1539 :
1540 :
1541 : setAntennaId(Tag (x.antennaId));
1542 :
1543 :
1544 :
1545 :
1546 :
1547 :
1548 :
1549 :
1550 :
1551 : setFieldId(Tag (x.fieldId));
1552 :
1553 :
1554 :
1555 :
1556 :
1557 :
1558 :
1559 :
1560 :
1561 : setSpectralWindowId(Tag (x.spectralWindowId));
1562 :
1563 :
1564 :
1565 :
1566 :
1567 :
1568 :
1569 :
1570 :
1571 :
1572 :
1573 :
1574 :
1575 : } catch (const IllegalAccessException &err) {
1576 : throw ConversionException (err.getMessage(),"DelayModel");
1577 : }
1578 : }
1579 : #endif
1580 :
1581 : /**
1582 : * Return this row in the form of an XML string.
1583 : * @return The values of this row as an XML string.
1584 : */
1585 0 : string DelayModelRow::toXML() const {
1586 0 : string buf;
1587 0 : buf.append("<row> \n");
1588 :
1589 :
1590 :
1591 :
1592 :
1593 :
1594 0 : Parser::toXML(timeInterval, "timeInterval", buf);
1595 :
1596 :
1597 :
1598 :
1599 :
1600 :
1601 :
1602 0 : Parser::toXML(numPoly, "numPoly", buf);
1603 :
1604 :
1605 :
1606 :
1607 :
1608 :
1609 :
1610 0 : Parser::toXML(phaseDelay, "phaseDelay", buf);
1611 :
1612 :
1613 :
1614 :
1615 :
1616 :
1617 :
1618 0 : Parser::toXML(phaseDelayRate, "phaseDelayRate", buf);
1619 :
1620 :
1621 :
1622 :
1623 :
1624 :
1625 :
1626 0 : Parser::toXML(groupDelay, "groupDelay", buf);
1627 :
1628 :
1629 :
1630 :
1631 :
1632 :
1633 :
1634 0 : Parser::toXML(groupDelayRate, "groupDelayRate", buf);
1635 :
1636 :
1637 :
1638 :
1639 :
1640 :
1641 0 : if (timeOriginExists) {
1642 :
1643 :
1644 0 : Parser::toXML(timeOrigin, "timeOrigin", buf);
1645 :
1646 :
1647 : }
1648 :
1649 :
1650 :
1651 :
1652 :
1653 0 : if (atmosphericGroupDelayExists) {
1654 :
1655 :
1656 0 : Parser::toXML(atmosphericGroupDelay, "atmosphericGroupDelay", buf);
1657 :
1658 :
1659 : }
1660 :
1661 :
1662 :
1663 :
1664 :
1665 0 : if (atmosphericGroupDelayRateExists) {
1666 :
1667 :
1668 0 : Parser::toXML(atmosphericGroupDelayRate, "atmosphericGroupDelayRate", buf);
1669 :
1670 :
1671 : }
1672 :
1673 :
1674 :
1675 :
1676 :
1677 0 : if (geometricDelayExists) {
1678 :
1679 :
1680 0 : Parser::toXML(geometricDelay, "geometricDelay", buf);
1681 :
1682 :
1683 : }
1684 :
1685 :
1686 :
1687 :
1688 :
1689 0 : if (geometricDelayRateExists) {
1690 :
1691 :
1692 0 : Parser::toXML(geometricDelayRate, "geometricDelayRate", buf);
1693 :
1694 :
1695 : }
1696 :
1697 :
1698 :
1699 :
1700 :
1701 0 : if (numLOExists) {
1702 :
1703 :
1704 0 : Parser::toXML(numLO, "numLO", buf);
1705 :
1706 :
1707 : }
1708 :
1709 :
1710 :
1711 :
1712 :
1713 0 : if (LOOffsetExists) {
1714 :
1715 :
1716 0 : Parser::toXML(LOOffset, "LOOffset", buf);
1717 :
1718 :
1719 : }
1720 :
1721 :
1722 :
1723 :
1724 :
1725 0 : if (LOOffsetRateExists) {
1726 :
1727 :
1728 0 : Parser::toXML(LOOffsetRate, "LOOffsetRate", buf);
1729 :
1730 :
1731 : }
1732 :
1733 :
1734 :
1735 :
1736 :
1737 0 : if (dispersiveDelayExists) {
1738 :
1739 :
1740 0 : Parser::toXML(dispersiveDelay, "dispersiveDelay", buf);
1741 :
1742 :
1743 : }
1744 :
1745 :
1746 :
1747 :
1748 :
1749 0 : if (dispersiveDelayRateExists) {
1750 :
1751 :
1752 0 : Parser::toXML(dispersiveDelayRate, "dispersiveDelayRate", buf);
1753 :
1754 :
1755 : }
1756 :
1757 :
1758 :
1759 :
1760 :
1761 0 : if (atmosphericDryDelayExists) {
1762 :
1763 :
1764 0 : Parser::toXML(atmosphericDryDelay, "atmosphericDryDelay", buf);
1765 :
1766 :
1767 : }
1768 :
1769 :
1770 :
1771 :
1772 :
1773 0 : if (atmosphericWetDelayExists) {
1774 :
1775 :
1776 0 : Parser::toXML(atmosphericWetDelay, "atmosphericWetDelay", buf);
1777 :
1778 :
1779 : }
1780 :
1781 :
1782 :
1783 :
1784 :
1785 0 : if (padDelayExists) {
1786 :
1787 :
1788 0 : Parser::toXML(padDelay, "padDelay", buf);
1789 :
1790 :
1791 : }
1792 :
1793 :
1794 :
1795 :
1796 :
1797 0 : if (antennaDelayExists) {
1798 :
1799 :
1800 0 : Parser::toXML(antennaDelay, "antennaDelay", buf);
1801 :
1802 :
1803 : }
1804 :
1805 :
1806 :
1807 :
1808 :
1809 0 : if (numReceptorExists) {
1810 :
1811 :
1812 0 : Parser::toXML(numReceptor, "numReceptor", buf);
1813 :
1814 :
1815 : }
1816 :
1817 :
1818 :
1819 :
1820 :
1821 0 : if (polarizationTypeExists) {
1822 :
1823 :
1824 0 : buf.append(EnumerationParser::toXML("polarizationType", polarizationType));
1825 :
1826 :
1827 : }
1828 :
1829 :
1830 :
1831 :
1832 :
1833 0 : if (electronicDelayExists) {
1834 :
1835 :
1836 0 : Parser::toXML(electronicDelay, "electronicDelay", buf);
1837 :
1838 :
1839 : }
1840 :
1841 :
1842 :
1843 :
1844 :
1845 0 : if (electronicDelayRateExists) {
1846 :
1847 :
1848 0 : Parser::toXML(electronicDelayRate, "electronicDelayRate", buf);
1849 :
1850 :
1851 : }
1852 :
1853 :
1854 :
1855 :
1856 :
1857 0 : if (receiverDelayExists) {
1858 :
1859 :
1860 0 : Parser::toXML(receiverDelay, "receiverDelay", buf);
1861 :
1862 :
1863 : }
1864 :
1865 :
1866 :
1867 :
1868 :
1869 0 : if (IFDelayExists) {
1870 :
1871 :
1872 0 : Parser::toXML(IFDelay, "IFDelay", buf);
1873 :
1874 :
1875 : }
1876 :
1877 :
1878 :
1879 :
1880 :
1881 0 : if (LODelayExists) {
1882 :
1883 :
1884 0 : Parser::toXML(LODelay, "LODelay", buf);
1885 :
1886 :
1887 : }
1888 :
1889 :
1890 :
1891 :
1892 :
1893 0 : if (crossPolarizationDelayExists) {
1894 :
1895 :
1896 0 : Parser::toXML(crossPolarizationDelay, "crossPolarizationDelay", buf);
1897 :
1898 :
1899 : }
1900 :
1901 :
1902 :
1903 :
1904 :
1905 :
1906 :
1907 :
1908 :
1909 0 : Parser::toXML(antennaId, "antennaId", buf);
1910 :
1911 :
1912 :
1913 :
1914 :
1915 :
1916 :
1917 0 : Parser::toXML(fieldId, "fieldId", buf);
1918 :
1919 :
1920 :
1921 :
1922 :
1923 :
1924 :
1925 0 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
1926 :
1927 :
1928 :
1929 :
1930 :
1931 :
1932 :
1933 :
1934 :
1935 :
1936 :
1937 :
1938 :
1939 0 : buf.append("</row>\n");
1940 0 : return buf;
1941 : }
1942 :
1943 : /**
1944 : * Fill the values of this row from an XML string
1945 : * that was produced by the toXML() method.
1946 : * @param x The XML string being used to set the values of this row.
1947 : */
1948 0 : void DelayModelRow::setFromXML (string rowDoc) {
1949 0 : Parser row(rowDoc);
1950 0 : string s = "";
1951 : try {
1952 :
1953 :
1954 :
1955 :
1956 :
1957 0 : setTimeInterval(Parser::getArrayTimeInterval("timeInterval","DelayModel",rowDoc));
1958 :
1959 :
1960 :
1961 :
1962 :
1963 :
1964 :
1965 0 : setNumPoly(Parser::getInteger("numPoly","DelayModel",rowDoc));
1966 :
1967 :
1968 :
1969 :
1970 :
1971 :
1972 :
1973 :
1974 0 : setPhaseDelay(Parser::get1DDouble("phaseDelay","DelayModel",rowDoc));
1975 :
1976 :
1977 :
1978 :
1979 :
1980 :
1981 :
1982 :
1983 :
1984 0 : setPhaseDelayRate(Parser::get1DDouble("phaseDelayRate","DelayModel",rowDoc));
1985 :
1986 :
1987 :
1988 :
1989 :
1990 :
1991 :
1992 :
1993 :
1994 0 : setGroupDelay(Parser::get1DDouble("groupDelay","DelayModel",rowDoc));
1995 :
1996 :
1997 :
1998 :
1999 :
2000 :
2001 :
2002 :
2003 :
2004 0 : setGroupDelayRate(Parser::get1DDouble("groupDelayRate","DelayModel",rowDoc));
2005 :
2006 :
2007 :
2008 :
2009 :
2010 :
2011 :
2012 0 : if (row.isStr("<timeOrigin>")) {
2013 :
2014 0 : setTimeOrigin(Parser::getArrayTime("timeOrigin","DelayModel",rowDoc));
2015 :
2016 : }
2017 :
2018 :
2019 :
2020 :
2021 :
2022 0 : if (row.isStr("<atmosphericGroupDelay>")) {
2023 :
2024 0 : setAtmosphericGroupDelay(Parser::getDouble("atmosphericGroupDelay","DelayModel",rowDoc));
2025 :
2026 : }
2027 :
2028 :
2029 :
2030 :
2031 :
2032 0 : if (row.isStr("<atmosphericGroupDelayRate>")) {
2033 :
2034 0 : setAtmosphericGroupDelayRate(Parser::getDouble("atmosphericGroupDelayRate","DelayModel",rowDoc));
2035 :
2036 : }
2037 :
2038 :
2039 :
2040 :
2041 :
2042 0 : if (row.isStr("<geometricDelay>")) {
2043 :
2044 0 : setGeometricDelay(Parser::getDouble("geometricDelay","DelayModel",rowDoc));
2045 :
2046 : }
2047 :
2048 :
2049 :
2050 :
2051 :
2052 0 : if (row.isStr("<geometricDelayRate>")) {
2053 :
2054 0 : setGeometricDelayRate(Parser::getDouble("geometricDelayRate","DelayModel",rowDoc));
2055 :
2056 : }
2057 :
2058 :
2059 :
2060 :
2061 :
2062 0 : if (row.isStr("<numLO>")) {
2063 :
2064 0 : setNumLO(Parser::getInteger("numLO","DelayModel",rowDoc));
2065 :
2066 : }
2067 :
2068 :
2069 :
2070 :
2071 :
2072 0 : if (row.isStr("<LOOffset>")) {
2073 :
2074 :
2075 0 : setLOOffset(Parser::get1DFrequency("LOOffset","DelayModel",rowDoc));
2076 :
2077 :
2078 : }
2079 :
2080 :
2081 :
2082 :
2083 :
2084 0 : if (row.isStr("<LOOffsetRate>")) {
2085 :
2086 :
2087 0 : setLOOffsetRate(Parser::get1DFrequency("LOOffsetRate","DelayModel",rowDoc));
2088 :
2089 :
2090 : }
2091 :
2092 :
2093 :
2094 :
2095 :
2096 0 : if (row.isStr("<dispersiveDelay>")) {
2097 :
2098 0 : setDispersiveDelay(Parser::getDouble("dispersiveDelay","DelayModel",rowDoc));
2099 :
2100 : }
2101 :
2102 :
2103 :
2104 :
2105 :
2106 0 : if (row.isStr("<dispersiveDelayRate>")) {
2107 :
2108 0 : setDispersiveDelayRate(Parser::getDouble("dispersiveDelayRate","DelayModel",rowDoc));
2109 :
2110 : }
2111 :
2112 :
2113 :
2114 :
2115 :
2116 0 : if (row.isStr("<atmosphericDryDelay>")) {
2117 :
2118 0 : setAtmosphericDryDelay(Parser::getDouble("atmosphericDryDelay","DelayModel",rowDoc));
2119 :
2120 : }
2121 :
2122 :
2123 :
2124 :
2125 :
2126 0 : if (row.isStr("<atmosphericWetDelay>")) {
2127 :
2128 0 : setAtmosphericWetDelay(Parser::getDouble("atmosphericWetDelay","DelayModel",rowDoc));
2129 :
2130 : }
2131 :
2132 :
2133 :
2134 :
2135 :
2136 0 : if (row.isStr("<padDelay>")) {
2137 :
2138 0 : setPadDelay(Parser::getDouble("padDelay","DelayModel",rowDoc));
2139 :
2140 : }
2141 :
2142 :
2143 :
2144 :
2145 :
2146 0 : if (row.isStr("<antennaDelay>")) {
2147 :
2148 0 : setAntennaDelay(Parser::getDouble("antennaDelay","DelayModel",rowDoc));
2149 :
2150 : }
2151 :
2152 :
2153 :
2154 :
2155 :
2156 0 : if (row.isStr("<numReceptor>")) {
2157 :
2158 0 : setNumReceptor(Parser::getInteger("numReceptor","DelayModel",rowDoc));
2159 :
2160 : }
2161 :
2162 :
2163 :
2164 :
2165 :
2166 0 : if (row.isStr("<polarizationType>")) {
2167 :
2168 :
2169 :
2170 0 : polarizationType = EnumerationParser::getPolarizationType1D("polarizationType","DelayModel",rowDoc);
2171 :
2172 :
2173 :
2174 0 : polarizationTypeExists = true;
2175 : }
2176 :
2177 :
2178 :
2179 :
2180 :
2181 0 : if (row.isStr("<electronicDelay>")) {
2182 :
2183 :
2184 0 : setElectronicDelay(Parser::get1DDouble("electronicDelay","DelayModel",rowDoc));
2185 :
2186 :
2187 : }
2188 :
2189 :
2190 :
2191 :
2192 :
2193 0 : if (row.isStr("<electronicDelayRate>")) {
2194 :
2195 :
2196 0 : setElectronicDelayRate(Parser::get1DDouble("electronicDelayRate","DelayModel",rowDoc));
2197 :
2198 :
2199 : }
2200 :
2201 :
2202 :
2203 :
2204 :
2205 0 : if (row.isStr("<receiverDelay>")) {
2206 :
2207 :
2208 0 : setReceiverDelay(Parser::get1DDouble("receiverDelay","DelayModel",rowDoc));
2209 :
2210 :
2211 : }
2212 :
2213 :
2214 :
2215 :
2216 :
2217 0 : if (row.isStr("<IFDelay>")) {
2218 :
2219 :
2220 0 : setIFDelay(Parser::get1DDouble("IFDelay","DelayModel",rowDoc));
2221 :
2222 :
2223 : }
2224 :
2225 :
2226 :
2227 :
2228 :
2229 0 : if (row.isStr("<LODelay>")) {
2230 :
2231 :
2232 0 : setLODelay(Parser::get1DDouble("LODelay","DelayModel",rowDoc));
2233 :
2234 :
2235 : }
2236 :
2237 :
2238 :
2239 :
2240 :
2241 0 : if (row.isStr("<crossPolarizationDelay>")) {
2242 :
2243 0 : setCrossPolarizationDelay(Parser::getDouble("crossPolarizationDelay","DelayModel",rowDoc));
2244 :
2245 : }
2246 :
2247 :
2248 :
2249 :
2250 :
2251 :
2252 :
2253 :
2254 :
2255 0 : setAntennaId(Parser::getTag("antennaId","Antenna",rowDoc));
2256 :
2257 :
2258 :
2259 :
2260 :
2261 :
2262 :
2263 0 : setFieldId(Parser::getTag("fieldId","DelayModel",rowDoc));
2264 :
2265 :
2266 :
2267 :
2268 :
2269 :
2270 :
2271 0 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
2272 :
2273 :
2274 :
2275 :
2276 :
2277 :
2278 :
2279 :
2280 :
2281 :
2282 :
2283 :
2284 0 : } catch (const IllegalAccessException &err) {
2285 0 : throw ConversionException (err.getMessage(),"DelayModel");
2286 : }
2287 0 : }
2288 :
2289 0 : void DelayModelRow::toBin(EndianOSStream& eoss) {
2290 :
2291 :
2292 :
2293 :
2294 :
2295 0 : antennaId.toBin(eoss);
2296 :
2297 :
2298 :
2299 :
2300 :
2301 :
2302 0 : spectralWindowId.toBin(eoss);
2303 :
2304 :
2305 :
2306 :
2307 :
2308 :
2309 0 : timeInterval.toBin(eoss);
2310 :
2311 :
2312 :
2313 :
2314 :
2315 :
2316 :
2317 0 : eoss.writeInt(numPoly);
2318 :
2319 :
2320 :
2321 :
2322 :
2323 :
2324 :
2325 :
2326 :
2327 0 : eoss.writeInt((int) phaseDelay.size());
2328 0 : for (unsigned int i = 0; i < phaseDelay.size(); i++)
2329 :
2330 0 : eoss.writeDouble(phaseDelay.at(i));
2331 :
2332 :
2333 :
2334 :
2335 :
2336 :
2337 :
2338 :
2339 :
2340 :
2341 :
2342 0 : eoss.writeInt((int) phaseDelayRate.size());
2343 0 : for (unsigned int i = 0; i < phaseDelayRate.size(); i++)
2344 :
2345 0 : eoss.writeDouble(phaseDelayRate.at(i));
2346 :
2347 :
2348 :
2349 :
2350 :
2351 :
2352 :
2353 :
2354 :
2355 :
2356 :
2357 0 : eoss.writeInt((int) groupDelay.size());
2358 0 : for (unsigned int i = 0; i < groupDelay.size(); i++)
2359 :
2360 0 : eoss.writeDouble(groupDelay.at(i));
2361 :
2362 :
2363 :
2364 :
2365 :
2366 :
2367 :
2368 :
2369 :
2370 :
2371 :
2372 0 : eoss.writeInt((int) groupDelayRate.size());
2373 0 : for (unsigned int i = 0; i < groupDelayRate.size(); i++)
2374 :
2375 0 : eoss.writeDouble(groupDelayRate.at(i));
2376 :
2377 :
2378 :
2379 :
2380 :
2381 :
2382 :
2383 :
2384 :
2385 0 : fieldId.toBin(eoss);
2386 :
2387 :
2388 :
2389 :
2390 :
2391 :
2392 0 : eoss.writeBoolean(timeOriginExists);
2393 0 : if (timeOriginExists) {
2394 :
2395 :
2396 :
2397 :
2398 0 : timeOrigin.toBin(eoss);
2399 :
2400 :
2401 :
2402 : }
2403 :
2404 0 : eoss.writeBoolean(atmosphericGroupDelayExists);
2405 0 : if (atmosphericGroupDelayExists) {
2406 :
2407 :
2408 :
2409 :
2410 :
2411 0 : eoss.writeDouble(atmosphericGroupDelay);
2412 :
2413 :
2414 :
2415 :
2416 : }
2417 :
2418 0 : eoss.writeBoolean(atmosphericGroupDelayRateExists);
2419 0 : if (atmosphericGroupDelayRateExists) {
2420 :
2421 :
2422 :
2423 :
2424 :
2425 0 : eoss.writeDouble(atmosphericGroupDelayRate);
2426 :
2427 :
2428 :
2429 :
2430 : }
2431 :
2432 0 : eoss.writeBoolean(geometricDelayExists);
2433 0 : if (geometricDelayExists) {
2434 :
2435 :
2436 :
2437 :
2438 :
2439 0 : eoss.writeDouble(geometricDelay);
2440 :
2441 :
2442 :
2443 :
2444 : }
2445 :
2446 0 : eoss.writeBoolean(geometricDelayRateExists);
2447 0 : if (geometricDelayRateExists) {
2448 :
2449 :
2450 :
2451 :
2452 :
2453 0 : eoss.writeDouble(geometricDelayRate);
2454 :
2455 :
2456 :
2457 :
2458 : }
2459 :
2460 0 : eoss.writeBoolean(numLOExists);
2461 0 : if (numLOExists) {
2462 :
2463 :
2464 :
2465 :
2466 :
2467 0 : eoss.writeInt(numLO);
2468 :
2469 :
2470 :
2471 :
2472 : }
2473 :
2474 0 : eoss.writeBoolean(LOOffsetExists);
2475 0 : if (LOOffsetExists) {
2476 :
2477 :
2478 :
2479 :
2480 0 : Frequency::toBin(LOOffset, eoss);
2481 :
2482 :
2483 :
2484 : }
2485 :
2486 0 : eoss.writeBoolean(LOOffsetRateExists);
2487 0 : if (LOOffsetRateExists) {
2488 :
2489 :
2490 :
2491 :
2492 0 : Frequency::toBin(LOOffsetRate, eoss);
2493 :
2494 :
2495 :
2496 : }
2497 :
2498 0 : eoss.writeBoolean(dispersiveDelayExists);
2499 0 : if (dispersiveDelayExists) {
2500 :
2501 :
2502 :
2503 :
2504 :
2505 0 : eoss.writeDouble(dispersiveDelay);
2506 :
2507 :
2508 :
2509 :
2510 : }
2511 :
2512 0 : eoss.writeBoolean(dispersiveDelayRateExists);
2513 0 : if (dispersiveDelayRateExists) {
2514 :
2515 :
2516 :
2517 :
2518 :
2519 0 : eoss.writeDouble(dispersiveDelayRate);
2520 :
2521 :
2522 :
2523 :
2524 : }
2525 :
2526 0 : eoss.writeBoolean(atmosphericDryDelayExists);
2527 0 : if (atmosphericDryDelayExists) {
2528 :
2529 :
2530 :
2531 :
2532 :
2533 0 : eoss.writeDouble(atmosphericDryDelay);
2534 :
2535 :
2536 :
2537 :
2538 : }
2539 :
2540 0 : eoss.writeBoolean(atmosphericWetDelayExists);
2541 0 : if (atmosphericWetDelayExists) {
2542 :
2543 :
2544 :
2545 :
2546 :
2547 0 : eoss.writeDouble(atmosphericWetDelay);
2548 :
2549 :
2550 :
2551 :
2552 : }
2553 :
2554 0 : eoss.writeBoolean(padDelayExists);
2555 0 : if (padDelayExists) {
2556 :
2557 :
2558 :
2559 :
2560 :
2561 0 : eoss.writeDouble(padDelay);
2562 :
2563 :
2564 :
2565 :
2566 : }
2567 :
2568 0 : eoss.writeBoolean(antennaDelayExists);
2569 0 : if (antennaDelayExists) {
2570 :
2571 :
2572 :
2573 :
2574 :
2575 0 : eoss.writeDouble(antennaDelay);
2576 :
2577 :
2578 :
2579 :
2580 : }
2581 :
2582 0 : eoss.writeBoolean(numReceptorExists);
2583 0 : if (numReceptorExists) {
2584 :
2585 :
2586 :
2587 :
2588 :
2589 0 : eoss.writeInt(numReceptor);
2590 :
2591 :
2592 :
2593 :
2594 : }
2595 :
2596 0 : eoss.writeBoolean(polarizationTypeExists);
2597 0 : if (polarizationTypeExists) {
2598 :
2599 :
2600 :
2601 :
2602 :
2603 :
2604 0 : eoss.writeInt((int) polarizationType.size());
2605 0 : for (unsigned int i = 0; i < polarizationType.size(); i++)
2606 :
2607 0 : eoss.writeString(CPolarizationType::name(polarizationType.at(i)));
2608 : /* eoss.writeInt(polarizationType.at(i)); */
2609 :
2610 :
2611 :
2612 :
2613 :
2614 :
2615 : }
2616 :
2617 0 : eoss.writeBoolean(electronicDelayExists);
2618 0 : if (electronicDelayExists) {
2619 :
2620 :
2621 :
2622 :
2623 :
2624 :
2625 0 : eoss.writeInt((int) electronicDelay.size());
2626 0 : for (unsigned int i = 0; i < electronicDelay.size(); i++)
2627 :
2628 0 : eoss.writeDouble(electronicDelay.at(i));
2629 :
2630 :
2631 :
2632 :
2633 :
2634 :
2635 : }
2636 :
2637 0 : eoss.writeBoolean(electronicDelayRateExists);
2638 0 : if (electronicDelayRateExists) {
2639 :
2640 :
2641 :
2642 :
2643 :
2644 :
2645 0 : eoss.writeInt((int) electronicDelayRate.size());
2646 0 : for (unsigned int i = 0; i < electronicDelayRate.size(); i++)
2647 :
2648 0 : eoss.writeDouble(electronicDelayRate.at(i));
2649 :
2650 :
2651 :
2652 :
2653 :
2654 :
2655 : }
2656 :
2657 0 : eoss.writeBoolean(receiverDelayExists);
2658 0 : if (receiverDelayExists) {
2659 :
2660 :
2661 :
2662 :
2663 :
2664 :
2665 0 : eoss.writeInt((int) receiverDelay.size());
2666 0 : for (unsigned int i = 0; i < receiverDelay.size(); i++)
2667 :
2668 0 : eoss.writeDouble(receiverDelay.at(i));
2669 :
2670 :
2671 :
2672 :
2673 :
2674 :
2675 : }
2676 :
2677 0 : eoss.writeBoolean(IFDelayExists);
2678 0 : if (IFDelayExists) {
2679 :
2680 :
2681 :
2682 :
2683 :
2684 :
2685 0 : eoss.writeInt((int) IFDelay.size());
2686 0 : for (unsigned int i = 0; i < IFDelay.size(); i++)
2687 :
2688 0 : eoss.writeDouble(IFDelay.at(i));
2689 :
2690 :
2691 :
2692 :
2693 :
2694 :
2695 : }
2696 :
2697 0 : eoss.writeBoolean(LODelayExists);
2698 0 : if (LODelayExists) {
2699 :
2700 :
2701 :
2702 :
2703 :
2704 :
2705 0 : eoss.writeInt((int) LODelay.size());
2706 0 : for (unsigned int i = 0; i < LODelay.size(); i++)
2707 :
2708 0 : eoss.writeDouble(LODelay.at(i));
2709 :
2710 :
2711 :
2712 :
2713 :
2714 :
2715 : }
2716 :
2717 0 : eoss.writeBoolean(crossPolarizationDelayExists);
2718 0 : if (crossPolarizationDelayExists) {
2719 :
2720 :
2721 :
2722 :
2723 :
2724 0 : eoss.writeDouble(crossPolarizationDelay);
2725 :
2726 :
2727 :
2728 :
2729 : }
2730 :
2731 0 : }
2732 :
2733 0 : void DelayModelRow::antennaIdFromBin(EndianIStream& eis) {
2734 :
2735 :
2736 :
2737 :
2738 0 : antennaId = Tag::fromBin(eis);
2739 :
2740 :
2741 :
2742 0 : }
2743 0 : void DelayModelRow::spectralWindowIdFromBin(EndianIStream& eis) {
2744 :
2745 :
2746 :
2747 :
2748 0 : spectralWindowId = Tag::fromBin(eis);
2749 :
2750 :
2751 :
2752 0 : }
2753 0 : void DelayModelRow::timeIntervalFromBin(EndianIStream& eis) {
2754 :
2755 :
2756 :
2757 :
2758 0 : timeInterval = ArrayTimeInterval::fromBin(eis);
2759 :
2760 :
2761 :
2762 0 : }
2763 0 : void DelayModelRow::numPolyFromBin(EndianIStream& eis) {
2764 :
2765 :
2766 :
2767 :
2768 :
2769 0 : numPoly = eis.readInt();
2770 :
2771 :
2772 :
2773 :
2774 0 : }
2775 0 : void DelayModelRow::phaseDelayFromBin(EndianIStream& eis) {
2776 :
2777 :
2778 :
2779 :
2780 :
2781 :
2782 0 : phaseDelay.clear();
2783 :
2784 0 : unsigned int phaseDelayDim1 = eis.readInt();
2785 0 : for (unsigned int i = 0 ; i < phaseDelayDim1; i++)
2786 :
2787 0 : phaseDelay.push_back(eis.readDouble());
2788 :
2789 :
2790 :
2791 :
2792 :
2793 :
2794 0 : }
2795 0 : void DelayModelRow::phaseDelayRateFromBin(EndianIStream& eis) {
2796 :
2797 :
2798 :
2799 :
2800 :
2801 :
2802 0 : phaseDelayRate.clear();
2803 :
2804 0 : unsigned int phaseDelayRateDim1 = eis.readInt();
2805 0 : for (unsigned int i = 0 ; i < phaseDelayRateDim1; i++)
2806 :
2807 0 : phaseDelayRate.push_back(eis.readDouble());
2808 :
2809 :
2810 :
2811 :
2812 :
2813 :
2814 0 : }
2815 0 : void DelayModelRow::groupDelayFromBin(EndianIStream& eis) {
2816 :
2817 :
2818 :
2819 :
2820 :
2821 :
2822 0 : groupDelay.clear();
2823 :
2824 0 : unsigned int groupDelayDim1 = eis.readInt();
2825 0 : for (unsigned int i = 0 ; i < groupDelayDim1; i++)
2826 :
2827 0 : groupDelay.push_back(eis.readDouble());
2828 :
2829 :
2830 :
2831 :
2832 :
2833 :
2834 0 : }
2835 0 : void DelayModelRow::groupDelayRateFromBin(EndianIStream& eis) {
2836 :
2837 :
2838 :
2839 :
2840 :
2841 :
2842 0 : groupDelayRate.clear();
2843 :
2844 0 : unsigned int groupDelayRateDim1 = eis.readInt();
2845 0 : for (unsigned int i = 0 ; i < groupDelayRateDim1; i++)
2846 :
2847 0 : groupDelayRate.push_back(eis.readDouble());
2848 :
2849 :
2850 :
2851 :
2852 :
2853 :
2854 0 : }
2855 0 : void DelayModelRow::fieldIdFromBin(EndianIStream& eis) {
2856 :
2857 :
2858 :
2859 :
2860 0 : fieldId = Tag::fromBin(eis);
2861 :
2862 :
2863 :
2864 0 : }
2865 :
2866 0 : void DelayModelRow::timeOriginFromBin(EndianIStream& eis) {
2867 :
2868 0 : timeOriginExists = eis.readBoolean();
2869 0 : if (timeOriginExists) {
2870 :
2871 :
2872 :
2873 :
2874 0 : timeOrigin = ArrayTime::fromBin(eis);
2875 :
2876 :
2877 :
2878 : }
2879 :
2880 0 : }
2881 0 : void DelayModelRow::atmosphericGroupDelayFromBin(EndianIStream& eis) {
2882 :
2883 0 : atmosphericGroupDelayExists = eis.readBoolean();
2884 0 : if (atmosphericGroupDelayExists) {
2885 :
2886 :
2887 :
2888 :
2889 :
2890 0 : atmosphericGroupDelay = eis.readDouble();
2891 :
2892 :
2893 :
2894 :
2895 : }
2896 :
2897 0 : }
2898 0 : void DelayModelRow::atmosphericGroupDelayRateFromBin(EndianIStream& eis) {
2899 :
2900 0 : atmosphericGroupDelayRateExists = eis.readBoolean();
2901 0 : if (atmosphericGroupDelayRateExists) {
2902 :
2903 :
2904 :
2905 :
2906 :
2907 0 : atmosphericGroupDelayRate = eis.readDouble();
2908 :
2909 :
2910 :
2911 :
2912 : }
2913 :
2914 0 : }
2915 0 : void DelayModelRow::geometricDelayFromBin(EndianIStream& eis) {
2916 :
2917 0 : geometricDelayExists = eis.readBoolean();
2918 0 : if (geometricDelayExists) {
2919 :
2920 :
2921 :
2922 :
2923 :
2924 0 : geometricDelay = eis.readDouble();
2925 :
2926 :
2927 :
2928 :
2929 : }
2930 :
2931 0 : }
2932 0 : void DelayModelRow::geometricDelayRateFromBin(EndianIStream& eis) {
2933 :
2934 0 : geometricDelayRateExists = eis.readBoolean();
2935 0 : if (geometricDelayRateExists) {
2936 :
2937 :
2938 :
2939 :
2940 :
2941 0 : geometricDelayRate = eis.readDouble();
2942 :
2943 :
2944 :
2945 :
2946 : }
2947 :
2948 0 : }
2949 0 : void DelayModelRow::numLOFromBin(EndianIStream& eis) {
2950 :
2951 0 : numLOExists = eis.readBoolean();
2952 0 : if (numLOExists) {
2953 :
2954 :
2955 :
2956 :
2957 :
2958 0 : numLO = eis.readInt();
2959 :
2960 :
2961 :
2962 :
2963 : }
2964 :
2965 0 : }
2966 0 : void DelayModelRow::LOOffsetFromBin(EndianIStream& eis) {
2967 :
2968 0 : LOOffsetExists = eis.readBoolean();
2969 0 : if (LOOffsetExists) {
2970 :
2971 :
2972 :
2973 :
2974 :
2975 :
2976 0 : LOOffset = Frequency::from1DBin(eis);
2977 :
2978 :
2979 :
2980 :
2981 :
2982 : }
2983 :
2984 0 : }
2985 0 : void DelayModelRow::LOOffsetRateFromBin(EndianIStream& eis) {
2986 :
2987 0 : LOOffsetRateExists = eis.readBoolean();
2988 0 : if (LOOffsetRateExists) {
2989 :
2990 :
2991 :
2992 :
2993 :
2994 :
2995 0 : LOOffsetRate = Frequency::from1DBin(eis);
2996 :
2997 :
2998 :
2999 :
3000 :
3001 : }
3002 :
3003 0 : }
3004 0 : void DelayModelRow::dispersiveDelayFromBin(EndianIStream& eis) {
3005 :
3006 0 : dispersiveDelayExists = eis.readBoolean();
3007 0 : if (dispersiveDelayExists) {
3008 :
3009 :
3010 :
3011 :
3012 :
3013 0 : dispersiveDelay = eis.readDouble();
3014 :
3015 :
3016 :
3017 :
3018 : }
3019 :
3020 0 : }
3021 0 : void DelayModelRow::dispersiveDelayRateFromBin(EndianIStream& eis) {
3022 :
3023 0 : dispersiveDelayRateExists = eis.readBoolean();
3024 0 : if (dispersiveDelayRateExists) {
3025 :
3026 :
3027 :
3028 :
3029 :
3030 0 : dispersiveDelayRate = eis.readDouble();
3031 :
3032 :
3033 :
3034 :
3035 : }
3036 :
3037 0 : }
3038 0 : void DelayModelRow::atmosphericDryDelayFromBin(EndianIStream& eis) {
3039 :
3040 0 : atmosphericDryDelayExists = eis.readBoolean();
3041 0 : if (atmosphericDryDelayExists) {
3042 :
3043 :
3044 :
3045 :
3046 :
3047 0 : atmosphericDryDelay = eis.readDouble();
3048 :
3049 :
3050 :
3051 :
3052 : }
3053 :
3054 0 : }
3055 0 : void DelayModelRow::atmosphericWetDelayFromBin(EndianIStream& eis) {
3056 :
3057 0 : atmosphericWetDelayExists = eis.readBoolean();
3058 0 : if (atmosphericWetDelayExists) {
3059 :
3060 :
3061 :
3062 :
3063 :
3064 0 : atmosphericWetDelay = eis.readDouble();
3065 :
3066 :
3067 :
3068 :
3069 : }
3070 :
3071 0 : }
3072 0 : void DelayModelRow::padDelayFromBin(EndianIStream& eis) {
3073 :
3074 0 : padDelayExists = eis.readBoolean();
3075 0 : if (padDelayExists) {
3076 :
3077 :
3078 :
3079 :
3080 :
3081 0 : padDelay = eis.readDouble();
3082 :
3083 :
3084 :
3085 :
3086 : }
3087 :
3088 0 : }
3089 0 : void DelayModelRow::antennaDelayFromBin(EndianIStream& eis) {
3090 :
3091 0 : antennaDelayExists = eis.readBoolean();
3092 0 : if (antennaDelayExists) {
3093 :
3094 :
3095 :
3096 :
3097 :
3098 0 : antennaDelay = eis.readDouble();
3099 :
3100 :
3101 :
3102 :
3103 : }
3104 :
3105 0 : }
3106 0 : void DelayModelRow::numReceptorFromBin(EndianIStream& eis) {
3107 :
3108 0 : numReceptorExists = eis.readBoolean();
3109 0 : if (numReceptorExists) {
3110 :
3111 :
3112 :
3113 :
3114 :
3115 0 : numReceptor = eis.readInt();
3116 :
3117 :
3118 :
3119 :
3120 : }
3121 :
3122 0 : }
3123 0 : void DelayModelRow::polarizationTypeFromBin(EndianIStream& eis) {
3124 :
3125 0 : polarizationTypeExists = eis.readBoolean();
3126 0 : if (polarizationTypeExists) {
3127 :
3128 :
3129 :
3130 :
3131 :
3132 :
3133 0 : polarizationType.clear();
3134 :
3135 0 : unsigned int polarizationTypeDim1 = eis.readInt();
3136 0 : for (unsigned int i = 0 ; i < polarizationTypeDim1; i++)
3137 :
3138 0 : polarizationType.push_back(CPolarizationType::literal(eis.readString()));
3139 :
3140 :
3141 :
3142 :
3143 :
3144 :
3145 : }
3146 :
3147 0 : }
3148 0 : void DelayModelRow::electronicDelayFromBin(EndianIStream& eis) {
3149 :
3150 0 : electronicDelayExists = eis.readBoolean();
3151 0 : if (electronicDelayExists) {
3152 :
3153 :
3154 :
3155 :
3156 :
3157 :
3158 0 : electronicDelay.clear();
3159 :
3160 0 : unsigned int electronicDelayDim1 = eis.readInt();
3161 0 : for (unsigned int i = 0 ; i < electronicDelayDim1; i++)
3162 :
3163 0 : electronicDelay.push_back(eis.readDouble());
3164 :
3165 :
3166 :
3167 :
3168 :
3169 :
3170 : }
3171 :
3172 0 : }
3173 0 : void DelayModelRow::electronicDelayRateFromBin(EndianIStream& eis) {
3174 :
3175 0 : electronicDelayRateExists = eis.readBoolean();
3176 0 : if (electronicDelayRateExists) {
3177 :
3178 :
3179 :
3180 :
3181 :
3182 :
3183 0 : electronicDelayRate.clear();
3184 :
3185 0 : unsigned int electronicDelayRateDim1 = eis.readInt();
3186 0 : for (unsigned int i = 0 ; i < electronicDelayRateDim1; i++)
3187 :
3188 0 : electronicDelayRate.push_back(eis.readDouble());
3189 :
3190 :
3191 :
3192 :
3193 :
3194 :
3195 : }
3196 :
3197 0 : }
3198 0 : void DelayModelRow::receiverDelayFromBin(EndianIStream& eis) {
3199 :
3200 0 : receiverDelayExists = eis.readBoolean();
3201 0 : if (receiverDelayExists) {
3202 :
3203 :
3204 :
3205 :
3206 :
3207 :
3208 0 : receiverDelay.clear();
3209 :
3210 0 : unsigned int receiverDelayDim1 = eis.readInt();
3211 0 : for (unsigned int i = 0 ; i < receiverDelayDim1; i++)
3212 :
3213 0 : receiverDelay.push_back(eis.readDouble());
3214 :
3215 :
3216 :
3217 :
3218 :
3219 :
3220 : }
3221 :
3222 0 : }
3223 0 : void DelayModelRow::IFDelayFromBin(EndianIStream& eis) {
3224 :
3225 0 : IFDelayExists = eis.readBoolean();
3226 0 : if (IFDelayExists) {
3227 :
3228 :
3229 :
3230 :
3231 :
3232 :
3233 0 : IFDelay.clear();
3234 :
3235 0 : unsigned int IFDelayDim1 = eis.readInt();
3236 0 : for (unsigned int i = 0 ; i < IFDelayDim1; i++)
3237 :
3238 0 : IFDelay.push_back(eis.readDouble());
3239 :
3240 :
3241 :
3242 :
3243 :
3244 :
3245 : }
3246 :
3247 0 : }
3248 0 : void DelayModelRow::LODelayFromBin(EndianIStream& eis) {
3249 :
3250 0 : LODelayExists = eis.readBoolean();
3251 0 : if (LODelayExists) {
3252 :
3253 :
3254 :
3255 :
3256 :
3257 :
3258 0 : LODelay.clear();
3259 :
3260 0 : unsigned int LODelayDim1 = eis.readInt();
3261 0 : for (unsigned int i = 0 ; i < LODelayDim1; i++)
3262 :
3263 0 : LODelay.push_back(eis.readDouble());
3264 :
3265 :
3266 :
3267 :
3268 :
3269 :
3270 : }
3271 :
3272 0 : }
3273 0 : void DelayModelRow::crossPolarizationDelayFromBin(EndianIStream& eis) {
3274 :
3275 0 : crossPolarizationDelayExists = eis.readBoolean();
3276 0 : if (crossPolarizationDelayExists) {
3277 :
3278 :
3279 :
3280 :
3281 :
3282 0 : crossPolarizationDelay = eis.readDouble();
3283 :
3284 :
3285 :
3286 :
3287 : }
3288 :
3289 0 : }
3290 :
3291 :
3292 0 : DelayModelRow* DelayModelRow::fromBin(EndianIStream& eis, DelayModelTable& table, const vector<string>& attributesSeq) {
3293 0 : DelayModelRow* row = new DelayModelRow(table);
3294 :
3295 0 : map<string, DelayModelAttributeFromBin>::iterator iter ;
3296 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
3297 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
3298 0 : if (iter != row->fromBinMethods.end()) {
3299 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
3300 : }
3301 : else {
3302 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
3303 0 : if (functorP)
3304 0 : (*functorP)(eis);
3305 : else
3306 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "DelayModelTable");
3307 : }
3308 :
3309 : }
3310 0 : return row;
3311 : }
3312 :
3313 : //
3314 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
3315 : // of one row.
3316 : //
3317 :
3318 : // Convert a string into an Tag
3319 0 : void DelayModelRow::antennaIdFromText(const string & s) {
3320 :
3321 :
3322 0 : antennaId = ASDMValuesParser::parse<Tag>(s);
3323 :
3324 :
3325 0 : }
3326 :
3327 :
3328 : // Convert a string into an Tag
3329 0 : void DelayModelRow::spectralWindowIdFromText(const string & s) {
3330 :
3331 :
3332 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
3333 :
3334 :
3335 0 : }
3336 :
3337 :
3338 : // Convert a string into an ArrayTimeInterval
3339 0 : void DelayModelRow::timeIntervalFromText(const string & s) {
3340 :
3341 :
3342 0 : timeInterval = ASDMValuesParser::parse<ArrayTimeInterval>(s);
3343 :
3344 :
3345 0 : }
3346 :
3347 :
3348 : // Convert a string into an int
3349 0 : void DelayModelRow::numPolyFromText(const string & s) {
3350 :
3351 :
3352 0 : numPoly = ASDMValuesParser::parse<int>(s);
3353 :
3354 :
3355 0 : }
3356 :
3357 :
3358 : // Convert a string into an double
3359 0 : void DelayModelRow::phaseDelayFromText(const string & s) {
3360 :
3361 :
3362 0 : phaseDelay = ASDMValuesParser::parse1D<double>(s);
3363 :
3364 :
3365 0 : }
3366 :
3367 :
3368 : // Convert a string into an double
3369 0 : void DelayModelRow::phaseDelayRateFromText(const string & s) {
3370 :
3371 :
3372 0 : phaseDelayRate = ASDMValuesParser::parse1D<double>(s);
3373 :
3374 :
3375 0 : }
3376 :
3377 :
3378 : // Convert a string into an double
3379 0 : void DelayModelRow::groupDelayFromText(const string & s) {
3380 :
3381 :
3382 0 : groupDelay = ASDMValuesParser::parse1D<double>(s);
3383 :
3384 :
3385 0 : }
3386 :
3387 :
3388 : // Convert a string into an double
3389 0 : void DelayModelRow::groupDelayRateFromText(const string & s) {
3390 :
3391 :
3392 0 : groupDelayRate = ASDMValuesParser::parse1D<double>(s);
3393 :
3394 :
3395 0 : }
3396 :
3397 :
3398 : // Convert a string into an Tag
3399 0 : void DelayModelRow::fieldIdFromText(const string & s) {
3400 :
3401 :
3402 0 : fieldId = ASDMValuesParser::parse<Tag>(s);
3403 :
3404 :
3405 0 : }
3406 :
3407 :
3408 :
3409 : // Convert a string into an ArrayTime
3410 0 : void DelayModelRow::timeOriginFromText(const string & s) {
3411 0 : timeOriginExists = true;
3412 :
3413 :
3414 0 : timeOrigin = ASDMValuesParser::parse<ArrayTime>(s);
3415 :
3416 :
3417 0 : }
3418 :
3419 :
3420 : // Convert a string into an double
3421 0 : void DelayModelRow::atmosphericGroupDelayFromText(const string & s) {
3422 0 : atmosphericGroupDelayExists = true;
3423 :
3424 :
3425 0 : atmosphericGroupDelay = ASDMValuesParser::parse<double>(s);
3426 :
3427 :
3428 0 : }
3429 :
3430 :
3431 : // Convert a string into an double
3432 0 : void DelayModelRow::atmosphericGroupDelayRateFromText(const string & s) {
3433 0 : atmosphericGroupDelayRateExists = true;
3434 :
3435 :
3436 0 : atmosphericGroupDelayRate = ASDMValuesParser::parse<double>(s);
3437 :
3438 :
3439 0 : }
3440 :
3441 :
3442 : // Convert a string into an double
3443 0 : void DelayModelRow::geometricDelayFromText(const string & s) {
3444 0 : geometricDelayExists = true;
3445 :
3446 :
3447 0 : geometricDelay = ASDMValuesParser::parse<double>(s);
3448 :
3449 :
3450 0 : }
3451 :
3452 :
3453 : // Convert a string into an double
3454 0 : void DelayModelRow::geometricDelayRateFromText(const string & s) {
3455 0 : geometricDelayRateExists = true;
3456 :
3457 :
3458 0 : geometricDelayRate = ASDMValuesParser::parse<double>(s);
3459 :
3460 :
3461 0 : }
3462 :
3463 :
3464 : // Convert a string into an int
3465 0 : void DelayModelRow::numLOFromText(const string & s) {
3466 0 : numLOExists = true;
3467 :
3468 :
3469 0 : numLO = ASDMValuesParser::parse<int>(s);
3470 :
3471 :
3472 0 : }
3473 :
3474 :
3475 : // Convert a string into an Frequency
3476 0 : void DelayModelRow::LOOffsetFromText(const string & s) {
3477 0 : LOOffsetExists = true;
3478 :
3479 :
3480 0 : LOOffset = ASDMValuesParser::parse1D<Frequency>(s);
3481 :
3482 :
3483 0 : }
3484 :
3485 :
3486 : // Convert a string into an Frequency
3487 0 : void DelayModelRow::LOOffsetRateFromText(const string & s) {
3488 0 : LOOffsetRateExists = true;
3489 :
3490 :
3491 0 : LOOffsetRate = ASDMValuesParser::parse1D<Frequency>(s);
3492 :
3493 :
3494 0 : }
3495 :
3496 :
3497 : // Convert a string into an double
3498 0 : void DelayModelRow::dispersiveDelayFromText(const string & s) {
3499 0 : dispersiveDelayExists = true;
3500 :
3501 :
3502 0 : dispersiveDelay = ASDMValuesParser::parse<double>(s);
3503 :
3504 :
3505 0 : }
3506 :
3507 :
3508 : // Convert a string into an double
3509 0 : void DelayModelRow::dispersiveDelayRateFromText(const string & s) {
3510 0 : dispersiveDelayRateExists = true;
3511 :
3512 :
3513 0 : dispersiveDelayRate = ASDMValuesParser::parse<double>(s);
3514 :
3515 :
3516 0 : }
3517 :
3518 :
3519 : // Convert a string into an double
3520 0 : void DelayModelRow::atmosphericDryDelayFromText(const string & s) {
3521 0 : atmosphericDryDelayExists = true;
3522 :
3523 :
3524 0 : atmosphericDryDelay = ASDMValuesParser::parse<double>(s);
3525 :
3526 :
3527 0 : }
3528 :
3529 :
3530 : // Convert a string into an double
3531 0 : void DelayModelRow::atmosphericWetDelayFromText(const string & s) {
3532 0 : atmosphericWetDelayExists = true;
3533 :
3534 :
3535 0 : atmosphericWetDelay = ASDMValuesParser::parse<double>(s);
3536 :
3537 :
3538 0 : }
3539 :
3540 :
3541 : // Convert a string into an double
3542 0 : void DelayModelRow::padDelayFromText(const string & s) {
3543 0 : padDelayExists = true;
3544 :
3545 :
3546 0 : padDelay = ASDMValuesParser::parse<double>(s);
3547 :
3548 :
3549 0 : }
3550 :
3551 :
3552 : // Convert a string into an double
3553 0 : void DelayModelRow::antennaDelayFromText(const string & s) {
3554 0 : antennaDelayExists = true;
3555 :
3556 :
3557 0 : antennaDelay = ASDMValuesParser::parse<double>(s);
3558 :
3559 :
3560 0 : }
3561 :
3562 :
3563 : // Convert a string into an int
3564 0 : void DelayModelRow::numReceptorFromText(const string & s) {
3565 0 : numReceptorExists = true;
3566 :
3567 :
3568 0 : numReceptor = ASDMValuesParser::parse<int>(s);
3569 :
3570 :
3571 0 : }
3572 :
3573 :
3574 : // Convert a string into an PolarizationType
3575 0 : void DelayModelRow::polarizationTypeFromText(const string & s) {
3576 0 : polarizationTypeExists = true;
3577 :
3578 :
3579 0 : polarizationType = ASDMValuesParser::parse1D<PolarizationTypeMod::PolarizationType>(s);
3580 :
3581 :
3582 0 : }
3583 :
3584 :
3585 : // Convert a string into an double
3586 0 : void DelayModelRow::electronicDelayFromText(const string & s) {
3587 0 : electronicDelayExists = true;
3588 :
3589 :
3590 0 : electronicDelay = ASDMValuesParser::parse1D<double>(s);
3591 :
3592 :
3593 0 : }
3594 :
3595 :
3596 : // Convert a string into an double
3597 0 : void DelayModelRow::electronicDelayRateFromText(const string & s) {
3598 0 : electronicDelayRateExists = true;
3599 :
3600 :
3601 0 : electronicDelayRate = ASDMValuesParser::parse1D<double>(s);
3602 :
3603 :
3604 0 : }
3605 :
3606 :
3607 : // Convert a string into an double
3608 0 : void DelayModelRow::receiverDelayFromText(const string & s) {
3609 0 : receiverDelayExists = true;
3610 :
3611 :
3612 0 : receiverDelay = ASDMValuesParser::parse1D<double>(s);
3613 :
3614 :
3615 0 : }
3616 :
3617 :
3618 : // Convert a string into an double
3619 0 : void DelayModelRow::IFDelayFromText(const string & s) {
3620 0 : IFDelayExists = true;
3621 :
3622 :
3623 0 : IFDelay = ASDMValuesParser::parse1D<double>(s);
3624 :
3625 :
3626 0 : }
3627 :
3628 :
3629 : // Convert a string into an double
3630 0 : void DelayModelRow::LODelayFromText(const string & s) {
3631 0 : LODelayExists = true;
3632 :
3633 :
3634 0 : LODelay = ASDMValuesParser::parse1D<double>(s);
3635 :
3636 :
3637 0 : }
3638 :
3639 :
3640 : // Convert a string into an double
3641 0 : void DelayModelRow::crossPolarizationDelayFromText(const string & s) {
3642 0 : crossPolarizationDelayExists = true;
3643 :
3644 :
3645 0 : crossPolarizationDelay = ASDMValuesParser::parse<double>(s);
3646 :
3647 :
3648 0 : }
3649 :
3650 :
3651 :
3652 0 : void DelayModelRow::fromText(const std::string& attributeName, const std::string& t) {
3653 0 : map<string, DelayModelAttributeFromText>::iterator iter;
3654 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
3655 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "DelayModelTable");
3656 0 : (this->*(iter->second))(t);
3657 0 : }
3658 :
3659 : ////////////////////////////////////////////////
3660 : // Intrinsic Table Attributes getters/setters //
3661 : ////////////////////////////////////////////////
3662 :
3663 :
3664 :
3665 :
3666 : /**
3667 : * Get timeInterval.
3668 : * @return timeInterval as ArrayTimeInterval
3669 : */
3670 0 : ArrayTimeInterval DelayModelRow::getTimeInterval() const {
3671 :
3672 0 : return timeInterval;
3673 : }
3674 :
3675 : /**
3676 : * Set timeInterval with the specified ArrayTimeInterval.
3677 : * @param timeInterval The ArrayTimeInterval value to which timeInterval is to be set.
3678 :
3679 :
3680 :
3681 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3682 :
3683 : */
3684 0 : void DelayModelRow::setTimeInterval (ArrayTimeInterval timeInterval) {
3685 :
3686 :
3687 0 : if (hasBeenAdded) {
3688 :
3689 0 : throw IllegalAccessException("timeInterval", "DelayModel");
3690 :
3691 : }
3692 :
3693 0 : this->timeInterval = timeInterval;
3694 :
3695 0 : }
3696 :
3697 :
3698 :
3699 :
3700 :
3701 :
3702 : /**
3703 : * Get numPoly.
3704 : * @return numPoly as int
3705 : */
3706 0 : int DelayModelRow::getNumPoly() const {
3707 :
3708 0 : return numPoly;
3709 : }
3710 :
3711 : /**
3712 : * Set numPoly with the specified int.
3713 : * @param numPoly The int value to which numPoly is to be set.
3714 :
3715 :
3716 :
3717 : */
3718 0 : void DelayModelRow::setNumPoly (int numPoly) {
3719 :
3720 :
3721 0 : if (hasBeenAdded) {
3722 :
3723 : }
3724 :
3725 0 : this->numPoly = numPoly;
3726 :
3727 0 : }
3728 :
3729 :
3730 :
3731 :
3732 :
3733 :
3734 : /**
3735 : * Get phaseDelay.
3736 : * @return phaseDelay as std::vector<double >
3737 : */
3738 0 : std::vector<double > DelayModelRow::getPhaseDelay() const {
3739 :
3740 0 : return phaseDelay;
3741 : }
3742 :
3743 : /**
3744 : * Set phaseDelay with the specified std::vector<double >.
3745 : * @param phaseDelay The std::vector<double > value to which phaseDelay is to be set.
3746 :
3747 :
3748 :
3749 : */
3750 0 : void DelayModelRow::setPhaseDelay (std::vector<double > phaseDelay) {
3751 :
3752 :
3753 0 : if (hasBeenAdded) {
3754 :
3755 : }
3756 :
3757 0 : this->phaseDelay = phaseDelay;
3758 :
3759 0 : }
3760 :
3761 :
3762 :
3763 :
3764 :
3765 :
3766 : /**
3767 : * Get phaseDelayRate.
3768 : * @return phaseDelayRate as std::vector<double >
3769 : */
3770 0 : std::vector<double > DelayModelRow::getPhaseDelayRate() const {
3771 :
3772 0 : return phaseDelayRate;
3773 : }
3774 :
3775 : /**
3776 : * Set phaseDelayRate with the specified std::vector<double >.
3777 : * @param phaseDelayRate The std::vector<double > value to which phaseDelayRate is to be set.
3778 :
3779 :
3780 :
3781 : */
3782 0 : void DelayModelRow::setPhaseDelayRate (std::vector<double > phaseDelayRate) {
3783 :
3784 :
3785 0 : if (hasBeenAdded) {
3786 :
3787 : }
3788 :
3789 0 : this->phaseDelayRate = phaseDelayRate;
3790 :
3791 0 : }
3792 :
3793 :
3794 :
3795 :
3796 :
3797 :
3798 : /**
3799 : * Get groupDelay.
3800 : * @return groupDelay as std::vector<double >
3801 : */
3802 0 : std::vector<double > DelayModelRow::getGroupDelay() const {
3803 :
3804 0 : return groupDelay;
3805 : }
3806 :
3807 : /**
3808 : * Set groupDelay with the specified std::vector<double >.
3809 : * @param groupDelay The std::vector<double > value to which groupDelay is to be set.
3810 :
3811 :
3812 :
3813 : */
3814 0 : void DelayModelRow::setGroupDelay (std::vector<double > groupDelay) {
3815 :
3816 :
3817 0 : if (hasBeenAdded) {
3818 :
3819 : }
3820 :
3821 0 : this->groupDelay = groupDelay;
3822 :
3823 0 : }
3824 :
3825 :
3826 :
3827 :
3828 :
3829 :
3830 : /**
3831 : * Get groupDelayRate.
3832 : * @return groupDelayRate as std::vector<double >
3833 : */
3834 0 : std::vector<double > DelayModelRow::getGroupDelayRate() const {
3835 :
3836 0 : return groupDelayRate;
3837 : }
3838 :
3839 : /**
3840 : * Set groupDelayRate with the specified std::vector<double >.
3841 : * @param groupDelayRate The std::vector<double > value to which groupDelayRate is to be set.
3842 :
3843 :
3844 :
3845 : */
3846 0 : void DelayModelRow::setGroupDelayRate (std::vector<double > groupDelayRate) {
3847 :
3848 :
3849 0 : if (hasBeenAdded) {
3850 :
3851 : }
3852 :
3853 0 : this->groupDelayRate = groupDelayRate;
3854 :
3855 0 : }
3856 :
3857 :
3858 :
3859 :
3860 : /**
3861 : * The attribute timeOrigin is optional. Return true if this attribute exists.
3862 : * @return true if and only if the timeOrigin attribute exists.
3863 : */
3864 0 : bool DelayModelRow::isTimeOriginExists() const {
3865 0 : return timeOriginExists;
3866 : }
3867 :
3868 :
3869 :
3870 : /**
3871 : * Get timeOrigin, which is optional.
3872 : * @return timeOrigin as ArrayTime
3873 : * @throw IllegalAccessException If timeOrigin does not exist.
3874 : */
3875 0 : ArrayTime DelayModelRow::getTimeOrigin() const {
3876 0 : if (!timeOriginExists) {
3877 0 : throw IllegalAccessException("timeOrigin", "DelayModel");
3878 : }
3879 :
3880 0 : return timeOrigin;
3881 : }
3882 :
3883 : /**
3884 : * Set timeOrigin with the specified ArrayTime.
3885 : * @param timeOrigin The ArrayTime value to which timeOrigin is to be set.
3886 :
3887 :
3888 : */
3889 0 : void DelayModelRow::setTimeOrigin (ArrayTime timeOrigin) {
3890 :
3891 0 : this->timeOrigin = timeOrigin;
3892 :
3893 0 : timeOriginExists = true;
3894 :
3895 0 : }
3896 :
3897 :
3898 : /**
3899 : * Mark timeOrigin, which is an optional field, as non-existent.
3900 : */
3901 0 : void DelayModelRow::clearTimeOrigin () {
3902 0 : timeOriginExists = false;
3903 0 : }
3904 :
3905 :
3906 :
3907 : /**
3908 : * The attribute atmosphericGroupDelay is optional. Return true if this attribute exists.
3909 : * @return true if and only if the atmosphericGroupDelay attribute exists.
3910 : */
3911 0 : bool DelayModelRow::isAtmosphericGroupDelayExists() const {
3912 0 : return atmosphericGroupDelayExists;
3913 : }
3914 :
3915 :
3916 :
3917 : /**
3918 : * Get atmosphericGroupDelay, which is optional.
3919 : * @return atmosphericGroupDelay as double
3920 : * @throw IllegalAccessException If atmosphericGroupDelay does not exist.
3921 : */
3922 0 : double DelayModelRow::getAtmosphericGroupDelay() const {
3923 0 : if (!atmosphericGroupDelayExists) {
3924 0 : throw IllegalAccessException("atmosphericGroupDelay", "DelayModel");
3925 : }
3926 :
3927 0 : return atmosphericGroupDelay;
3928 : }
3929 :
3930 : /**
3931 : * Set atmosphericGroupDelay with the specified double.
3932 : * @param atmosphericGroupDelay The double value to which atmosphericGroupDelay is to be set.
3933 :
3934 :
3935 : */
3936 0 : void DelayModelRow::setAtmosphericGroupDelay (double atmosphericGroupDelay) {
3937 :
3938 0 : this->atmosphericGroupDelay = atmosphericGroupDelay;
3939 :
3940 0 : atmosphericGroupDelayExists = true;
3941 :
3942 0 : }
3943 :
3944 :
3945 : /**
3946 : * Mark atmosphericGroupDelay, which is an optional field, as non-existent.
3947 : */
3948 0 : void DelayModelRow::clearAtmosphericGroupDelay () {
3949 0 : atmosphericGroupDelayExists = false;
3950 0 : }
3951 :
3952 :
3953 :
3954 : /**
3955 : * The attribute atmosphericGroupDelayRate is optional. Return true if this attribute exists.
3956 : * @return true if and only if the atmosphericGroupDelayRate attribute exists.
3957 : */
3958 0 : bool DelayModelRow::isAtmosphericGroupDelayRateExists() const {
3959 0 : return atmosphericGroupDelayRateExists;
3960 : }
3961 :
3962 :
3963 :
3964 : /**
3965 : * Get atmosphericGroupDelayRate, which is optional.
3966 : * @return atmosphericGroupDelayRate as double
3967 : * @throw IllegalAccessException If atmosphericGroupDelayRate does not exist.
3968 : */
3969 0 : double DelayModelRow::getAtmosphericGroupDelayRate() const {
3970 0 : if (!atmosphericGroupDelayRateExists) {
3971 0 : throw IllegalAccessException("atmosphericGroupDelayRate", "DelayModel");
3972 : }
3973 :
3974 0 : return atmosphericGroupDelayRate;
3975 : }
3976 :
3977 : /**
3978 : * Set atmosphericGroupDelayRate with the specified double.
3979 : * @param atmosphericGroupDelayRate The double value to which atmosphericGroupDelayRate is to be set.
3980 :
3981 :
3982 : */
3983 0 : void DelayModelRow::setAtmosphericGroupDelayRate (double atmosphericGroupDelayRate) {
3984 :
3985 0 : this->atmosphericGroupDelayRate = atmosphericGroupDelayRate;
3986 :
3987 0 : atmosphericGroupDelayRateExists = true;
3988 :
3989 0 : }
3990 :
3991 :
3992 : /**
3993 : * Mark atmosphericGroupDelayRate, which is an optional field, as non-existent.
3994 : */
3995 0 : void DelayModelRow::clearAtmosphericGroupDelayRate () {
3996 0 : atmosphericGroupDelayRateExists = false;
3997 0 : }
3998 :
3999 :
4000 :
4001 : /**
4002 : * The attribute geometricDelay is optional. Return true if this attribute exists.
4003 : * @return true if and only if the geometricDelay attribute exists.
4004 : */
4005 0 : bool DelayModelRow::isGeometricDelayExists() const {
4006 0 : return geometricDelayExists;
4007 : }
4008 :
4009 :
4010 :
4011 : /**
4012 : * Get geometricDelay, which is optional.
4013 : * @return geometricDelay as double
4014 : * @throw IllegalAccessException If geometricDelay does not exist.
4015 : */
4016 0 : double DelayModelRow::getGeometricDelay() const {
4017 0 : if (!geometricDelayExists) {
4018 0 : throw IllegalAccessException("geometricDelay", "DelayModel");
4019 : }
4020 :
4021 0 : return geometricDelay;
4022 : }
4023 :
4024 : /**
4025 : * Set geometricDelay with the specified double.
4026 : * @param geometricDelay The double value to which geometricDelay is to be set.
4027 :
4028 :
4029 : */
4030 0 : void DelayModelRow::setGeometricDelay (double geometricDelay) {
4031 :
4032 0 : this->geometricDelay = geometricDelay;
4033 :
4034 0 : geometricDelayExists = true;
4035 :
4036 0 : }
4037 :
4038 :
4039 : /**
4040 : * Mark geometricDelay, which is an optional field, as non-existent.
4041 : */
4042 0 : void DelayModelRow::clearGeometricDelay () {
4043 0 : geometricDelayExists = false;
4044 0 : }
4045 :
4046 :
4047 :
4048 : /**
4049 : * The attribute geometricDelayRate is optional. Return true if this attribute exists.
4050 : * @return true if and only if the geometricDelayRate attribute exists.
4051 : */
4052 0 : bool DelayModelRow::isGeometricDelayRateExists() const {
4053 0 : return geometricDelayRateExists;
4054 : }
4055 :
4056 :
4057 :
4058 : /**
4059 : * Get geometricDelayRate, which is optional.
4060 : * @return geometricDelayRate as double
4061 : * @throw IllegalAccessException If geometricDelayRate does not exist.
4062 : */
4063 0 : double DelayModelRow::getGeometricDelayRate() const {
4064 0 : if (!geometricDelayRateExists) {
4065 0 : throw IllegalAccessException("geometricDelayRate", "DelayModel");
4066 : }
4067 :
4068 0 : return geometricDelayRate;
4069 : }
4070 :
4071 : /**
4072 : * Set geometricDelayRate with the specified double.
4073 : * @param geometricDelayRate The double value to which geometricDelayRate is to be set.
4074 :
4075 :
4076 : */
4077 0 : void DelayModelRow::setGeometricDelayRate (double geometricDelayRate) {
4078 :
4079 0 : this->geometricDelayRate = geometricDelayRate;
4080 :
4081 0 : geometricDelayRateExists = true;
4082 :
4083 0 : }
4084 :
4085 :
4086 : /**
4087 : * Mark geometricDelayRate, which is an optional field, as non-existent.
4088 : */
4089 0 : void DelayModelRow::clearGeometricDelayRate () {
4090 0 : geometricDelayRateExists = false;
4091 0 : }
4092 :
4093 :
4094 :
4095 : /**
4096 : * The attribute numLO is optional. Return true if this attribute exists.
4097 : * @return true if and only if the numLO attribute exists.
4098 : */
4099 0 : bool DelayModelRow::isNumLOExists() const {
4100 0 : return numLOExists;
4101 : }
4102 :
4103 :
4104 :
4105 : /**
4106 : * Get numLO, which is optional.
4107 : * @return numLO as int
4108 : * @throw IllegalAccessException If numLO does not exist.
4109 : */
4110 0 : int DelayModelRow::getNumLO() const {
4111 0 : if (!numLOExists) {
4112 0 : throw IllegalAccessException("numLO", "DelayModel");
4113 : }
4114 :
4115 0 : return numLO;
4116 : }
4117 :
4118 : /**
4119 : * Set numLO with the specified int.
4120 : * @param numLO The int value to which numLO is to be set.
4121 :
4122 :
4123 : */
4124 0 : void DelayModelRow::setNumLO (int numLO) {
4125 :
4126 0 : this->numLO = numLO;
4127 :
4128 0 : numLOExists = true;
4129 :
4130 0 : }
4131 :
4132 :
4133 : /**
4134 : * Mark numLO, which is an optional field, as non-existent.
4135 : */
4136 0 : void DelayModelRow::clearNumLO () {
4137 0 : numLOExists = false;
4138 0 : }
4139 :
4140 :
4141 :
4142 : /**
4143 : * The attribute LOOffset is optional. Return true if this attribute exists.
4144 : * @return true if and only if the LOOffset attribute exists.
4145 : */
4146 0 : bool DelayModelRow::isLOOffsetExists() const {
4147 0 : return LOOffsetExists;
4148 : }
4149 :
4150 :
4151 :
4152 : /**
4153 : * Get LOOffset, which is optional.
4154 : * @return LOOffset as std::vector<Frequency >
4155 : * @throw IllegalAccessException If LOOffset does not exist.
4156 : */
4157 0 : std::vector<Frequency > DelayModelRow::getLOOffset() const {
4158 0 : if (!LOOffsetExists) {
4159 0 : throw IllegalAccessException("LOOffset", "DelayModel");
4160 : }
4161 :
4162 0 : return LOOffset;
4163 : }
4164 :
4165 : /**
4166 : * Set LOOffset with the specified std::vector<Frequency >.
4167 : * @param LOOffset The std::vector<Frequency > value to which LOOffset is to be set.
4168 :
4169 :
4170 : */
4171 0 : void DelayModelRow::setLOOffset (std::vector<Frequency > LOOffset) {
4172 :
4173 0 : this->LOOffset = LOOffset;
4174 :
4175 0 : LOOffsetExists = true;
4176 :
4177 0 : }
4178 :
4179 :
4180 : /**
4181 : * Mark LOOffset, which is an optional field, as non-existent.
4182 : */
4183 0 : void DelayModelRow::clearLOOffset () {
4184 0 : LOOffsetExists = false;
4185 0 : }
4186 :
4187 :
4188 :
4189 : /**
4190 : * The attribute LOOffsetRate is optional. Return true if this attribute exists.
4191 : * @return true if and only if the LOOffsetRate attribute exists.
4192 : */
4193 0 : bool DelayModelRow::isLOOffsetRateExists() const {
4194 0 : return LOOffsetRateExists;
4195 : }
4196 :
4197 :
4198 :
4199 : /**
4200 : * Get LOOffsetRate, which is optional.
4201 : * @return LOOffsetRate as std::vector<Frequency >
4202 : * @throw IllegalAccessException If LOOffsetRate does not exist.
4203 : */
4204 0 : std::vector<Frequency > DelayModelRow::getLOOffsetRate() const {
4205 0 : if (!LOOffsetRateExists) {
4206 0 : throw IllegalAccessException("LOOffsetRate", "DelayModel");
4207 : }
4208 :
4209 0 : return LOOffsetRate;
4210 : }
4211 :
4212 : /**
4213 : * Set LOOffsetRate with the specified std::vector<Frequency >.
4214 : * @param LOOffsetRate The std::vector<Frequency > value to which LOOffsetRate is to be set.
4215 :
4216 :
4217 : */
4218 0 : void DelayModelRow::setLOOffsetRate (std::vector<Frequency > LOOffsetRate) {
4219 :
4220 0 : this->LOOffsetRate = LOOffsetRate;
4221 :
4222 0 : LOOffsetRateExists = true;
4223 :
4224 0 : }
4225 :
4226 :
4227 : /**
4228 : * Mark LOOffsetRate, which is an optional field, as non-existent.
4229 : */
4230 0 : void DelayModelRow::clearLOOffsetRate () {
4231 0 : LOOffsetRateExists = false;
4232 0 : }
4233 :
4234 :
4235 :
4236 : /**
4237 : * The attribute dispersiveDelay is optional. Return true if this attribute exists.
4238 : * @return true if and only if the dispersiveDelay attribute exists.
4239 : */
4240 0 : bool DelayModelRow::isDispersiveDelayExists() const {
4241 0 : return dispersiveDelayExists;
4242 : }
4243 :
4244 :
4245 :
4246 : /**
4247 : * Get dispersiveDelay, which is optional.
4248 : * @return dispersiveDelay as double
4249 : * @throw IllegalAccessException If dispersiveDelay does not exist.
4250 : */
4251 0 : double DelayModelRow::getDispersiveDelay() const {
4252 0 : if (!dispersiveDelayExists) {
4253 0 : throw IllegalAccessException("dispersiveDelay", "DelayModel");
4254 : }
4255 :
4256 0 : return dispersiveDelay;
4257 : }
4258 :
4259 : /**
4260 : * Set dispersiveDelay with the specified double.
4261 : * @param dispersiveDelay The double value to which dispersiveDelay is to be set.
4262 :
4263 :
4264 : */
4265 0 : void DelayModelRow::setDispersiveDelay (double dispersiveDelay) {
4266 :
4267 0 : this->dispersiveDelay = dispersiveDelay;
4268 :
4269 0 : dispersiveDelayExists = true;
4270 :
4271 0 : }
4272 :
4273 :
4274 : /**
4275 : * Mark dispersiveDelay, which is an optional field, as non-existent.
4276 : */
4277 0 : void DelayModelRow::clearDispersiveDelay () {
4278 0 : dispersiveDelayExists = false;
4279 0 : }
4280 :
4281 :
4282 :
4283 : /**
4284 : * The attribute dispersiveDelayRate is optional. Return true if this attribute exists.
4285 : * @return true if and only if the dispersiveDelayRate attribute exists.
4286 : */
4287 0 : bool DelayModelRow::isDispersiveDelayRateExists() const {
4288 0 : return dispersiveDelayRateExists;
4289 : }
4290 :
4291 :
4292 :
4293 : /**
4294 : * Get dispersiveDelayRate, which is optional.
4295 : * @return dispersiveDelayRate as double
4296 : * @throw IllegalAccessException If dispersiveDelayRate does not exist.
4297 : */
4298 0 : double DelayModelRow::getDispersiveDelayRate() const {
4299 0 : if (!dispersiveDelayRateExists) {
4300 0 : throw IllegalAccessException("dispersiveDelayRate", "DelayModel");
4301 : }
4302 :
4303 0 : return dispersiveDelayRate;
4304 : }
4305 :
4306 : /**
4307 : * Set dispersiveDelayRate with the specified double.
4308 : * @param dispersiveDelayRate The double value to which dispersiveDelayRate is to be set.
4309 :
4310 :
4311 : */
4312 0 : void DelayModelRow::setDispersiveDelayRate (double dispersiveDelayRate) {
4313 :
4314 0 : this->dispersiveDelayRate = dispersiveDelayRate;
4315 :
4316 0 : dispersiveDelayRateExists = true;
4317 :
4318 0 : }
4319 :
4320 :
4321 : /**
4322 : * Mark dispersiveDelayRate, which is an optional field, as non-existent.
4323 : */
4324 0 : void DelayModelRow::clearDispersiveDelayRate () {
4325 0 : dispersiveDelayRateExists = false;
4326 0 : }
4327 :
4328 :
4329 :
4330 : /**
4331 : * The attribute atmosphericDryDelay is optional. Return true if this attribute exists.
4332 : * @return true if and only if the atmosphericDryDelay attribute exists.
4333 : */
4334 0 : bool DelayModelRow::isAtmosphericDryDelayExists() const {
4335 0 : return atmosphericDryDelayExists;
4336 : }
4337 :
4338 :
4339 :
4340 : /**
4341 : * Get atmosphericDryDelay, which is optional.
4342 : * @return atmosphericDryDelay as double
4343 : * @throw IllegalAccessException If atmosphericDryDelay does not exist.
4344 : */
4345 0 : double DelayModelRow::getAtmosphericDryDelay() const {
4346 0 : if (!atmosphericDryDelayExists) {
4347 0 : throw IllegalAccessException("atmosphericDryDelay", "DelayModel");
4348 : }
4349 :
4350 0 : return atmosphericDryDelay;
4351 : }
4352 :
4353 : /**
4354 : * Set atmosphericDryDelay with the specified double.
4355 : * @param atmosphericDryDelay The double value to which atmosphericDryDelay is to be set.
4356 :
4357 :
4358 : */
4359 0 : void DelayModelRow::setAtmosphericDryDelay (double atmosphericDryDelay) {
4360 :
4361 0 : this->atmosphericDryDelay = atmosphericDryDelay;
4362 :
4363 0 : atmosphericDryDelayExists = true;
4364 :
4365 0 : }
4366 :
4367 :
4368 : /**
4369 : * Mark atmosphericDryDelay, which is an optional field, as non-existent.
4370 : */
4371 0 : void DelayModelRow::clearAtmosphericDryDelay () {
4372 0 : atmosphericDryDelayExists = false;
4373 0 : }
4374 :
4375 :
4376 :
4377 : /**
4378 : * The attribute atmosphericWetDelay is optional. Return true if this attribute exists.
4379 : * @return true if and only if the atmosphericWetDelay attribute exists.
4380 : */
4381 0 : bool DelayModelRow::isAtmosphericWetDelayExists() const {
4382 0 : return atmosphericWetDelayExists;
4383 : }
4384 :
4385 :
4386 :
4387 : /**
4388 : * Get atmosphericWetDelay, which is optional.
4389 : * @return atmosphericWetDelay as double
4390 : * @throw IllegalAccessException If atmosphericWetDelay does not exist.
4391 : */
4392 0 : double DelayModelRow::getAtmosphericWetDelay() const {
4393 0 : if (!atmosphericWetDelayExists) {
4394 0 : throw IllegalAccessException("atmosphericWetDelay", "DelayModel");
4395 : }
4396 :
4397 0 : return atmosphericWetDelay;
4398 : }
4399 :
4400 : /**
4401 : * Set atmosphericWetDelay with the specified double.
4402 : * @param atmosphericWetDelay The double value to which atmosphericWetDelay is to be set.
4403 :
4404 :
4405 : */
4406 0 : void DelayModelRow::setAtmosphericWetDelay (double atmosphericWetDelay) {
4407 :
4408 0 : this->atmosphericWetDelay = atmosphericWetDelay;
4409 :
4410 0 : atmosphericWetDelayExists = true;
4411 :
4412 0 : }
4413 :
4414 :
4415 : /**
4416 : * Mark atmosphericWetDelay, which is an optional field, as non-existent.
4417 : */
4418 0 : void DelayModelRow::clearAtmosphericWetDelay () {
4419 0 : atmosphericWetDelayExists = false;
4420 0 : }
4421 :
4422 :
4423 :
4424 : /**
4425 : * The attribute padDelay is optional. Return true if this attribute exists.
4426 : * @return true if and only if the padDelay attribute exists.
4427 : */
4428 0 : bool DelayModelRow::isPadDelayExists() const {
4429 0 : return padDelayExists;
4430 : }
4431 :
4432 :
4433 :
4434 : /**
4435 : * Get padDelay, which is optional.
4436 : * @return padDelay as double
4437 : * @throw IllegalAccessException If padDelay does not exist.
4438 : */
4439 0 : double DelayModelRow::getPadDelay() const {
4440 0 : if (!padDelayExists) {
4441 0 : throw IllegalAccessException("padDelay", "DelayModel");
4442 : }
4443 :
4444 0 : return padDelay;
4445 : }
4446 :
4447 : /**
4448 : * Set padDelay with the specified double.
4449 : * @param padDelay The double value to which padDelay is to be set.
4450 :
4451 :
4452 : */
4453 0 : void DelayModelRow::setPadDelay (double padDelay) {
4454 :
4455 0 : this->padDelay = padDelay;
4456 :
4457 0 : padDelayExists = true;
4458 :
4459 0 : }
4460 :
4461 :
4462 : /**
4463 : * Mark padDelay, which is an optional field, as non-existent.
4464 : */
4465 0 : void DelayModelRow::clearPadDelay () {
4466 0 : padDelayExists = false;
4467 0 : }
4468 :
4469 :
4470 :
4471 : /**
4472 : * The attribute antennaDelay is optional. Return true if this attribute exists.
4473 : * @return true if and only if the antennaDelay attribute exists.
4474 : */
4475 0 : bool DelayModelRow::isAntennaDelayExists() const {
4476 0 : return antennaDelayExists;
4477 : }
4478 :
4479 :
4480 :
4481 : /**
4482 : * Get antennaDelay, which is optional.
4483 : * @return antennaDelay as double
4484 : * @throw IllegalAccessException If antennaDelay does not exist.
4485 : */
4486 0 : double DelayModelRow::getAntennaDelay() const {
4487 0 : if (!antennaDelayExists) {
4488 0 : throw IllegalAccessException("antennaDelay", "DelayModel");
4489 : }
4490 :
4491 0 : return antennaDelay;
4492 : }
4493 :
4494 : /**
4495 : * Set antennaDelay with the specified double.
4496 : * @param antennaDelay The double value to which antennaDelay is to be set.
4497 :
4498 :
4499 : */
4500 0 : void DelayModelRow::setAntennaDelay (double antennaDelay) {
4501 :
4502 0 : this->antennaDelay = antennaDelay;
4503 :
4504 0 : antennaDelayExists = true;
4505 :
4506 0 : }
4507 :
4508 :
4509 : /**
4510 : * Mark antennaDelay, which is an optional field, as non-existent.
4511 : */
4512 0 : void DelayModelRow::clearAntennaDelay () {
4513 0 : antennaDelayExists = false;
4514 0 : }
4515 :
4516 :
4517 :
4518 : /**
4519 : * The attribute numReceptor is optional. Return true if this attribute exists.
4520 : * @return true if and only if the numReceptor attribute exists.
4521 : */
4522 0 : bool DelayModelRow::isNumReceptorExists() const {
4523 0 : return numReceptorExists;
4524 : }
4525 :
4526 :
4527 :
4528 : /**
4529 : * Get numReceptor, which is optional.
4530 : * @return numReceptor as int
4531 : * @throw IllegalAccessException If numReceptor does not exist.
4532 : */
4533 0 : int DelayModelRow::getNumReceptor() const {
4534 0 : if (!numReceptorExists) {
4535 0 : throw IllegalAccessException("numReceptor", "DelayModel");
4536 : }
4537 :
4538 0 : return numReceptor;
4539 : }
4540 :
4541 : /**
4542 : * Set numReceptor with the specified int.
4543 : * @param numReceptor The int value to which numReceptor is to be set.
4544 :
4545 :
4546 : */
4547 0 : void DelayModelRow::setNumReceptor (int numReceptor) {
4548 :
4549 0 : this->numReceptor = numReceptor;
4550 :
4551 0 : numReceptorExists = true;
4552 :
4553 0 : }
4554 :
4555 :
4556 : /**
4557 : * Mark numReceptor, which is an optional field, as non-existent.
4558 : */
4559 0 : void DelayModelRow::clearNumReceptor () {
4560 0 : numReceptorExists = false;
4561 0 : }
4562 :
4563 :
4564 :
4565 : /**
4566 : * The attribute polarizationType is optional. Return true if this attribute exists.
4567 : * @return true if and only if the polarizationType attribute exists.
4568 : */
4569 0 : bool DelayModelRow::isPolarizationTypeExists() const {
4570 0 : return polarizationTypeExists;
4571 : }
4572 :
4573 :
4574 :
4575 : /**
4576 : * Get polarizationType, which is optional.
4577 : * @return polarizationType as std::vector<PolarizationTypeMod::PolarizationType >
4578 : * @throw IllegalAccessException If polarizationType does not exist.
4579 : */
4580 0 : std::vector<PolarizationTypeMod::PolarizationType > DelayModelRow::getPolarizationType() const {
4581 0 : if (!polarizationTypeExists) {
4582 0 : throw IllegalAccessException("polarizationType", "DelayModel");
4583 : }
4584 :
4585 0 : return polarizationType;
4586 : }
4587 :
4588 : /**
4589 : * Set polarizationType with the specified std::vector<PolarizationTypeMod::PolarizationType >.
4590 : * @param polarizationType The std::vector<PolarizationTypeMod::PolarizationType > value to which polarizationType is to be set.
4591 :
4592 :
4593 : */
4594 0 : void DelayModelRow::setPolarizationType (std::vector<PolarizationTypeMod::PolarizationType > polarizationType) {
4595 :
4596 0 : this->polarizationType = polarizationType;
4597 :
4598 0 : polarizationTypeExists = true;
4599 :
4600 0 : }
4601 :
4602 :
4603 : /**
4604 : * Mark polarizationType, which is an optional field, as non-existent.
4605 : */
4606 0 : void DelayModelRow::clearPolarizationType () {
4607 0 : polarizationTypeExists = false;
4608 0 : }
4609 :
4610 :
4611 :
4612 : /**
4613 : * The attribute electronicDelay is optional. Return true if this attribute exists.
4614 : * @return true if and only if the electronicDelay attribute exists.
4615 : */
4616 0 : bool DelayModelRow::isElectronicDelayExists() const {
4617 0 : return electronicDelayExists;
4618 : }
4619 :
4620 :
4621 :
4622 : /**
4623 : * Get electronicDelay, which is optional.
4624 : * @return electronicDelay as std::vector<double >
4625 : * @throw IllegalAccessException If electronicDelay does not exist.
4626 : */
4627 0 : std::vector<double > DelayModelRow::getElectronicDelay() const {
4628 0 : if (!electronicDelayExists) {
4629 0 : throw IllegalAccessException("electronicDelay", "DelayModel");
4630 : }
4631 :
4632 0 : return electronicDelay;
4633 : }
4634 :
4635 : /**
4636 : * Set electronicDelay with the specified std::vector<double >.
4637 : * @param electronicDelay The std::vector<double > value to which electronicDelay is to be set.
4638 :
4639 :
4640 : */
4641 0 : void DelayModelRow::setElectronicDelay (std::vector<double > electronicDelay) {
4642 :
4643 0 : this->electronicDelay = electronicDelay;
4644 :
4645 0 : electronicDelayExists = true;
4646 :
4647 0 : }
4648 :
4649 :
4650 : /**
4651 : * Mark electronicDelay, which is an optional field, as non-existent.
4652 : */
4653 0 : void DelayModelRow::clearElectronicDelay () {
4654 0 : electronicDelayExists = false;
4655 0 : }
4656 :
4657 :
4658 :
4659 : /**
4660 : * The attribute electronicDelayRate is optional. Return true if this attribute exists.
4661 : * @return true if and only if the electronicDelayRate attribute exists.
4662 : */
4663 0 : bool DelayModelRow::isElectronicDelayRateExists() const {
4664 0 : return electronicDelayRateExists;
4665 : }
4666 :
4667 :
4668 :
4669 : /**
4670 : * Get electronicDelayRate, which is optional.
4671 : * @return electronicDelayRate as std::vector<double >
4672 : * @throw IllegalAccessException If electronicDelayRate does not exist.
4673 : */
4674 0 : std::vector<double > DelayModelRow::getElectronicDelayRate() const {
4675 0 : if (!electronicDelayRateExists) {
4676 0 : throw IllegalAccessException("electronicDelayRate", "DelayModel");
4677 : }
4678 :
4679 0 : return electronicDelayRate;
4680 : }
4681 :
4682 : /**
4683 : * Set electronicDelayRate with the specified std::vector<double >.
4684 : * @param electronicDelayRate The std::vector<double > value to which electronicDelayRate is to be set.
4685 :
4686 :
4687 : */
4688 0 : void DelayModelRow::setElectronicDelayRate (std::vector<double > electronicDelayRate) {
4689 :
4690 0 : this->electronicDelayRate = electronicDelayRate;
4691 :
4692 0 : electronicDelayRateExists = true;
4693 :
4694 0 : }
4695 :
4696 :
4697 : /**
4698 : * Mark electronicDelayRate, which is an optional field, as non-existent.
4699 : */
4700 0 : void DelayModelRow::clearElectronicDelayRate () {
4701 0 : electronicDelayRateExists = false;
4702 0 : }
4703 :
4704 :
4705 :
4706 : /**
4707 : * The attribute receiverDelay is optional. Return true if this attribute exists.
4708 : * @return true if and only if the receiverDelay attribute exists.
4709 : */
4710 0 : bool DelayModelRow::isReceiverDelayExists() const {
4711 0 : return receiverDelayExists;
4712 : }
4713 :
4714 :
4715 :
4716 : /**
4717 : * Get receiverDelay, which is optional.
4718 : * @return receiverDelay as std::vector<double >
4719 : * @throw IllegalAccessException If receiverDelay does not exist.
4720 : */
4721 0 : std::vector<double > DelayModelRow::getReceiverDelay() const {
4722 0 : if (!receiverDelayExists) {
4723 0 : throw IllegalAccessException("receiverDelay", "DelayModel");
4724 : }
4725 :
4726 0 : return receiverDelay;
4727 : }
4728 :
4729 : /**
4730 : * Set receiverDelay with the specified std::vector<double >.
4731 : * @param receiverDelay The std::vector<double > value to which receiverDelay is to be set.
4732 :
4733 :
4734 : */
4735 0 : void DelayModelRow::setReceiverDelay (std::vector<double > receiverDelay) {
4736 :
4737 0 : this->receiverDelay = receiverDelay;
4738 :
4739 0 : receiverDelayExists = true;
4740 :
4741 0 : }
4742 :
4743 :
4744 : /**
4745 : * Mark receiverDelay, which is an optional field, as non-existent.
4746 : */
4747 0 : void DelayModelRow::clearReceiverDelay () {
4748 0 : receiverDelayExists = false;
4749 0 : }
4750 :
4751 :
4752 :
4753 : /**
4754 : * The attribute IFDelay is optional. Return true if this attribute exists.
4755 : * @return true if and only if the IFDelay attribute exists.
4756 : */
4757 0 : bool DelayModelRow::isIFDelayExists() const {
4758 0 : return IFDelayExists;
4759 : }
4760 :
4761 :
4762 :
4763 : /**
4764 : * Get IFDelay, which is optional.
4765 : * @return IFDelay as std::vector<double >
4766 : * @throw IllegalAccessException If IFDelay does not exist.
4767 : */
4768 0 : std::vector<double > DelayModelRow::getIFDelay() const {
4769 0 : if (!IFDelayExists) {
4770 0 : throw IllegalAccessException("IFDelay", "DelayModel");
4771 : }
4772 :
4773 0 : return IFDelay;
4774 : }
4775 :
4776 : /**
4777 : * Set IFDelay with the specified std::vector<double >.
4778 : * @param IFDelay The std::vector<double > value to which IFDelay is to be set.
4779 :
4780 :
4781 : */
4782 0 : void DelayModelRow::setIFDelay (std::vector<double > IFDelay) {
4783 :
4784 0 : this->IFDelay = IFDelay;
4785 :
4786 0 : IFDelayExists = true;
4787 :
4788 0 : }
4789 :
4790 :
4791 : /**
4792 : * Mark IFDelay, which is an optional field, as non-existent.
4793 : */
4794 0 : void DelayModelRow::clearIFDelay () {
4795 0 : IFDelayExists = false;
4796 0 : }
4797 :
4798 :
4799 :
4800 : /**
4801 : * The attribute LODelay is optional. Return true if this attribute exists.
4802 : * @return true if and only if the LODelay attribute exists.
4803 : */
4804 0 : bool DelayModelRow::isLODelayExists() const {
4805 0 : return LODelayExists;
4806 : }
4807 :
4808 :
4809 :
4810 : /**
4811 : * Get LODelay, which is optional.
4812 : * @return LODelay as std::vector<double >
4813 : * @throw IllegalAccessException If LODelay does not exist.
4814 : */
4815 0 : std::vector<double > DelayModelRow::getLODelay() const {
4816 0 : if (!LODelayExists) {
4817 0 : throw IllegalAccessException("LODelay", "DelayModel");
4818 : }
4819 :
4820 0 : return LODelay;
4821 : }
4822 :
4823 : /**
4824 : * Set LODelay with the specified std::vector<double >.
4825 : * @param LODelay The std::vector<double > value to which LODelay is to be set.
4826 :
4827 :
4828 : */
4829 0 : void DelayModelRow::setLODelay (std::vector<double > LODelay) {
4830 :
4831 0 : this->LODelay = LODelay;
4832 :
4833 0 : LODelayExists = true;
4834 :
4835 0 : }
4836 :
4837 :
4838 : /**
4839 : * Mark LODelay, which is an optional field, as non-existent.
4840 : */
4841 0 : void DelayModelRow::clearLODelay () {
4842 0 : LODelayExists = false;
4843 0 : }
4844 :
4845 :
4846 :
4847 : /**
4848 : * The attribute crossPolarizationDelay is optional. Return true if this attribute exists.
4849 : * @return true if and only if the crossPolarizationDelay attribute exists.
4850 : */
4851 0 : bool DelayModelRow::isCrossPolarizationDelayExists() const {
4852 0 : return crossPolarizationDelayExists;
4853 : }
4854 :
4855 :
4856 :
4857 : /**
4858 : * Get crossPolarizationDelay, which is optional.
4859 : * @return crossPolarizationDelay as double
4860 : * @throw IllegalAccessException If crossPolarizationDelay does not exist.
4861 : */
4862 0 : double DelayModelRow::getCrossPolarizationDelay() const {
4863 0 : if (!crossPolarizationDelayExists) {
4864 0 : throw IllegalAccessException("crossPolarizationDelay", "DelayModel");
4865 : }
4866 :
4867 0 : return crossPolarizationDelay;
4868 : }
4869 :
4870 : /**
4871 : * Set crossPolarizationDelay with the specified double.
4872 : * @param crossPolarizationDelay The double value to which crossPolarizationDelay is to be set.
4873 :
4874 :
4875 : */
4876 0 : void DelayModelRow::setCrossPolarizationDelay (double crossPolarizationDelay) {
4877 :
4878 0 : this->crossPolarizationDelay = crossPolarizationDelay;
4879 :
4880 0 : crossPolarizationDelayExists = true;
4881 :
4882 0 : }
4883 :
4884 :
4885 : /**
4886 : * Mark crossPolarizationDelay, which is an optional field, as non-existent.
4887 : */
4888 0 : void DelayModelRow::clearCrossPolarizationDelay () {
4889 0 : crossPolarizationDelayExists = false;
4890 0 : }
4891 :
4892 :
4893 :
4894 : ///////////////////////////////////////////////
4895 : // Extrinsic Table Attributes getters/setters//
4896 : ///////////////////////////////////////////////
4897 :
4898 :
4899 :
4900 :
4901 : /**
4902 : * Get antennaId.
4903 : * @return antennaId as Tag
4904 : */
4905 0 : Tag DelayModelRow::getAntennaId() const {
4906 :
4907 0 : return antennaId;
4908 : }
4909 :
4910 : /**
4911 : * Set antennaId with the specified Tag.
4912 : * @param antennaId The Tag value to which antennaId is to be set.
4913 :
4914 :
4915 :
4916 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4917 :
4918 : */
4919 0 : void DelayModelRow::setAntennaId (Tag antennaId) {
4920 :
4921 :
4922 0 : if (hasBeenAdded) {
4923 :
4924 0 : throw IllegalAccessException("antennaId", "DelayModel");
4925 :
4926 : }
4927 :
4928 0 : this->antennaId = antennaId;
4929 :
4930 0 : }
4931 :
4932 :
4933 :
4934 :
4935 :
4936 :
4937 : /**
4938 : * Get fieldId.
4939 : * @return fieldId as Tag
4940 : */
4941 0 : Tag DelayModelRow::getFieldId() const {
4942 :
4943 0 : return fieldId;
4944 : }
4945 :
4946 : /**
4947 : * Set fieldId with the specified Tag.
4948 : * @param fieldId The Tag value to which fieldId is to be set.
4949 :
4950 :
4951 :
4952 : */
4953 0 : void DelayModelRow::setFieldId (Tag fieldId) {
4954 :
4955 :
4956 0 : if (hasBeenAdded) {
4957 :
4958 : }
4959 :
4960 0 : this->fieldId = fieldId;
4961 :
4962 0 : }
4963 :
4964 :
4965 :
4966 :
4967 :
4968 :
4969 : /**
4970 : * Get spectralWindowId.
4971 : * @return spectralWindowId as Tag
4972 : */
4973 0 : Tag DelayModelRow::getSpectralWindowId() const {
4974 :
4975 0 : return spectralWindowId;
4976 : }
4977 :
4978 : /**
4979 : * Set spectralWindowId with the specified Tag.
4980 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
4981 :
4982 :
4983 :
4984 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4985 :
4986 : */
4987 0 : void DelayModelRow::setSpectralWindowId (Tag spectralWindowId) {
4988 :
4989 :
4990 0 : if (hasBeenAdded) {
4991 :
4992 0 : throw IllegalAccessException("spectralWindowId", "DelayModel");
4993 :
4994 : }
4995 :
4996 0 : this->spectralWindowId = spectralWindowId;
4997 :
4998 0 : }
4999 :
5000 :
5001 :
5002 :
5003 : //////////////////////////////////////
5004 : // Links Attributes getters/setters //
5005 : //////////////////////////////////////
5006 :
5007 :
5008 :
5009 :
5010 :
5011 :
5012 : /**
5013 : * Returns the pointer to the row in the Antenna table having Antenna.antennaId == antennaId
5014 : * @return a AntennaRow*
5015 : *
5016 :
5017 : */
5018 0 : AntennaRow* DelayModelRow::getAntennaUsingAntennaId() {
5019 :
5020 0 : return table.getContainer().getAntenna().getRowByKey(antennaId);
5021 : }
5022 :
5023 :
5024 :
5025 :
5026 :
5027 :
5028 :
5029 :
5030 :
5031 : /**
5032 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.spectralWindowId == spectralWindowId
5033 : * @return a SpectralWindowRow*
5034 : *
5035 :
5036 : */
5037 0 : SpectralWindowRow* DelayModelRow::getSpectralWindowUsingSpectralWindowId() {
5038 :
5039 0 : return table.getContainer().getSpectralWindow().getRowByKey(spectralWindowId);
5040 : }
5041 :
5042 :
5043 :
5044 :
5045 :
5046 :
5047 :
5048 :
5049 :
5050 : /**
5051 : * Returns the pointer to the row in the Field table having Field.fieldId == fieldId
5052 : * @return a FieldRow*
5053 : *
5054 :
5055 : */
5056 0 : FieldRow* DelayModelRow::getFieldUsingFieldId() {
5057 :
5058 0 : return table.getContainer().getField().getRowByKey(fieldId);
5059 : }
5060 :
5061 :
5062 :
5063 :
5064 :
5065 : /**
5066 : * Create a DelayModelRow.
5067 : * <p>
5068 : * This constructor is private because only the
5069 : * table can create rows. All rows know the table
5070 : * to which they belong.
5071 : * @param table The table to which this row belongs.
5072 : */
5073 0 : DelayModelRow::DelayModelRow (DelayModelTable &t) : table(t) {
5074 0 : hasBeenAdded = false;
5075 :
5076 :
5077 :
5078 :
5079 :
5080 :
5081 :
5082 :
5083 :
5084 :
5085 :
5086 :
5087 :
5088 :
5089 :
5090 0 : timeOriginExists = false;
5091 :
5092 :
5093 :
5094 0 : atmosphericGroupDelayExists = false;
5095 :
5096 :
5097 :
5098 0 : atmosphericGroupDelayRateExists = false;
5099 :
5100 :
5101 :
5102 0 : geometricDelayExists = false;
5103 :
5104 :
5105 :
5106 0 : geometricDelayRateExists = false;
5107 :
5108 :
5109 :
5110 0 : numLOExists = false;
5111 :
5112 :
5113 :
5114 0 : LOOffsetExists = false;
5115 :
5116 :
5117 :
5118 0 : LOOffsetRateExists = false;
5119 :
5120 :
5121 :
5122 0 : dispersiveDelayExists = false;
5123 :
5124 :
5125 :
5126 0 : dispersiveDelayRateExists = false;
5127 :
5128 :
5129 :
5130 0 : atmosphericDryDelayExists = false;
5131 :
5132 :
5133 :
5134 0 : atmosphericWetDelayExists = false;
5135 :
5136 :
5137 :
5138 0 : padDelayExists = false;
5139 :
5140 :
5141 :
5142 0 : antennaDelayExists = false;
5143 :
5144 :
5145 :
5146 0 : numReceptorExists = false;
5147 :
5148 :
5149 :
5150 0 : polarizationTypeExists = false;
5151 :
5152 :
5153 :
5154 0 : electronicDelayExists = false;
5155 :
5156 :
5157 :
5158 0 : electronicDelayRateExists = false;
5159 :
5160 :
5161 :
5162 0 : receiverDelayExists = false;
5163 :
5164 :
5165 :
5166 0 : IFDelayExists = false;
5167 :
5168 :
5169 :
5170 0 : LODelayExists = false;
5171 :
5172 :
5173 :
5174 0 : crossPolarizationDelayExists = false;
5175 :
5176 :
5177 :
5178 :
5179 :
5180 :
5181 :
5182 :
5183 :
5184 :
5185 :
5186 :
5187 :
5188 :
5189 :
5190 :
5191 :
5192 :
5193 :
5194 :
5195 :
5196 :
5197 :
5198 :
5199 :
5200 :
5201 :
5202 :
5203 :
5204 :
5205 :
5206 :
5207 :
5208 :
5209 :
5210 :
5211 :
5212 :
5213 :
5214 :
5215 :
5216 :
5217 :
5218 :
5219 :
5220 :
5221 :
5222 :
5223 :
5224 :
5225 :
5226 :
5227 :
5228 :
5229 :
5230 :
5231 :
5232 :
5233 :
5234 :
5235 :
5236 :
5237 :
5238 :
5239 :
5240 :
5241 :
5242 :
5243 :
5244 :
5245 0 : fromBinMethods["antennaId"] = &DelayModelRow::antennaIdFromBin;
5246 0 : fromBinMethods["spectralWindowId"] = &DelayModelRow::spectralWindowIdFromBin;
5247 0 : fromBinMethods["timeInterval"] = &DelayModelRow::timeIntervalFromBin;
5248 0 : fromBinMethods["numPoly"] = &DelayModelRow::numPolyFromBin;
5249 0 : fromBinMethods["phaseDelay"] = &DelayModelRow::phaseDelayFromBin;
5250 0 : fromBinMethods["phaseDelayRate"] = &DelayModelRow::phaseDelayRateFromBin;
5251 0 : fromBinMethods["groupDelay"] = &DelayModelRow::groupDelayFromBin;
5252 0 : fromBinMethods["groupDelayRate"] = &DelayModelRow::groupDelayRateFromBin;
5253 0 : fromBinMethods["fieldId"] = &DelayModelRow::fieldIdFromBin;
5254 :
5255 :
5256 0 : fromBinMethods["timeOrigin"] = &DelayModelRow::timeOriginFromBin;
5257 0 : fromBinMethods["atmosphericGroupDelay"] = &DelayModelRow::atmosphericGroupDelayFromBin;
5258 0 : fromBinMethods["atmosphericGroupDelayRate"] = &DelayModelRow::atmosphericGroupDelayRateFromBin;
5259 0 : fromBinMethods["geometricDelay"] = &DelayModelRow::geometricDelayFromBin;
5260 0 : fromBinMethods["geometricDelayRate"] = &DelayModelRow::geometricDelayRateFromBin;
5261 0 : fromBinMethods["numLO"] = &DelayModelRow::numLOFromBin;
5262 0 : fromBinMethods["LOOffset"] = &DelayModelRow::LOOffsetFromBin;
5263 0 : fromBinMethods["LOOffsetRate"] = &DelayModelRow::LOOffsetRateFromBin;
5264 0 : fromBinMethods["dispersiveDelay"] = &DelayModelRow::dispersiveDelayFromBin;
5265 0 : fromBinMethods["dispersiveDelayRate"] = &DelayModelRow::dispersiveDelayRateFromBin;
5266 0 : fromBinMethods["atmosphericDryDelay"] = &DelayModelRow::atmosphericDryDelayFromBin;
5267 0 : fromBinMethods["atmosphericWetDelay"] = &DelayModelRow::atmosphericWetDelayFromBin;
5268 0 : fromBinMethods["padDelay"] = &DelayModelRow::padDelayFromBin;
5269 0 : fromBinMethods["antennaDelay"] = &DelayModelRow::antennaDelayFromBin;
5270 0 : fromBinMethods["numReceptor"] = &DelayModelRow::numReceptorFromBin;
5271 0 : fromBinMethods["polarizationType"] = &DelayModelRow::polarizationTypeFromBin;
5272 0 : fromBinMethods["electronicDelay"] = &DelayModelRow::electronicDelayFromBin;
5273 0 : fromBinMethods["electronicDelayRate"] = &DelayModelRow::electronicDelayRateFromBin;
5274 0 : fromBinMethods["receiverDelay"] = &DelayModelRow::receiverDelayFromBin;
5275 0 : fromBinMethods["IFDelay"] = &DelayModelRow::IFDelayFromBin;
5276 0 : fromBinMethods["LODelay"] = &DelayModelRow::LODelayFromBin;
5277 0 : fromBinMethods["crossPolarizationDelay"] = &DelayModelRow::crossPolarizationDelayFromBin;
5278 :
5279 :
5280 :
5281 :
5282 :
5283 0 : fromTextMethods["antennaId"] = &DelayModelRow::antennaIdFromText;
5284 :
5285 :
5286 :
5287 0 : fromTextMethods["spectralWindowId"] = &DelayModelRow::spectralWindowIdFromText;
5288 :
5289 :
5290 :
5291 0 : fromTextMethods["timeInterval"] = &DelayModelRow::timeIntervalFromText;
5292 :
5293 :
5294 :
5295 0 : fromTextMethods["numPoly"] = &DelayModelRow::numPolyFromText;
5296 :
5297 :
5298 :
5299 0 : fromTextMethods["phaseDelay"] = &DelayModelRow::phaseDelayFromText;
5300 :
5301 :
5302 :
5303 0 : fromTextMethods["phaseDelayRate"] = &DelayModelRow::phaseDelayRateFromText;
5304 :
5305 :
5306 :
5307 0 : fromTextMethods["groupDelay"] = &DelayModelRow::groupDelayFromText;
5308 :
5309 :
5310 :
5311 0 : fromTextMethods["groupDelayRate"] = &DelayModelRow::groupDelayRateFromText;
5312 :
5313 :
5314 :
5315 0 : fromTextMethods["fieldId"] = &DelayModelRow::fieldIdFromText;
5316 :
5317 :
5318 :
5319 :
5320 :
5321 0 : fromTextMethods["timeOrigin"] = &DelayModelRow::timeOriginFromText;
5322 :
5323 :
5324 :
5325 0 : fromTextMethods["atmosphericGroupDelay"] = &DelayModelRow::atmosphericGroupDelayFromText;
5326 :
5327 :
5328 :
5329 0 : fromTextMethods["atmosphericGroupDelayRate"] = &DelayModelRow::atmosphericGroupDelayRateFromText;
5330 :
5331 :
5332 :
5333 0 : fromTextMethods["geometricDelay"] = &DelayModelRow::geometricDelayFromText;
5334 :
5335 :
5336 :
5337 0 : fromTextMethods["geometricDelayRate"] = &DelayModelRow::geometricDelayRateFromText;
5338 :
5339 :
5340 :
5341 0 : fromTextMethods["numLO"] = &DelayModelRow::numLOFromText;
5342 :
5343 :
5344 :
5345 0 : fromTextMethods["LOOffset"] = &DelayModelRow::LOOffsetFromText;
5346 :
5347 :
5348 :
5349 0 : fromTextMethods["LOOffsetRate"] = &DelayModelRow::LOOffsetRateFromText;
5350 :
5351 :
5352 :
5353 0 : fromTextMethods["dispersiveDelay"] = &DelayModelRow::dispersiveDelayFromText;
5354 :
5355 :
5356 :
5357 0 : fromTextMethods["dispersiveDelayRate"] = &DelayModelRow::dispersiveDelayRateFromText;
5358 :
5359 :
5360 :
5361 0 : fromTextMethods["atmosphericDryDelay"] = &DelayModelRow::atmosphericDryDelayFromText;
5362 :
5363 :
5364 :
5365 0 : fromTextMethods["atmosphericWetDelay"] = &DelayModelRow::atmosphericWetDelayFromText;
5366 :
5367 :
5368 :
5369 0 : fromTextMethods["padDelay"] = &DelayModelRow::padDelayFromText;
5370 :
5371 :
5372 :
5373 0 : fromTextMethods["antennaDelay"] = &DelayModelRow::antennaDelayFromText;
5374 :
5375 :
5376 :
5377 0 : fromTextMethods["numReceptor"] = &DelayModelRow::numReceptorFromText;
5378 :
5379 :
5380 :
5381 0 : fromTextMethods["polarizationType"] = &DelayModelRow::polarizationTypeFromText;
5382 :
5383 :
5384 :
5385 0 : fromTextMethods["electronicDelay"] = &DelayModelRow::electronicDelayFromText;
5386 :
5387 :
5388 :
5389 0 : fromTextMethods["electronicDelayRate"] = &DelayModelRow::electronicDelayRateFromText;
5390 :
5391 :
5392 :
5393 0 : fromTextMethods["receiverDelay"] = &DelayModelRow::receiverDelayFromText;
5394 :
5395 :
5396 :
5397 0 : fromTextMethods["IFDelay"] = &DelayModelRow::IFDelayFromText;
5398 :
5399 :
5400 :
5401 0 : fromTextMethods["LODelay"] = &DelayModelRow::LODelayFromText;
5402 :
5403 :
5404 :
5405 0 : fromTextMethods["crossPolarizationDelay"] = &DelayModelRow::crossPolarizationDelayFromText;
5406 :
5407 :
5408 0 : }
5409 :
5410 0 : DelayModelRow::DelayModelRow (DelayModelTable &t, DelayModelRow *row) : table(t) {
5411 0 : hasBeenAdded = false;
5412 :
5413 0 : if (row == 0) {
5414 :
5415 :
5416 :
5417 :
5418 :
5419 :
5420 :
5421 :
5422 :
5423 :
5424 :
5425 :
5426 :
5427 :
5428 :
5429 0 : timeOriginExists = false;
5430 :
5431 :
5432 :
5433 0 : atmosphericGroupDelayExists = false;
5434 :
5435 :
5436 :
5437 0 : atmosphericGroupDelayRateExists = false;
5438 :
5439 :
5440 :
5441 0 : geometricDelayExists = false;
5442 :
5443 :
5444 :
5445 0 : geometricDelayRateExists = false;
5446 :
5447 :
5448 :
5449 0 : numLOExists = false;
5450 :
5451 :
5452 :
5453 0 : LOOffsetExists = false;
5454 :
5455 :
5456 :
5457 0 : LOOffsetRateExists = false;
5458 :
5459 :
5460 :
5461 0 : dispersiveDelayExists = false;
5462 :
5463 :
5464 :
5465 0 : dispersiveDelayRateExists = false;
5466 :
5467 :
5468 :
5469 0 : atmosphericDryDelayExists = false;
5470 :
5471 :
5472 :
5473 0 : atmosphericWetDelayExists = false;
5474 :
5475 :
5476 :
5477 0 : padDelayExists = false;
5478 :
5479 :
5480 :
5481 0 : antennaDelayExists = false;
5482 :
5483 :
5484 :
5485 0 : numReceptorExists = false;
5486 :
5487 :
5488 :
5489 0 : polarizationTypeExists = false;
5490 :
5491 :
5492 :
5493 0 : electronicDelayExists = false;
5494 :
5495 :
5496 :
5497 0 : electronicDelayRateExists = false;
5498 :
5499 :
5500 :
5501 0 : receiverDelayExists = false;
5502 :
5503 :
5504 :
5505 0 : IFDelayExists = false;
5506 :
5507 :
5508 :
5509 0 : LODelayExists = false;
5510 :
5511 :
5512 :
5513 0 : crossPolarizationDelayExists = false;
5514 :
5515 :
5516 :
5517 :
5518 :
5519 :
5520 :
5521 :
5522 :
5523 : }
5524 : else {
5525 :
5526 :
5527 0 : antennaId = row->antennaId;
5528 :
5529 0 : spectralWindowId = row->spectralWindowId;
5530 :
5531 0 : timeInterval = row->timeInterval;
5532 :
5533 :
5534 :
5535 :
5536 0 : numPoly = row->numPoly;
5537 :
5538 0 : phaseDelay = row->phaseDelay;
5539 :
5540 0 : phaseDelayRate = row->phaseDelayRate;
5541 :
5542 0 : groupDelay = row->groupDelay;
5543 :
5544 0 : groupDelayRate = row->groupDelayRate;
5545 :
5546 0 : fieldId = row->fieldId;
5547 :
5548 :
5549 :
5550 :
5551 0 : if (row->timeOriginExists) {
5552 0 : timeOrigin = row->timeOrigin;
5553 0 : timeOriginExists = true;
5554 : }
5555 : else
5556 0 : timeOriginExists = false;
5557 :
5558 0 : if (row->atmosphericGroupDelayExists) {
5559 0 : atmosphericGroupDelay = row->atmosphericGroupDelay;
5560 0 : atmosphericGroupDelayExists = true;
5561 : }
5562 : else
5563 0 : atmosphericGroupDelayExists = false;
5564 :
5565 0 : if (row->atmosphericGroupDelayRateExists) {
5566 0 : atmosphericGroupDelayRate = row->atmosphericGroupDelayRate;
5567 0 : atmosphericGroupDelayRateExists = true;
5568 : }
5569 : else
5570 0 : atmosphericGroupDelayRateExists = false;
5571 :
5572 0 : if (row->geometricDelayExists) {
5573 0 : geometricDelay = row->geometricDelay;
5574 0 : geometricDelayExists = true;
5575 : }
5576 : else
5577 0 : geometricDelayExists = false;
5578 :
5579 0 : if (row->geometricDelayRateExists) {
5580 0 : geometricDelayRate = row->geometricDelayRate;
5581 0 : geometricDelayRateExists = true;
5582 : }
5583 : else
5584 0 : geometricDelayRateExists = false;
5585 :
5586 0 : if (row->numLOExists) {
5587 0 : numLO = row->numLO;
5588 0 : numLOExists = true;
5589 : }
5590 : else
5591 0 : numLOExists = false;
5592 :
5593 0 : if (row->LOOffsetExists) {
5594 0 : LOOffset = row->LOOffset;
5595 0 : LOOffsetExists = true;
5596 : }
5597 : else
5598 0 : LOOffsetExists = false;
5599 :
5600 0 : if (row->LOOffsetRateExists) {
5601 0 : LOOffsetRate = row->LOOffsetRate;
5602 0 : LOOffsetRateExists = true;
5603 : }
5604 : else
5605 0 : LOOffsetRateExists = false;
5606 :
5607 0 : if (row->dispersiveDelayExists) {
5608 0 : dispersiveDelay = row->dispersiveDelay;
5609 0 : dispersiveDelayExists = true;
5610 : }
5611 : else
5612 0 : dispersiveDelayExists = false;
5613 :
5614 0 : if (row->dispersiveDelayRateExists) {
5615 0 : dispersiveDelayRate = row->dispersiveDelayRate;
5616 0 : dispersiveDelayRateExists = true;
5617 : }
5618 : else
5619 0 : dispersiveDelayRateExists = false;
5620 :
5621 0 : if (row->atmosphericDryDelayExists) {
5622 0 : atmosphericDryDelay = row->atmosphericDryDelay;
5623 0 : atmosphericDryDelayExists = true;
5624 : }
5625 : else
5626 0 : atmosphericDryDelayExists = false;
5627 :
5628 0 : if (row->atmosphericWetDelayExists) {
5629 0 : atmosphericWetDelay = row->atmosphericWetDelay;
5630 0 : atmosphericWetDelayExists = true;
5631 : }
5632 : else
5633 0 : atmosphericWetDelayExists = false;
5634 :
5635 0 : if (row->padDelayExists) {
5636 0 : padDelay = row->padDelay;
5637 0 : padDelayExists = true;
5638 : }
5639 : else
5640 0 : padDelayExists = false;
5641 :
5642 0 : if (row->antennaDelayExists) {
5643 0 : antennaDelay = row->antennaDelay;
5644 0 : antennaDelayExists = true;
5645 : }
5646 : else
5647 0 : antennaDelayExists = false;
5648 :
5649 0 : if (row->numReceptorExists) {
5650 0 : numReceptor = row->numReceptor;
5651 0 : numReceptorExists = true;
5652 : }
5653 : else
5654 0 : numReceptorExists = false;
5655 :
5656 0 : if (row->polarizationTypeExists) {
5657 0 : polarizationType = row->polarizationType;
5658 0 : polarizationTypeExists = true;
5659 : }
5660 : else
5661 0 : polarizationTypeExists = false;
5662 :
5663 0 : if (row->electronicDelayExists) {
5664 0 : electronicDelay = row->electronicDelay;
5665 0 : electronicDelayExists = true;
5666 : }
5667 : else
5668 0 : electronicDelayExists = false;
5669 :
5670 0 : if (row->electronicDelayRateExists) {
5671 0 : electronicDelayRate = row->electronicDelayRate;
5672 0 : electronicDelayRateExists = true;
5673 : }
5674 : else
5675 0 : electronicDelayRateExists = false;
5676 :
5677 0 : if (row->receiverDelayExists) {
5678 0 : receiverDelay = row->receiverDelay;
5679 0 : receiverDelayExists = true;
5680 : }
5681 : else
5682 0 : receiverDelayExists = false;
5683 :
5684 0 : if (row->IFDelayExists) {
5685 0 : IFDelay = row->IFDelay;
5686 0 : IFDelayExists = true;
5687 : }
5688 : else
5689 0 : IFDelayExists = false;
5690 :
5691 0 : if (row->LODelayExists) {
5692 0 : LODelay = row->LODelay;
5693 0 : LODelayExists = true;
5694 : }
5695 : else
5696 0 : LODelayExists = false;
5697 :
5698 0 : if (row->crossPolarizationDelayExists) {
5699 0 : crossPolarizationDelay = row->crossPolarizationDelay;
5700 0 : crossPolarizationDelayExists = true;
5701 : }
5702 : else
5703 0 : crossPolarizationDelayExists = false;
5704 :
5705 : }
5706 :
5707 0 : fromBinMethods["antennaId"] = &DelayModelRow::antennaIdFromBin;
5708 0 : fromBinMethods["spectralWindowId"] = &DelayModelRow::spectralWindowIdFromBin;
5709 0 : fromBinMethods["timeInterval"] = &DelayModelRow::timeIntervalFromBin;
5710 0 : fromBinMethods["numPoly"] = &DelayModelRow::numPolyFromBin;
5711 0 : fromBinMethods["phaseDelay"] = &DelayModelRow::phaseDelayFromBin;
5712 0 : fromBinMethods["phaseDelayRate"] = &DelayModelRow::phaseDelayRateFromBin;
5713 0 : fromBinMethods["groupDelay"] = &DelayModelRow::groupDelayFromBin;
5714 0 : fromBinMethods["groupDelayRate"] = &DelayModelRow::groupDelayRateFromBin;
5715 0 : fromBinMethods["fieldId"] = &DelayModelRow::fieldIdFromBin;
5716 :
5717 :
5718 0 : fromBinMethods["timeOrigin"] = &DelayModelRow::timeOriginFromBin;
5719 0 : fromBinMethods["atmosphericGroupDelay"] = &DelayModelRow::atmosphericGroupDelayFromBin;
5720 0 : fromBinMethods["atmosphericGroupDelayRate"] = &DelayModelRow::atmosphericGroupDelayRateFromBin;
5721 0 : fromBinMethods["geometricDelay"] = &DelayModelRow::geometricDelayFromBin;
5722 0 : fromBinMethods["geometricDelayRate"] = &DelayModelRow::geometricDelayRateFromBin;
5723 0 : fromBinMethods["numLO"] = &DelayModelRow::numLOFromBin;
5724 0 : fromBinMethods["LOOffset"] = &DelayModelRow::LOOffsetFromBin;
5725 0 : fromBinMethods["LOOffsetRate"] = &DelayModelRow::LOOffsetRateFromBin;
5726 0 : fromBinMethods["dispersiveDelay"] = &DelayModelRow::dispersiveDelayFromBin;
5727 0 : fromBinMethods["dispersiveDelayRate"] = &DelayModelRow::dispersiveDelayRateFromBin;
5728 0 : fromBinMethods["atmosphericDryDelay"] = &DelayModelRow::atmosphericDryDelayFromBin;
5729 0 : fromBinMethods["atmosphericWetDelay"] = &DelayModelRow::atmosphericWetDelayFromBin;
5730 0 : fromBinMethods["padDelay"] = &DelayModelRow::padDelayFromBin;
5731 0 : fromBinMethods["antennaDelay"] = &DelayModelRow::antennaDelayFromBin;
5732 0 : fromBinMethods["numReceptor"] = &DelayModelRow::numReceptorFromBin;
5733 0 : fromBinMethods["polarizationType"] = &DelayModelRow::polarizationTypeFromBin;
5734 0 : fromBinMethods["electronicDelay"] = &DelayModelRow::electronicDelayFromBin;
5735 0 : fromBinMethods["electronicDelayRate"] = &DelayModelRow::electronicDelayRateFromBin;
5736 0 : fromBinMethods["receiverDelay"] = &DelayModelRow::receiverDelayFromBin;
5737 0 : fromBinMethods["IFDelay"] = &DelayModelRow::IFDelayFromBin;
5738 0 : fromBinMethods["LODelay"] = &DelayModelRow::LODelayFromBin;
5739 0 : fromBinMethods["crossPolarizationDelay"] = &DelayModelRow::crossPolarizationDelayFromBin;
5740 :
5741 0 : }
5742 :
5743 :
5744 0 : bool DelayModelRow::compareNoAutoInc(Tag antennaId, Tag spectralWindowId, ArrayTimeInterval timeInterval, int numPoly, std::vector<double > phaseDelay, std::vector<double > phaseDelayRate, std::vector<double > groupDelay, std::vector<double > groupDelayRate, Tag fieldId) {
5745 : bool result;
5746 0 : result = true;
5747 :
5748 :
5749 :
5750 0 : result = result && (this->antennaId == antennaId);
5751 :
5752 0 : if (!result) return false;
5753 :
5754 :
5755 :
5756 :
5757 0 : result = result && (this->spectralWindowId == spectralWindowId);
5758 :
5759 0 : if (!result) return false;
5760 :
5761 :
5762 :
5763 :
5764 0 : result = result && (this->timeInterval.overlaps(timeInterval));
5765 :
5766 0 : if (!result) return false;
5767 :
5768 :
5769 :
5770 :
5771 0 : result = result && (this->numPoly == numPoly);
5772 :
5773 0 : if (!result) return false;
5774 :
5775 :
5776 :
5777 :
5778 0 : result = result && (this->phaseDelay == phaseDelay);
5779 :
5780 0 : if (!result) return false;
5781 :
5782 :
5783 :
5784 :
5785 0 : result = result && (this->phaseDelayRate == phaseDelayRate);
5786 :
5787 0 : if (!result) return false;
5788 :
5789 :
5790 :
5791 :
5792 0 : result = result && (this->groupDelay == groupDelay);
5793 :
5794 0 : if (!result) return false;
5795 :
5796 :
5797 :
5798 :
5799 0 : result = result && (this->groupDelayRate == groupDelayRate);
5800 :
5801 0 : if (!result) return false;
5802 :
5803 :
5804 :
5805 :
5806 0 : result = result && (this->fieldId == fieldId);
5807 :
5808 0 : if (!result) return false;
5809 :
5810 :
5811 0 : return result;
5812 : }
5813 :
5814 :
5815 :
5816 0 : bool DelayModelRow::compareRequiredValue(int numPoly, std::vector<double > phaseDelay, std::vector<double > phaseDelayRate, std::vector<double > groupDelay, std::vector<double > groupDelayRate, Tag fieldId) {
5817 : bool result;
5818 0 : result = true;
5819 :
5820 :
5821 0 : if (!(this->numPoly == numPoly)) return false;
5822 :
5823 :
5824 :
5825 0 : if (!(this->phaseDelay == phaseDelay)) return false;
5826 :
5827 :
5828 :
5829 0 : if (!(this->phaseDelayRate == phaseDelayRate)) return false;
5830 :
5831 :
5832 :
5833 0 : if (!(this->groupDelay == groupDelay)) return false;
5834 :
5835 :
5836 :
5837 0 : if (!(this->groupDelayRate == groupDelayRate)) return false;
5838 :
5839 :
5840 :
5841 0 : if (!(this->fieldId == fieldId)) return false;
5842 :
5843 :
5844 0 : return result;
5845 : }
5846 :
5847 :
5848 : /**
5849 : * Return true if all required attributes of the value part are equal to their homologues
5850 : * in x and false otherwise.
5851 : *
5852 :
5853 : * @param x a pointer on the DelayModelRow whose required attributes of the value part
5854 :
5855 : * will be compared with those of this.
5856 : * @return a boolean.
5857 : */
5858 0 : bool DelayModelRow::equalByRequiredValue(DelayModelRow* x ) {
5859 :
5860 :
5861 0 : if (this->numPoly != x->numPoly) return false;
5862 :
5863 0 : if (this->phaseDelay != x->phaseDelay) return false;
5864 :
5865 0 : if (this->phaseDelayRate != x->phaseDelayRate) return false;
5866 :
5867 0 : if (this->groupDelay != x->groupDelay) return false;
5868 :
5869 0 : if (this->groupDelayRate != x->groupDelayRate) return false;
5870 :
5871 0 : if (this->fieldId != x->fieldId) return false;
5872 :
5873 :
5874 0 : return true;
5875 : }
5876 :
5877 : /*
5878 : map<string, DelayModelAttributeFromBin> DelayModelRow::initFromBinMethods() {
5879 : map<string, DelayModelAttributeFromBin> result;
5880 :
5881 : result["antennaId"] = &DelayModelRow::antennaIdFromBin;
5882 : result["spectralWindowId"] = &DelayModelRow::spectralWindowIdFromBin;
5883 : result["timeInterval"] = &DelayModelRow::timeIntervalFromBin;
5884 : result["numPoly"] = &DelayModelRow::numPolyFromBin;
5885 : result["phaseDelay"] = &DelayModelRow::phaseDelayFromBin;
5886 : result["phaseDelayRate"] = &DelayModelRow::phaseDelayRateFromBin;
5887 : result["groupDelay"] = &DelayModelRow::groupDelayFromBin;
5888 : result["groupDelayRate"] = &DelayModelRow::groupDelayRateFromBin;
5889 : result["fieldId"] = &DelayModelRow::fieldIdFromBin;
5890 :
5891 :
5892 : result["timeOrigin"] = &DelayModelRow::timeOriginFromBin;
5893 : result["atmosphericGroupDelay"] = &DelayModelRow::atmosphericGroupDelayFromBin;
5894 : result["atmosphericGroupDelayRate"] = &DelayModelRow::atmosphericGroupDelayRateFromBin;
5895 : result["geometricDelay"] = &DelayModelRow::geometricDelayFromBin;
5896 : result["geometricDelayRate"] = &DelayModelRow::geometricDelayRateFromBin;
5897 : result["numLO"] = &DelayModelRow::numLOFromBin;
5898 : result["LOOffset"] = &DelayModelRow::LOOffsetFromBin;
5899 : result["LOOffsetRate"] = &DelayModelRow::LOOffsetRateFromBin;
5900 : result["dispersiveDelay"] = &DelayModelRow::dispersiveDelayFromBin;
5901 : result["dispersiveDelayRate"] = &DelayModelRow::dispersiveDelayRateFromBin;
5902 : result["atmosphericDryDelay"] = &DelayModelRow::atmosphericDryDelayFromBin;
5903 : result["atmosphericWetDelay"] = &DelayModelRow::atmosphericWetDelayFromBin;
5904 : result["padDelay"] = &DelayModelRow::padDelayFromBin;
5905 : result["antennaDelay"] = &DelayModelRow::antennaDelayFromBin;
5906 : result["numReceptor"] = &DelayModelRow::numReceptorFromBin;
5907 : result["polarizationType"] = &DelayModelRow::polarizationTypeFromBin;
5908 : result["electronicDelay"] = &DelayModelRow::electronicDelayFromBin;
5909 : result["electronicDelayRate"] = &DelayModelRow::electronicDelayRateFromBin;
5910 : result["receiverDelay"] = &DelayModelRow::receiverDelayFromBin;
5911 : result["IFDelay"] = &DelayModelRow::IFDelayFromBin;
5912 : result["LODelay"] = &DelayModelRow::LODelayFromBin;
5913 : result["crossPolarizationDelay"] = &DelayModelRow::crossPolarizationDelayFromBin;
5914 :
5915 :
5916 : return result;
5917 : }
5918 : */
5919 : } // End namespace asdm
5920 :
|
