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 CalAntennaSolutionsRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalAntennaSolutionsRow.h>
39 : #include <alma/ASDM/CalAntennaSolutionsTable.h>
40 :
41 : #include <alma/ASDM/CalDataTable.h>
42 : #include <alma/ASDM/CalDataRow.h>
43 :
44 : #include <alma/ASDM/CalReductionTable.h>
45 : #include <alma/ASDM/CalReductionRow.h>
46 :
47 : #include <alma/ASDM/SpectralWindowTable.h>
48 : #include <alma/ASDM/SpectralWindowRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::CalAntennaSolutionsRow;
53 : using asdm::CalAntennaSolutionsTable;
54 :
55 : using asdm::CalDataTable;
56 : using asdm::CalDataRow;
57 :
58 : using asdm::CalReductionTable;
59 : using asdm::CalReductionRow;
60 :
61 : using asdm::SpectralWindowTable;
62 : using asdm::SpectralWindowRow;
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 : CalAntennaSolutionsRow::~CalAntennaSolutionsRow() {
76 0 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 0 : CalAntennaSolutionsTable &CalAntennaSolutionsRow::getTable() const {
82 0 : return table;
83 : }
84 :
85 0 : bool CalAntennaSolutionsRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 0 : void CalAntennaSolutionsRow::isAdded(bool added) {
90 0 : hasBeenAdded = added;
91 0 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::CalAntennaSolutionsRowIDL;
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 CalAntennaSolutionsRowIDL struct.
101 : */
102 : CalAntennaSolutionsRowIDL *CalAntennaSolutionsRow::toIDL() const {
103 : CalAntennaSolutionsRowIDL *x = new CalAntennaSolutionsRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 :
114 : x->antennaName = CORBA::string_dup(antennaName.c_str());
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 :
125 :
126 : x->atmPhaseCorrection = atmPhaseCorrection;
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 : x->basebandName = basebandName;
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 : x->receiverBand = receiverBand;
151 :
152 :
153 :
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 : x->startValidTime = startValidTime.toIDLArrayTime();
162 :
163 :
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 : x->endValidTime = endValidTime.toIDLArrayTime();
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 : x->numReceptor = numReceptor;
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 : x->refAntennaName = CORBA::string_dup(refAntennaName.c_str());
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 : x->direction.length(direction.size());
206 : for (unsigned int i = 0; i < direction.size(); ++i) {
207 :
208 : x->direction[i] = direction.at(i).toIDLAngle();
209 :
210 : }
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 : x->frequencyRange.length(frequencyRange.size());
221 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
222 :
223 : x->frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
224 :
225 : }
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 : x->integrationTime = integrationTime.toIDLInterval();
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 : x->polarizationTypes.length(polarizationTypes.size());
246 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
247 :
248 :
249 : x->polarizationTypes[i] = polarizationTypes.at(i);
250 :
251 :
252 : }
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 :
261 :
262 :
263 : x->correctionValidity = correctionValidity;
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 :
274 : x->phaseAnt.length(phaseAnt.size());
275 : for (unsigned int i = 0; i < phaseAnt.size(); ++i) {
276 :
277 :
278 : x->phaseAnt[i] = phaseAnt.at(i);
279 :
280 :
281 : }
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 : x->phaseAntRMS.length(phaseAntRMS.size());
292 : for (unsigned int i = 0; i < phaseAntRMS.size(); ++i) {
293 :
294 :
295 : x->phaseAntRMS[i] = phaseAntRMS.at(i);
296 :
297 :
298 : }
299 :
300 :
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 : x->amplitudeAnt.length(amplitudeAnt.size());
309 : for (unsigned int i = 0; i < amplitudeAnt.size(); ++i) {
310 :
311 :
312 : x->amplitudeAnt[i] = amplitudeAnt.at(i);
313 :
314 :
315 : }
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 : x->amplitudeAntRMS.length(amplitudeAntRMS.size());
326 : for (unsigned int i = 0; i < amplitudeAntRMS.size(); ++i) {
327 :
328 :
329 : x->amplitudeAntRMS[i] = amplitudeAntRMS.at(i);
330 :
331 :
332 : }
333 :
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 : x->calDataId = calDataId.toIDLTag();
347 :
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 : x->calReductionId = calReductionId.toIDLTag();
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 : x->spectralWindowId = spectralWindowId.toIDLTag();
369 :
370 :
371 :
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 : return x;
383 :
384 : }
385 :
386 : void CalAntennaSolutionsRow::toIDL(asdmIDL::CalAntennaSolutionsRowIDL& x) const {
387 : // Set the x's fields.
388 :
389 :
390 :
391 :
392 :
393 :
394 :
395 :
396 : x.antennaName = CORBA::string_dup(antennaName.c_str());
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 :
408 : x.atmPhaseCorrection = atmPhaseCorrection;
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 :
420 : x.basebandName = basebandName;
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 : x.receiverBand = receiverBand;
433 :
434 :
435 :
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 : x.startValidTime = startValidTime.toIDLArrayTime();
444 :
445 :
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 : x.endValidTime = endValidTime.toIDLArrayTime();
454 :
455 :
456 :
457 :
458 :
459 :
460 :
461 :
462 :
463 :
464 : x.numReceptor = numReceptor;
465 :
466 :
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 : x.refAntennaName = CORBA::string_dup(refAntennaName.c_str());
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 :
487 : x.direction.length(direction.size());
488 : for (unsigned int i = 0; i < direction.size(); ++i) {
489 :
490 : x.direction[i] = direction.at(i).toIDLAngle();
491 :
492 : }
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 : x.frequencyRange.length(frequencyRange.size());
503 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
504 :
505 : x.frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
506 :
507 : }
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 :
516 :
517 : x.integrationTime = integrationTime.toIDLInterval();
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 :
526 :
527 : x.polarizationTypes.length(polarizationTypes.size());
528 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
529 :
530 :
531 : x.polarizationTypes[i] = polarizationTypes.at(i);
532 :
533 :
534 : }
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 : x.correctionValidity = correctionValidity;
546 :
547 :
548 :
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 : x.phaseAnt.length(phaseAnt.size());
557 : for (unsigned int i = 0; i < phaseAnt.size(); ++i) {
558 :
559 :
560 : x.phaseAnt[i] = phaseAnt.at(i);
561 :
562 :
563 : }
564 :
565 :
566 :
567 :
568 :
569 :
570 :
571 :
572 :
573 : x.phaseAntRMS.length(phaseAntRMS.size());
574 : for (unsigned int i = 0; i < phaseAntRMS.size(); ++i) {
575 :
576 :
577 : x.phaseAntRMS[i] = phaseAntRMS.at(i);
578 :
579 :
580 : }
581 :
582 :
583 :
584 :
585 :
586 :
587 :
588 :
589 :
590 : x.amplitudeAnt.length(amplitudeAnt.size());
591 : for (unsigned int i = 0; i < amplitudeAnt.size(); ++i) {
592 :
593 :
594 : x.amplitudeAnt[i] = amplitudeAnt.at(i);
595 :
596 :
597 : }
598 :
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 : x.amplitudeAntRMS.length(amplitudeAntRMS.size());
608 : for (unsigned int i = 0; i < amplitudeAntRMS.size(); ++i) {
609 :
610 :
611 : x.amplitudeAntRMS[i] = amplitudeAntRMS.at(i);
612 :
613 :
614 : }
615 :
616 :
617 :
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 :
628 : x.calDataId = calDataId.toIDLTag();
629 :
630 :
631 :
632 :
633 :
634 :
635 :
636 :
637 :
638 :
639 : x.calReductionId = calReductionId.toIDLTag();
640 :
641 :
642 :
643 :
644 :
645 :
646 :
647 :
648 :
649 :
650 : x.spectralWindowId = spectralWindowId.toIDLTag();
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 : }
665 : #endif
666 :
667 :
668 : #ifndef WITHOUT_ACS
669 : /**
670 : * Fill the values of this row from the IDL struct CalAntennaSolutionsRowIDL.
671 : * @param x The IDL struct containing the values used to fill this row.
672 : */
673 : void CalAntennaSolutionsRow::setFromIDL (CalAntennaSolutionsRowIDL x){
674 : try {
675 : // Fill the values from x.
676 :
677 :
678 :
679 :
680 :
681 :
682 : setAntennaName(string (x.antennaName));
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 :
691 :
692 : setAtmPhaseCorrection(x.atmPhaseCorrection);
693 :
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 : setBasebandName(x.basebandName);
703 :
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 : setReceiverBand(x.receiverBand);
713 :
714 :
715 :
716 :
717 :
718 :
719 :
720 :
721 :
722 : setStartValidTime(ArrayTime (x.startValidTime));
723 :
724 :
725 :
726 :
727 :
728 :
729 :
730 :
731 :
732 : setEndValidTime(ArrayTime (x.endValidTime));
733 :
734 :
735 :
736 :
737 :
738 :
739 :
740 :
741 :
742 : setNumReceptor(x.numReceptor);
743 :
744 :
745 :
746 :
747 :
748 :
749 :
750 :
751 :
752 : setRefAntennaName(string (x.refAntennaName));
753 :
754 :
755 :
756 :
757 :
758 :
759 :
760 :
761 :
762 : direction .clear();
763 : for (unsigned int i = 0; i <x.direction.length(); ++i) {
764 :
765 : direction.push_back(Angle (x.direction[i]));
766 :
767 : }
768 :
769 :
770 :
771 :
772 :
773 :
774 :
775 :
776 :
777 : frequencyRange .clear();
778 : for (unsigned int i = 0; i <x.frequencyRange.length(); ++i) {
779 :
780 : frequencyRange.push_back(Frequency (x.frequencyRange[i]));
781 :
782 : }
783 :
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 : setIntegrationTime(Interval (x.integrationTime));
793 :
794 :
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 : polarizationTypes .clear();
803 : for (unsigned int i = 0; i <x.polarizationTypes.length(); ++i) {
804 :
805 : polarizationTypes.push_back(x.polarizationTypes[i]);
806 :
807 : }
808 :
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 :
817 : setCorrectionValidity(x.correctionValidity);
818 :
819 :
820 :
821 :
822 :
823 :
824 :
825 :
826 :
827 : phaseAnt .clear();
828 : for (unsigned int i = 0; i <x.phaseAnt.length(); ++i) {
829 :
830 : phaseAnt.push_back(x.phaseAnt[i]);
831 :
832 : }
833 :
834 :
835 :
836 :
837 :
838 :
839 :
840 :
841 :
842 : phaseAntRMS .clear();
843 : for (unsigned int i = 0; i <x.phaseAntRMS.length(); ++i) {
844 :
845 : phaseAntRMS.push_back(x.phaseAntRMS[i]);
846 :
847 : }
848 :
849 :
850 :
851 :
852 :
853 :
854 :
855 :
856 :
857 : amplitudeAnt .clear();
858 : for (unsigned int i = 0; i <x.amplitudeAnt.length(); ++i) {
859 :
860 : amplitudeAnt.push_back(x.amplitudeAnt[i]);
861 :
862 : }
863 :
864 :
865 :
866 :
867 :
868 :
869 :
870 :
871 :
872 : amplitudeAntRMS .clear();
873 : for (unsigned int i = 0; i <x.amplitudeAntRMS.length(); ++i) {
874 :
875 : amplitudeAntRMS.push_back(x.amplitudeAntRMS[i]);
876 :
877 : }
878 :
879 :
880 :
881 :
882 :
883 :
884 :
885 :
886 :
887 :
888 :
889 :
890 : setCalDataId(Tag (x.calDataId));
891 :
892 :
893 :
894 :
895 :
896 :
897 :
898 :
899 :
900 : setCalReductionId(Tag (x.calReductionId));
901 :
902 :
903 :
904 :
905 :
906 :
907 :
908 :
909 :
910 : setSpectralWindowId(Tag (x.spectralWindowId));
911 :
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 : } catch (const IllegalAccessException &err) {
925 : throw ConversionException (err.getMessage(),"CalAntennaSolutions");
926 : }
927 : }
928 : #endif
929 :
930 : /**
931 : * Return this row in the form of an XML string.
932 : * @return The values of this row as an XML string.
933 : */
934 0 : string CalAntennaSolutionsRow::toXML() const {
935 0 : string buf;
936 0 : buf.append("<row> \n");
937 :
938 :
939 :
940 :
941 :
942 :
943 0 : Parser::toXML(antennaName, "antennaName", buf);
944 :
945 :
946 :
947 :
948 :
949 :
950 :
951 0 : buf.append(EnumerationParser::toXML("atmPhaseCorrection", atmPhaseCorrection));
952 :
953 :
954 :
955 :
956 :
957 :
958 :
959 0 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
960 :
961 :
962 :
963 :
964 :
965 :
966 :
967 0 : buf.append(EnumerationParser::toXML("receiverBand", receiverBand));
968 :
969 :
970 :
971 :
972 :
973 :
974 :
975 0 : Parser::toXML(startValidTime, "startValidTime", buf);
976 :
977 :
978 :
979 :
980 :
981 :
982 :
983 0 : Parser::toXML(endValidTime, "endValidTime", buf);
984 :
985 :
986 :
987 :
988 :
989 :
990 :
991 0 : Parser::toXML(numReceptor, "numReceptor", buf);
992 :
993 :
994 :
995 :
996 :
997 :
998 :
999 0 : Parser::toXML(refAntennaName, "refAntennaName", buf);
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 0 : Parser::toXML(direction, "direction", buf);
1008 :
1009 :
1010 :
1011 :
1012 :
1013 :
1014 :
1015 0 : Parser::toXML(frequencyRange, "frequencyRange", buf);
1016 :
1017 :
1018 :
1019 :
1020 :
1021 :
1022 :
1023 0 : Parser::toXML(integrationTime, "integrationTime", buf);
1024 :
1025 :
1026 :
1027 :
1028 :
1029 :
1030 :
1031 0 : buf.append(EnumerationParser::toXML("polarizationTypes", polarizationTypes));
1032 :
1033 :
1034 :
1035 :
1036 :
1037 :
1038 :
1039 0 : Parser::toXML(correctionValidity, "correctionValidity", buf);
1040 :
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 0 : Parser::toXML(phaseAnt, "phaseAnt", buf);
1048 :
1049 :
1050 :
1051 :
1052 :
1053 :
1054 :
1055 0 : Parser::toXML(phaseAntRMS, "phaseAntRMS", buf);
1056 :
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 0 : Parser::toXML(amplitudeAnt, "amplitudeAnt", buf);
1064 :
1065 :
1066 :
1067 :
1068 :
1069 :
1070 :
1071 0 : Parser::toXML(amplitudeAntRMS, "amplitudeAntRMS", buf);
1072 :
1073 :
1074 :
1075 :
1076 :
1077 :
1078 :
1079 :
1080 :
1081 :
1082 0 : Parser::toXML(calDataId, "calDataId", buf);
1083 :
1084 :
1085 :
1086 :
1087 :
1088 :
1089 :
1090 0 : Parser::toXML(calReductionId, "calReductionId", buf);
1091 :
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 0 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
1099 :
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 :
1108 :
1109 :
1110 :
1111 :
1112 0 : buf.append("</row>\n");
1113 0 : return buf;
1114 0 : }
1115 :
1116 : /**
1117 : * Fill the values of this row from an XML string
1118 : * that was produced by the toXML() method.
1119 : * @param x The XML string being used to set the values of this row.
1120 : */
1121 0 : void CalAntennaSolutionsRow::setFromXML (string rowDoc) {
1122 0 : Parser row(rowDoc);
1123 0 : string s = "";
1124 : try {
1125 :
1126 :
1127 :
1128 :
1129 :
1130 0 : setAntennaName(Parser::getString("antennaName","CalAntennaSolutions",rowDoc));
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 0 : atmPhaseCorrection = EnumerationParser::getAtmPhaseCorrection("atmPhaseCorrection","CalAntennaSolutions",rowDoc);
1140 :
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 :
1148 :
1149 0 : basebandName = EnumerationParser::getBasebandName("basebandName","CalAntennaSolutions",rowDoc);
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 :
1157 :
1158 :
1159 0 : receiverBand = EnumerationParser::getReceiverBand("receiverBand","CalAntennaSolutions",rowDoc);
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 :
1167 :
1168 0 : setStartValidTime(Parser::getArrayTime("startValidTime","CalAntennaSolutions",rowDoc));
1169 :
1170 :
1171 :
1172 :
1173 :
1174 :
1175 :
1176 0 : setEndValidTime(Parser::getArrayTime("endValidTime","CalAntennaSolutions",rowDoc));
1177 :
1178 :
1179 :
1180 :
1181 :
1182 :
1183 :
1184 0 : setNumReceptor(Parser::getInteger("numReceptor","CalAntennaSolutions",rowDoc));
1185 :
1186 :
1187 :
1188 :
1189 :
1190 :
1191 :
1192 0 : setRefAntennaName(Parser::getString("refAntennaName","CalAntennaSolutions",rowDoc));
1193 :
1194 :
1195 :
1196 :
1197 :
1198 :
1199 :
1200 :
1201 0 : setDirection(Parser::get1DAngle("direction","CalAntennaSolutions",rowDoc));
1202 :
1203 :
1204 :
1205 :
1206 :
1207 :
1208 :
1209 :
1210 :
1211 0 : setFrequencyRange(Parser::get1DFrequency("frequencyRange","CalAntennaSolutions",rowDoc));
1212 :
1213 :
1214 :
1215 :
1216 :
1217 :
1218 :
1219 :
1220 0 : setIntegrationTime(Parser::getInterval("integrationTime","CalAntennaSolutions",rowDoc));
1221 :
1222 :
1223 :
1224 :
1225 :
1226 :
1227 :
1228 :
1229 0 : polarizationTypes = EnumerationParser::getPolarizationType1D("polarizationTypes","CalAntennaSolutions",rowDoc);
1230 :
1231 :
1232 :
1233 :
1234 :
1235 :
1236 :
1237 :
1238 0 : setCorrectionValidity(Parser::getBoolean("correctionValidity","CalAntennaSolutions",rowDoc));
1239 :
1240 :
1241 :
1242 :
1243 :
1244 :
1245 :
1246 :
1247 0 : setPhaseAnt(Parser::get1DFloat("phaseAnt","CalAntennaSolutions",rowDoc));
1248 :
1249 :
1250 :
1251 :
1252 :
1253 :
1254 :
1255 :
1256 :
1257 0 : setPhaseAntRMS(Parser::get1DFloat("phaseAntRMS","CalAntennaSolutions",rowDoc));
1258 :
1259 :
1260 :
1261 :
1262 :
1263 :
1264 :
1265 :
1266 :
1267 0 : setAmplitudeAnt(Parser::get1DFloat("amplitudeAnt","CalAntennaSolutions",rowDoc));
1268 :
1269 :
1270 :
1271 :
1272 :
1273 :
1274 :
1275 :
1276 :
1277 0 : setAmplitudeAntRMS(Parser::get1DFloat("amplitudeAntRMS","CalAntennaSolutions",rowDoc));
1278 :
1279 :
1280 :
1281 :
1282 :
1283 :
1284 :
1285 :
1286 :
1287 :
1288 :
1289 0 : setCalDataId(Parser::getTag("calDataId","CalData",rowDoc));
1290 :
1291 :
1292 :
1293 :
1294 :
1295 :
1296 :
1297 0 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
1298 :
1299 :
1300 :
1301 :
1302 :
1303 :
1304 :
1305 0 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
1306 :
1307 :
1308 :
1309 :
1310 :
1311 :
1312 :
1313 :
1314 :
1315 :
1316 :
1317 :
1318 0 : } catch (const IllegalAccessException &err) {
1319 0 : throw ConversionException (err.getMessage(),"CalAntennaSolutions");
1320 0 : }
1321 0 : }
1322 :
1323 0 : void CalAntennaSolutionsRow::toBin(EndianOSStream& eoss) {
1324 :
1325 :
1326 :
1327 :
1328 :
1329 :
1330 0 : eoss.writeString(antennaName);
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 :
1338 :
1339 0 : eoss.writeString(CAtmPhaseCorrection::name(atmPhaseCorrection));
1340 : /* eoss.writeInt(atmPhaseCorrection); */
1341 :
1342 :
1343 :
1344 :
1345 :
1346 :
1347 :
1348 :
1349 0 : eoss.writeString(CReceiverBand::name(receiverBand));
1350 : /* eoss.writeInt(receiverBand); */
1351 :
1352 :
1353 :
1354 :
1355 :
1356 :
1357 :
1358 :
1359 0 : eoss.writeString(CBasebandName::name(basebandName));
1360 : /* eoss.writeInt(basebandName); */
1361 :
1362 :
1363 :
1364 :
1365 :
1366 :
1367 :
1368 0 : calDataId.toBin(eoss);
1369 :
1370 :
1371 :
1372 :
1373 :
1374 :
1375 0 : calReductionId.toBin(eoss);
1376 :
1377 :
1378 :
1379 :
1380 :
1381 :
1382 0 : spectralWindowId.toBin(eoss);
1383 :
1384 :
1385 :
1386 :
1387 :
1388 :
1389 0 : startValidTime.toBin(eoss);
1390 :
1391 :
1392 :
1393 :
1394 :
1395 :
1396 0 : endValidTime.toBin(eoss);
1397 :
1398 :
1399 :
1400 :
1401 :
1402 :
1403 :
1404 0 : eoss.writeInt(numReceptor);
1405 :
1406 :
1407 :
1408 :
1409 :
1410 :
1411 :
1412 :
1413 0 : eoss.writeString(refAntennaName);
1414 :
1415 :
1416 :
1417 :
1418 :
1419 :
1420 :
1421 0 : Angle::toBin(direction, eoss);
1422 :
1423 :
1424 :
1425 :
1426 :
1427 :
1428 0 : Frequency::toBin(frequencyRange, eoss);
1429 :
1430 :
1431 :
1432 :
1433 :
1434 :
1435 0 : integrationTime.toBin(eoss);
1436 :
1437 :
1438 :
1439 :
1440 :
1441 :
1442 :
1443 :
1444 0 : eoss.writeInt((int) polarizationTypes.size());
1445 0 : for (unsigned int i = 0; i < polarizationTypes.size(); i++)
1446 :
1447 0 : eoss.writeString(CPolarizationType::name(polarizationTypes.at(i)));
1448 : /* eoss.writeInt(polarizationTypes.at(i)); */
1449 :
1450 :
1451 :
1452 :
1453 :
1454 :
1455 :
1456 :
1457 :
1458 :
1459 0 : eoss.writeBoolean(correctionValidity);
1460 :
1461 :
1462 :
1463 :
1464 :
1465 :
1466 :
1467 :
1468 :
1469 0 : eoss.writeInt((int) phaseAnt.size());
1470 0 : for (unsigned int i = 0; i < phaseAnt.size(); i++)
1471 :
1472 0 : eoss.writeFloat(phaseAnt.at(i));
1473 :
1474 :
1475 :
1476 :
1477 :
1478 :
1479 :
1480 :
1481 :
1482 :
1483 :
1484 0 : eoss.writeInt((int) phaseAntRMS.size());
1485 0 : for (unsigned int i = 0; i < phaseAntRMS.size(); i++)
1486 :
1487 0 : eoss.writeFloat(phaseAntRMS.at(i));
1488 :
1489 :
1490 :
1491 :
1492 :
1493 :
1494 :
1495 :
1496 :
1497 :
1498 :
1499 0 : eoss.writeInt((int) amplitudeAnt.size());
1500 0 : for (unsigned int i = 0; i < amplitudeAnt.size(); i++)
1501 :
1502 0 : eoss.writeFloat(amplitudeAnt.at(i));
1503 :
1504 :
1505 :
1506 :
1507 :
1508 :
1509 :
1510 :
1511 :
1512 :
1513 :
1514 0 : eoss.writeInt((int) amplitudeAntRMS.size());
1515 0 : for (unsigned int i = 0; i < amplitudeAntRMS.size(); i++)
1516 :
1517 0 : eoss.writeFloat(amplitudeAntRMS.at(i));
1518 :
1519 :
1520 :
1521 :
1522 :
1523 :
1524 :
1525 :
1526 :
1527 0 : }
1528 :
1529 0 : void CalAntennaSolutionsRow::antennaNameFromBin(EndianIStream& eis) {
1530 :
1531 :
1532 :
1533 :
1534 :
1535 0 : antennaName = eis.readString();
1536 :
1537 :
1538 :
1539 :
1540 0 : }
1541 0 : void CalAntennaSolutionsRow::atmPhaseCorrectionFromBin(EndianIStream& eis) {
1542 :
1543 :
1544 :
1545 :
1546 :
1547 0 : atmPhaseCorrection = CAtmPhaseCorrection::literal(eis.readString());
1548 :
1549 :
1550 :
1551 :
1552 0 : }
1553 0 : void CalAntennaSolutionsRow::receiverBandFromBin(EndianIStream& eis) {
1554 :
1555 :
1556 :
1557 :
1558 :
1559 0 : receiverBand = CReceiverBand::literal(eis.readString());
1560 :
1561 :
1562 :
1563 :
1564 0 : }
1565 0 : void CalAntennaSolutionsRow::basebandNameFromBin(EndianIStream& eis) {
1566 :
1567 :
1568 :
1569 :
1570 :
1571 0 : basebandName = CBasebandName::literal(eis.readString());
1572 :
1573 :
1574 :
1575 :
1576 0 : }
1577 0 : void CalAntennaSolutionsRow::calDataIdFromBin(EndianIStream& eis) {
1578 :
1579 :
1580 :
1581 :
1582 0 : calDataId = Tag::fromBin(eis);
1583 :
1584 :
1585 :
1586 0 : }
1587 0 : void CalAntennaSolutionsRow::calReductionIdFromBin(EndianIStream& eis) {
1588 :
1589 :
1590 :
1591 :
1592 0 : calReductionId = Tag::fromBin(eis);
1593 :
1594 :
1595 :
1596 0 : }
1597 0 : void CalAntennaSolutionsRow::spectralWindowIdFromBin(EndianIStream& eis) {
1598 :
1599 :
1600 :
1601 :
1602 0 : spectralWindowId = Tag::fromBin(eis);
1603 :
1604 :
1605 :
1606 0 : }
1607 0 : void CalAntennaSolutionsRow::startValidTimeFromBin(EndianIStream& eis) {
1608 :
1609 :
1610 :
1611 :
1612 0 : startValidTime = ArrayTime::fromBin(eis);
1613 :
1614 :
1615 :
1616 0 : }
1617 0 : void CalAntennaSolutionsRow::endValidTimeFromBin(EndianIStream& eis) {
1618 :
1619 :
1620 :
1621 :
1622 0 : endValidTime = ArrayTime::fromBin(eis);
1623 :
1624 :
1625 :
1626 0 : }
1627 0 : void CalAntennaSolutionsRow::numReceptorFromBin(EndianIStream& eis) {
1628 :
1629 :
1630 :
1631 :
1632 :
1633 0 : numReceptor = eis.readInt();
1634 :
1635 :
1636 :
1637 :
1638 0 : }
1639 0 : void CalAntennaSolutionsRow::refAntennaNameFromBin(EndianIStream& eis) {
1640 :
1641 :
1642 :
1643 :
1644 :
1645 0 : refAntennaName = eis.readString();
1646 :
1647 :
1648 :
1649 :
1650 0 : }
1651 0 : void CalAntennaSolutionsRow::directionFromBin(EndianIStream& eis) {
1652 :
1653 :
1654 :
1655 :
1656 :
1657 :
1658 0 : direction = Angle::from1DBin(eis);
1659 :
1660 :
1661 :
1662 :
1663 :
1664 0 : }
1665 0 : void CalAntennaSolutionsRow::frequencyRangeFromBin(EndianIStream& eis) {
1666 :
1667 :
1668 :
1669 :
1670 :
1671 :
1672 0 : frequencyRange = Frequency::from1DBin(eis);
1673 :
1674 :
1675 :
1676 :
1677 :
1678 0 : }
1679 0 : void CalAntennaSolutionsRow::integrationTimeFromBin(EndianIStream& eis) {
1680 :
1681 :
1682 :
1683 :
1684 0 : integrationTime = Interval::fromBin(eis);
1685 :
1686 :
1687 :
1688 0 : }
1689 0 : void CalAntennaSolutionsRow::polarizationTypesFromBin(EndianIStream& eis) {
1690 :
1691 :
1692 :
1693 :
1694 :
1695 :
1696 0 : polarizationTypes.clear();
1697 :
1698 0 : unsigned int polarizationTypesDim1 = eis.readInt();
1699 0 : for (unsigned int i = 0 ; i < polarizationTypesDim1; i++)
1700 :
1701 0 : polarizationTypes.push_back(CPolarizationType::literal(eis.readString()));
1702 :
1703 :
1704 :
1705 :
1706 :
1707 :
1708 0 : }
1709 0 : void CalAntennaSolutionsRow::correctionValidityFromBin(EndianIStream& eis) {
1710 :
1711 :
1712 :
1713 :
1714 :
1715 0 : correctionValidity = eis.readBoolean();
1716 :
1717 :
1718 :
1719 :
1720 0 : }
1721 0 : void CalAntennaSolutionsRow::phaseAntFromBin(EndianIStream& eis) {
1722 :
1723 :
1724 :
1725 :
1726 :
1727 :
1728 0 : phaseAnt.clear();
1729 :
1730 0 : unsigned int phaseAntDim1 = eis.readInt();
1731 0 : for (unsigned int i = 0 ; i < phaseAntDim1; i++)
1732 :
1733 0 : phaseAnt.push_back(eis.readFloat());
1734 :
1735 :
1736 :
1737 :
1738 :
1739 :
1740 0 : }
1741 0 : void CalAntennaSolutionsRow::phaseAntRMSFromBin(EndianIStream& eis) {
1742 :
1743 :
1744 :
1745 :
1746 :
1747 :
1748 0 : phaseAntRMS.clear();
1749 :
1750 0 : unsigned int phaseAntRMSDim1 = eis.readInt();
1751 0 : for (unsigned int i = 0 ; i < phaseAntRMSDim1; i++)
1752 :
1753 0 : phaseAntRMS.push_back(eis.readFloat());
1754 :
1755 :
1756 :
1757 :
1758 :
1759 :
1760 0 : }
1761 0 : void CalAntennaSolutionsRow::amplitudeAntFromBin(EndianIStream& eis) {
1762 :
1763 :
1764 :
1765 :
1766 :
1767 :
1768 0 : amplitudeAnt.clear();
1769 :
1770 0 : unsigned int amplitudeAntDim1 = eis.readInt();
1771 0 : for (unsigned int i = 0 ; i < amplitudeAntDim1; i++)
1772 :
1773 0 : amplitudeAnt.push_back(eis.readFloat());
1774 :
1775 :
1776 :
1777 :
1778 :
1779 :
1780 0 : }
1781 0 : void CalAntennaSolutionsRow::amplitudeAntRMSFromBin(EndianIStream& eis) {
1782 :
1783 :
1784 :
1785 :
1786 :
1787 :
1788 0 : amplitudeAntRMS.clear();
1789 :
1790 0 : unsigned int amplitudeAntRMSDim1 = eis.readInt();
1791 0 : for (unsigned int i = 0 ; i < amplitudeAntRMSDim1; i++)
1792 :
1793 0 : amplitudeAntRMS.push_back(eis.readFloat());
1794 :
1795 :
1796 :
1797 :
1798 :
1799 :
1800 0 : }
1801 :
1802 :
1803 :
1804 0 : CalAntennaSolutionsRow* CalAntennaSolutionsRow::fromBin(EndianIStream& eis, CalAntennaSolutionsTable& table, const vector<string>& attributesSeq) {
1805 0 : CalAntennaSolutionsRow* row = new CalAntennaSolutionsRow(table);
1806 :
1807 0 : map<string, CalAntennaSolutionsAttributeFromBin>::iterator iter ;
1808 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1809 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1810 0 : if (iter != row->fromBinMethods.end()) {
1811 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1812 : }
1813 : else {
1814 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1815 0 : if (functorP)
1816 0 : (*functorP)(eis);
1817 : else
1818 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalAntennaSolutionsTable");
1819 : }
1820 :
1821 : }
1822 0 : return row;
1823 : }
1824 :
1825 : //
1826 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1827 : // of one row.
1828 : //
1829 :
1830 : // Convert a string into an String
1831 0 : void CalAntennaSolutionsRow::antennaNameFromText(const string & s) {
1832 :
1833 :
1834 0 : antennaName = ASDMValuesParser::parse<string>(s);
1835 :
1836 :
1837 0 : }
1838 :
1839 :
1840 : // Convert a string into an AtmPhaseCorrection
1841 0 : void CalAntennaSolutionsRow::atmPhaseCorrectionFromText(const string & s) {
1842 :
1843 :
1844 0 : atmPhaseCorrection = ASDMValuesParser::parse<AtmPhaseCorrectionMod::AtmPhaseCorrection>(s);
1845 :
1846 :
1847 0 : }
1848 :
1849 :
1850 : // Convert a string into an ReceiverBand
1851 0 : void CalAntennaSolutionsRow::receiverBandFromText(const string & s) {
1852 :
1853 :
1854 0 : receiverBand = ASDMValuesParser::parse<ReceiverBandMod::ReceiverBand>(s);
1855 :
1856 :
1857 0 : }
1858 :
1859 :
1860 : // Convert a string into an BasebandName
1861 0 : void CalAntennaSolutionsRow::basebandNameFromText(const string & s) {
1862 :
1863 :
1864 0 : basebandName = ASDMValuesParser::parse<BasebandNameMod::BasebandName>(s);
1865 :
1866 :
1867 0 : }
1868 :
1869 :
1870 : // Convert a string into an Tag
1871 0 : void CalAntennaSolutionsRow::calDataIdFromText(const string & s) {
1872 :
1873 :
1874 0 : calDataId = ASDMValuesParser::parse<Tag>(s);
1875 :
1876 :
1877 0 : }
1878 :
1879 :
1880 : // Convert a string into an Tag
1881 0 : void CalAntennaSolutionsRow::calReductionIdFromText(const string & s) {
1882 :
1883 :
1884 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
1885 :
1886 :
1887 0 : }
1888 :
1889 :
1890 : // Convert a string into an Tag
1891 0 : void CalAntennaSolutionsRow::spectralWindowIdFromText(const string & s) {
1892 :
1893 :
1894 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
1895 :
1896 :
1897 0 : }
1898 :
1899 :
1900 : // Convert a string into an ArrayTime
1901 0 : void CalAntennaSolutionsRow::startValidTimeFromText(const string & s) {
1902 :
1903 :
1904 0 : startValidTime = ASDMValuesParser::parse<ArrayTime>(s);
1905 :
1906 :
1907 0 : }
1908 :
1909 :
1910 : // Convert a string into an ArrayTime
1911 0 : void CalAntennaSolutionsRow::endValidTimeFromText(const string & s) {
1912 :
1913 :
1914 0 : endValidTime = ASDMValuesParser::parse<ArrayTime>(s);
1915 :
1916 :
1917 0 : }
1918 :
1919 :
1920 : // Convert a string into an int
1921 0 : void CalAntennaSolutionsRow::numReceptorFromText(const string & s) {
1922 :
1923 :
1924 0 : numReceptor = ASDMValuesParser::parse<int>(s);
1925 :
1926 :
1927 0 : }
1928 :
1929 :
1930 : // Convert a string into an String
1931 0 : void CalAntennaSolutionsRow::refAntennaNameFromText(const string & s) {
1932 :
1933 :
1934 0 : refAntennaName = ASDMValuesParser::parse<string>(s);
1935 :
1936 :
1937 0 : }
1938 :
1939 :
1940 : // Convert a string into an Angle
1941 0 : void CalAntennaSolutionsRow::directionFromText(const string & s) {
1942 :
1943 :
1944 0 : direction = ASDMValuesParser::parse1D<Angle>(s);
1945 :
1946 :
1947 0 : }
1948 :
1949 :
1950 : // Convert a string into an Frequency
1951 0 : void CalAntennaSolutionsRow::frequencyRangeFromText(const string & s) {
1952 :
1953 :
1954 0 : frequencyRange = ASDMValuesParser::parse1D<Frequency>(s);
1955 :
1956 :
1957 0 : }
1958 :
1959 :
1960 : // Convert a string into an Interval
1961 0 : void CalAntennaSolutionsRow::integrationTimeFromText(const string & s) {
1962 :
1963 :
1964 0 : integrationTime = ASDMValuesParser::parse<Interval>(s);
1965 :
1966 :
1967 0 : }
1968 :
1969 :
1970 : // Convert a string into an PolarizationType
1971 0 : void CalAntennaSolutionsRow::polarizationTypesFromText(const string & s) {
1972 :
1973 :
1974 0 : polarizationTypes = ASDMValuesParser::parse1D<PolarizationTypeMod::PolarizationType>(s);
1975 :
1976 :
1977 0 : }
1978 :
1979 :
1980 : // Convert a string into an boolean
1981 0 : void CalAntennaSolutionsRow::correctionValidityFromText(const string & s) {
1982 :
1983 :
1984 0 : correctionValidity = ASDMValuesParser::parse<bool>(s);
1985 :
1986 :
1987 0 : }
1988 :
1989 :
1990 : // Convert a string into an float
1991 0 : void CalAntennaSolutionsRow::phaseAntFromText(const string & s) {
1992 :
1993 :
1994 0 : phaseAnt = ASDMValuesParser::parse1D<float>(s);
1995 :
1996 :
1997 0 : }
1998 :
1999 :
2000 : // Convert a string into an float
2001 0 : void CalAntennaSolutionsRow::phaseAntRMSFromText(const string & s) {
2002 :
2003 :
2004 0 : phaseAntRMS = ASDMValuesParser::parse1D<float>(s);
2005 :
2006 :
2007 0 : }
2008 :
2009 :
2010 : // Convert a string into an float
2011 0 : void CalAntennaSolutionsRow::amplitudeAntFromText(const string & s) {
2012 :
2013 :
2014 0 : amplitudeAnt = ASDMValuesParser::parse1D<float>(s);
2015 :
2016 :
2017 0 : }
2018 :
2019 :
2020 : // Convert a string into an float
2021 0 : void CalAntennaSolutionsRow::amplitudeAntRMSFromText(const string & s) {
2022 :
2023 :
2024 0 : amplitudeAntRMS = ASDMValuesParser::parse1D<float>(s);
2025 :
2026 :
2027 0 : }
2028 :
2029 :
2030 :
2031 :
2032 0 : void CalAntennaSolutionsRow::fromText(const std::string& attributeName, const std::string& t) {
2033 0 : map<string, CalAntennaSolutionsAttributeFromText>::iterator iter;
2034 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
2035 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalAntennaSolutionsTable");
2036 0 : (this->*(iter->second))(t);
2037 0 : }
2038 :
2039 : ////////////////////////////////////////////////
2040 : // Intrinsic Table Attributes getters/setters //
2041 : ////////////////////////////////////////////////
2042 :
2043 :
2044 :
2045 :
2046 : /**
2047 : * Get antennaName.
2048 : * @return antennaName as std::string
2049 : */
2050 0 : std::string CalAntennaSolutionsRow::getAntennaName() const {
2051 :
2052 0 : return antennaName;
2053 : }
2054 :
2055 : /**
2056 : * Set antennaName with the specified std::string.
2057 : * @param antennaName The std::string value to which antennaName is to be set.
2058 :
2059 :
2060 :
2061 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2062 :
2063 : */
2064 0 : void CalAntennaSolutionsRow::setAntennaName (std::string antennaName) {
2065 :
2066 :
2067 0 : if (hasBeenAdded) {
2068 :
2069 0 : throw IllegalAccessException("antennaName", "CalAntennaSolutions");
2070 :
2071 : }
2072 :
2073 0 : this->antennaName = antennaName;
2074 :
2075 0 : }
2076 :
2077 :
2078 :
2079 :
2080 :
2081 :
2082 : /**
2083 : * Get atmPhaseCorrection.
2084 : * @return atmPhaseCorrection as AtmPhaseCorrectionMod::AtmPhaseCorrection
2085 : */
2086 0 : AtmPhaseCorrectionMod::AtmPhaseCorrection CalAntennaSolutionsRow::getAtmPhaseCorrection() const {
2087 :
2088 0 : return atmPhaseCorrection;
2089 : }
2090 :
2091 : /**
2092 : * Set atmPhaseCorrection with the specified AtmPhaseCorrectionMod::AtmPhaseCorrection.
2093 : * @param atmPhaseCorrection The AtmPhaseCorrectionMod::AtmPhaseCorrection value to which atmPhaseCorrection is to be set.
2094 :
2095 :
2096 :
2097 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2098 :
2099 : */
2100 0 : void CalAntennaSolutionsRow::setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection) {
2101 :
2102 :
2103 0 : if (hasBeenAdded) {
2104 :
2105 0 : throw IllegalAccessException("atmPhaseCorrection", "CalAntennaSolutions");
2106 :
2107 : }
2108 :
2109 0 : this->atmPhaseCorrection = atmPhaseCorrection;
2110 :
2111 0 : }
2112 :
2113 :
2114 :
2115 :
2116 :
2117 :
2118 : /**
2119 : * Get basebandName.
2120 : * @return basebandName as BasebandNameMod::BasebandName
2121 : */
2122 0 : BasebandNameMod::BasebandName CalAntennaSolutionsRow::getBasebandName() const {
2123 :
2124 0 : return basebandName;
2125 : }
2126 :
2127 : /**
2128 : * Set basebandName with the specified BasebandNameMod::BasebandName.
2129 : * @param basebandName The BasebandNameMod::BasebandName value to which basebandName is to be set.
2130 :
2131 :
2132 :
2133 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2134 :
2135 : */
2136 0 : void CalAntennaSolutionsRow::setBasebandName (BasebandNameMod::BasebandName basebandName) {
2137 :
2138 :
2139 0 : if (hasBeenAdded) {
2140 :
2141 0 : throw IllegalAccessException("basebandName", "CalAntennaSolutions");
2142 :
2143 : }
2144 :
2145 0 : this->basebandName = basebandName;
2146 :
2147 0 : }
2148 :
2149 :
2150 :
2151 :
2152 :
2153 :
2154 : /**
2155 : * Get receiverBand.
2156 : * @return receiverBand as ReceiverBandMod::ReceiverBand
2157 : */
2158 0 : ReceiverBandMod::ReceiverBand CalAntennaSolutionsRow::getReceiverBand() const {
2159 :
2160 0 : return receiverBand;
2161 : }
2162 :
2163 : /**
2164 : * Set receiverBand with the specified ReceiverBandMod::ReceiverBand.
2165 : * @param receiverBand The ReceiverBandMod::ReceiverBand value to which receiverBand is to be set.
2166 :
2167 :
2168 :
2169 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2170 :
2171 : */
2172 0 : void CalAntennaSolutionsRow::setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand) {
2173 :
2174 :
2175 0 : if (hasBeenAdded) {
2176 :
2177 0 : throw IllegalAccessException("receiverBand", "CalAntennaSolutions");
2178 :
2179 : }
2180 :
2181 0 : this->receiverBand = receiverBand;
2182 :
2183 0 : }
2184 :
2185 :
2186 :
2187 :
2188 :
2189 :
2190 : /**
2191 : * Get startValidTime.
2192 : * @return startValidTime as ArrayTime
2193 : */
2194 0 : ArrayTime CalAntennaSolutionsRow::getStartValidTime() const {
2195 :
2196 0 : return startValidTime;
2197 : }
2198 :
2199 : /**
2200 : * Set startValidTime with the specified ArrayTime.
2201 : * @param startValidTime The ArrayTime value to which startValidTime is to be set.
2202 :
2203 :
2204 :
2205 : */
2206 0 : void CalAntennaSolutionsRow::setStartValidTime (ArrayTime startValidTime) {
2207 :
2208 :
2209 0 : if (hasBeenAdded) {
2210 :
2211 : }
2212 :
2213 0 : this->startValidTime = startValidTime;
2214 :
2215 0 : }
2216 :
2217 :
2218 :
2219 :
2220 :
2221 :
2222 : /**
2223 : * Get endValidTime.
2224 : * @return endValidTime as ArrayTime
2225 : */
2226 0 : ArrayTime CalAntennaSolutionsRow::getEndValidTime() const {
2227 :
2228 0 : return endValidTime;
2229 : }
2230 :
2231 : /**
2232 : * Set endValidTime with the specified ArrayTime.
2233 : * @param endValidTime The ArrayTime value to which endValidTime is to be set.
2234 :
2235 :
2236 :
2237 : */
2238 0 : void CalAntennaSolutionsRow::setEndValidTime (ArrayTime endValidTime) {
2239 :
2240 :
2241 0 : if (hasBeenAdded) {
2242 :
2243 : }
2244 :
2245 0 : this->endValidTime = endValidTime;
2246 :
2247 0 : }
2248 :
2249 :
2250 :
2251 :
2252 :
2253 :
2254 : /**
2255 : * Get numReceptor.
2256 : * @return numReceptor as int
2257 : */
2258 0 : int CalAntennaSolutionsRow::getNumReceptor() const {
2259 :
2260 0 : return numReceptor;
2261 : }
2262 :
2263 : /**
2264 : * Set numReceptor with the specified int.
2265 : * @param numReceptor The int value to which numReceptor is to be set.
2266 :
2267 :
2268 :
2269 : */
2270 0 : void CalAntennaSolutionsRow::setNumReceptor (int numReceptor) {
2271 :
2272 :
2273 0 : if (hasBeenAdded) {
2274 :
2275 : }
2276 :
2277 0 : this->numReceptor = numReceptor;
2278 :
2279 0 : }
2280 :
2281 :
2282 :
2283 :
2284 :
2285 :
2286 : /**
2287 : * Get refAntennaName.
2288 : * @return refAntennaName as std::string
2289 : */
2290 0 : std::string CalAntennaSolutionsRow::getRefAntennaName() const {
2291 :
2292 0 : return refAntennaName;
2293 : }
2294 :
2295 : /**
2296 : * Set refAntennaName with the specified std::string.
2297 : * @param refAntennaName The std::string value to which refAntennaName is to be set.
2298 :
2299 :
2300 :
2301 : */
2302 0 : void CalAntennaSolutionsRow::setRefAntennaName (std::string refAntennaName) {
2303 :
2304 :
2305 0 : if (hasBeenAdded) {
2306 :
2307 : }
2308 :
2309 0 : this->refAntennaName = refAntennaName;
2310 :
2311 0 : }
2312 :
2313 :
2314 :
2315 :
2316 :
2317 :
2318 : /**
2319 : * Get direction.
2320 : * @return direction as std::vector<Angle >
2321 : */
2322 0 : std::vector<Angle > CalAntennaSolutionsRow::getDirection() const {
2323 :
2324 0 : return direction;
2325 : }
2326 :
2327 : /**
2328 : * Set direction with the specified std::vector<Angle >.
2329 : * @param direction The std::vector<Angle > value to which direction is to be set.
2330 :
2331 :
2332 :
2333 : */
2334 0 : void CalAntennaSolutionsRow::setDirection (std::vector<Angle > direction) {
2335 :
2336 :
2337 0 : if (hasBeenAdded) {
2338 :
2339 : }
2340 :
2341 0 : this->direction = direction;
2342 :
2343 0 : }
2344 :
2345 :
2346 :
2347 :
2348 :
2349 :
2350 : /**
2351 : * Get frequencyRange.
2352 : * @return frequencyRange as std::vector<Frequency >
2353 : */
2354 0 : std::vector<Frequency > CalAntennaSolutionsRow::getFrequencyRange() const {
2355 :
2356 0 : return frequencyRange;
2357 : }
2358 :
2359 : /**
2360 : * Set frequencyRange with the specified std::vector<Frequency >.
2361 : * @param frequencyRange The std::vector<Frequency > value to which frequencyRange is to be set.
2362 :
2363 :
2364 :
2365 : */
2366 0 : void CalAntennaSolutionsRow::setFrequencyRange (std::vector<Frequency > frequencyRange) {
2367 :
2368 :
2369 0 : if (hasBeenAdded) {
2370 :
2371 : }
2372 :
2373 0 : this->frequencyRange = frequencyRange;
2374 :
2375 0 : }
2376 :
2377 :
2378 :
2379 :
2380 :
2381 :
2382 : /**
2383 : * Get integrationTime.
2384 : * @return integrationTime as Interval
2385 : */
2386 0 : Interval CalAntennaSolutionsRow::getIntegrationTime() const {
2387 :
2388 0 : return integrationTime;
2389 : }
2390 :
2391 : /**
2392 : * Set integrationTime with the specified Interval.
2393 : * @param integrationTime The Interval value to which integrationTime is to be set.
2394 :
2395 :
2396 :
2397 : */
2398 0 : void CalAntennaSolutionsRow::setIntegrationTime (Interval integrationTime) {
2399 :
2400 :
2401 0 : if (hasBeenAdded) {
2402 :
2403 : }
2404 :
2405 0 : this->integrationTime = integrationTime;
2406 :
2407 0 : }
2408 :
2409 :
2410 :
2411 :
2412 :
2413 :
2414 : /**
2415 : * Get polarizationTypes.
2416 : * @return polarizationTypes as std::vector<PolarizationTypeMod::PolarizationType >
2417 : */
2418 0 : std::vector<PolarizationTypeMod::PolarizationType > CalAntennaSolutionsRow::getPolarizationTypes() const {
2419 :
2420 0 : return polarizationTypes;
2421 : }
2422 :
2423 : /**
2424 : * Set polarizationTypes with the specified std::vector<PolarizationTypeMod::PolarizationType >.
2425 : * @param polarizationTypes The std::vector<PolarizationTypeMod::PolarizationType > value to which polarizationTypes is to be set.
2426 :
2427 :
2428 :
2429 : */
2430 0 : void CalAntennaSolutionsRow::setPolarizationTypes (std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes) {
2431 :
2432 :
2433 0 : if (hasBeenAdded) {
2434 :
2435 : }
2436 :
2437 0 : this->polarizationTypes = polarizationTypes;
2438 :
2439 0 : }
2440 :
2441 :
2442 :
2443 :
2444 :
2445 :
2446 : /**
2447 : * Get correctionValidity.
2448 : * @return correctionValidity as bool
2449 : */
2450 0 : bool CalAntennaSolutionsRow::getCorrectionValidity() const {
2451 :
2452 0 : return correctionValidity;
2453 : }
2454 :
2455 : /**
2456 : * Set correctionValidity with the specified bool.
2457 : * @param correctionValidity The bool value to which correctionValidity is to be set.
2458 :
2459 :
2460 :
2461 : */
2462 0 : void CalAntennaSolutionsRow::setCorrectionValidity (bool correctionValidity) {
2463 :
2464 :
2465 0 : if (hasBeenAdded) {
2466 :
2467 : }
2468 :
2469 0 : this->correctionValidity = correctionValidity;
2470 :
2471 0 : }
2472 :
2473 :
2474 :
2475 :
2476 :
2477 :
2478 : /**
2479 : * Get phaseAnt.
2480 : * @return phaseAnt as std::vector<float >
2481 : */
2482 0 : std::vector<float > CalAntennaSolutionsRow::getPhaseAnt() const {
2483 :
2484 0 : return phaseAnt;
2485 : }
2486 :
2487 : /**
2488 : * Set phaseAnt with the specified std::vector<float >.
2489 : * @param phaseAnt The std::vector<float > value to which phaseAnt is to be set.
2490 :
2491 :
2492 :
2493 : */
2494 0 : void CalAntennaSolutionsRow::setPhaseAnt (std::vector<float > phaseAnt) {
2495 :
2496 :
2497 0 : if (hasBeenAdded) {
2498 :
2499 : }
2500 :
2501 0 : this->phaseAnt = phaseAnt;
2502 :
2503 0 : }
2504 :
2505 :
2506 :
2507 :
2508 :
2509 :
2510 : /**
2511 : * Get phaseAntRMS.
2512 : * @return phaseAntRMS as std::vector<float >
2513 : */
2514 0 : std::vector<float > CalAntennaSolutionsRow::getPhaseAntRMS() const {
2515 :
2516 0 : return phaseAntRMS;
2517 : }
2518 :
2519 : /**
2520 : * Set phaseAntRMS with the specified std::vector<float >.
2521 : * @param phaseAntRMS The std::vector<float > value to which phaseAntRMS is to be set.
2522 :
2523 :
2524 :
2525 : */
2526 0 : void CalAntennaSolutionsRow::setPhaseAntRMS (std::vector<float > phaseAntRMS) {
2527 :
2528 :
2529 0 : if (hasBeenAdded) {
2530 :
2531 : }
2532 :
2533 0 : this->phaseAntRMS = phaseAntRMS;
2534 :
2535 0 : }
2536 :
2537 :
2538 :
2539 :
2540 :
2541 :
2542 : /**
2543 : * Get amplitudeAnt.
2544 : * @return amplitudeAnt as std::vector<float >
2545 : */
2546 0 : std::vector<float > CalAntennaSolutionsRow::getAmplitudeAnt() const {
2547 :
2548 0 : return amplitudeAnt;
2549 : }
2550 :
2551 : /**
2552 : * Set amplitudeAnt with the specified std::vector<float >.
2553 : * @param amplitudeAnt The std::vector<float > value to which amplitudeAnt is to be set.
2554 :
2555 :
2556 :
2557 : */
2558 0 : void CalAntennaSolutionsRow::setAmplitudeAnt (std::vector<float > amplitudeAnt) {
2559 :
2560 :
2561 0 : if (hasBeenAdded) {
2562 :
2563 : }
2564 :
2565 0 : this->amplitudeAnt = amplitudeAnt;
2566 :
2567 0 : }
2568 :
2569 :
2570 :
2571 :
2572 :
2573 :
2574 : /**
2575 : * Get amplitudeAntRMS.
2576 : * @return amplitudeAntRMS as std::vector<float >
2577 : */
2578 0 : std::vector<float > CalAntennaSolutionsRow::getAmplitudeAntRMS() const {
2579 :
2580 0 : return amplitudeAntRMS;
2581 : }
2582 :
2583 : /**
2584 : * Set amplitudeAntRMS with the specified std::vector<float >.
2585 : * @param amplitudeAntRMS The std::vector<float > value to which amplitudeAntRMS is to be set.
2586 :
2587 :
2588 :
2589 : */
2590 0 : void CalAntennaSolutionsRow::setAmplitudeAntRMS (std::vector<float > amplitudeAntRMS) {
2591 :
2592 :
2593 0 : if (hasBeenAdded) {
2594 :
2595 : }
2596 :
2597 0 : this->amplitudeAntRMS = amplitudeAntRMS;
2598 :
2599 0 : }
2600 :
2601 :
2602 :
2603 :
2604 : ///////////////////////////////////////////////
2605 : // Extrinsic Table Attributes getters/setters//
2606 : ///////////////////////////////////////////////
2607 :
2608 :
2609 :
2610 :
2611 : /**
2612 : * Get calDataId.
2613 : * @return calDataId as Tag
2614 : */
2615 0 : Tag CalAntennaSolutionsRow::getCalDataId() const {
2616 :
2617 0 : return calDataId;
2618 : }
2619 :
2620 : /**
2621 : * Set calDataId with the specified Tag.
2622 : * @param calDataId The Tag value to which calDataId is to be set.
2623 :
2624 :
2625 :
2626 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2627 :
2628 : */
2629 0 : void CalAntennaSolutionsRow::setCalDataId (Tag calDataId) {
2630 :
2631 :
2632 0 : if (hasBeenAdded) {
2633 :
2634 0 : throw IllegalAccessException("calDataId", "CalAntennaSolutions");
2635 :
2636 : }
2637 :
2638 0 : this->calDataId = calDataId;
2639 :
2640 0 : }
2641 :
2642 :
2643 :
2644 :
2645 :
2646 :
2647 : /**
2648 : * Get calReductionId.
2649 : * @return calReductionId as Tag
2650 : */
2651 0 : Tag CalAntennaSolutionsRow::getCalReductionId() const {
2652 :
2653 0 : return calReductionId;
2654 : }
2655 :
2656 : /**
2657 : * Set calReductionId with the specified Tag.
2658 : * @param calReductionId The Tag value to which calReductionId is to be set.
2659 :
2660 :
2661 :
2662 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2663 :
2664 : */
2665 0 : void CalAntennaSolutionsRow::setCalReductionId (Tag calReductionId) {
2666 :
2667 :
2668 0 : if (hasBeenAdded) {
2669 :
2670 0 : throw IllegalAccessException("calReductionId", "CalAntennaSolutions");
2671 :
2672 : }
2673 :
2674 0 : this->calReductionId = calReductionId;
2675 :
2676 0 : }
2677 :
2678 :
2679 :
2680 :
2681 :
2682 :
2683 : /**
2684 : * Get spectralWindowId.
2685 : * @return spectralWindowId as Tag
2686 : */
2687 0 : Tag CalAntennaSolutionsRow::getSpectralWindowId() const {
2688 :
2689 0 : return spectralWindowId;
2690 : }
2691 :
2692 : /**
2693 : * Set spectralWindowId with the specified Tag.
2694 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
2695 :
2696 :
2697 :
2698 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2699 :
2700 : */
2701 0 : void CalAntennaSolutionsRow::setSpectralWindowId (Tag spectralWindowId) {
2702 :
2703 :
2704 0 : if (hasBeenAdded) {
2705 :
2706 0 : throw IllegalAccessException("spectralWindowId", "CalAntennaSolutions");
2707 :
2708 : }
2709 :
2710 0 : this->spectralWindowId = spectralWindowId;
2711 :
2712 0 : }
2713 :
2714 :
2715 :
2716 :
2717 : //////////////////////////////////////
2718 : // Links Attributes getters/setters //
2719 : //////////////////////////////////////
2720 :
2721 :
2722 :
2723 :
2724 :
2725 :
2726 : /**
2727 : * Returns the pointer to the row in the CalData table having CalData.calDataId == calDataId
2728 : * @return a CalDataRow*
2729 : *
2730 :
2731 : */
2732 0 : CalDataRow* CalAntennaSolutionsRow::getCalDataUsingCalDataId() {
2733 :
2734 0 : return table.getContainer().getCalData().getRowByKey(calDataId);
2735 : }
2736 :
2737 :
2738 :
2739 :
2740 :
2741 :
2742 :
2743 :
2744 :
2745 : /**
2746 : * Returns the pointer to the row in the CalReduction table having CalReduction.calReductionId == calReductionId
2747 : * @return a CalReductionRow*
2748 : *
2749 :
2750 : */
2751 0 : CalReductionRow* CalAntennaSolutionsRow::getCalReductionUsingCalReductionId() {
2752 :
2753 0 : return table.getContainer().getCalReduction().getRowByKey(calReductionId);
2754 : }
2755 :
2756 :
2757 :
2758 :
2759 :
2760 :
2761 :
2762 :
2763 :
2764 : /**
2765 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.spectralWindowId == spectralWindowId
2766 : * @return a SpectralWindowRow*
2767 : *
2768 :
2769 : */
2770 0 : SpectralWindowRow* CalAntennaSolutionsRow::getSpectralWindowUsingSpectralWindowId() {
2771 :
2772 0 : return table.getContainer().getSpectralWindow().getRowByKey(spectralWindowId);
2773 : }
2774 :
2775 :
2776 :
2777 :
2778 :
2779 : /**
2780 : * Create a CalAntennaSolutionsRow.
2781 : * <p>
2782 : * This constructor is private because only the
2783 : * table can create rows. All rows know the table
2784 : * to which they belong.
2785 : * @param table The table to which this row belongs.
2786 : */
2787 0 : CalAntennaSolutionsRow::CalAntennaSolutionsRow (CalAntennaSolutionsTable &t) : table(t) {
2788 0 : hasBeenAdded = false;
2789 :
2790 :
2791 :
2792 :
2793 :
2794 :
2795 :
2796 :
2797 :
2798 :
2799 :
2800 :
2801 :
2802 :
2803 :
2804 :
2805 :
2806 :
2807 :
2808 :
2809 :
2810 :
2811 :
2812 :
2813 :
2814 :
2815 :
2816 :
2817 :
2818 :
2819 :
2820 :
2821 :
2822 :
2823 :
2824 :
2825 :
2826 :
2827 :
2828 :
2829 :
2830 :
2831 :
2832 :
2833 :
2834 :
2835 :
2836 :
2837 :
2838 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2839 0 : atmPhaseCorrection = CAtmPhaseCorrection::from_int(0);
2840 :
2841 :
2842 :
2843 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2844 0 : basebandName = CBasebandName::from_int(0);
2845 :
2846 :
2847 :
2848 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2849 0 : receiverBand = CReceiverBand::from_int(0);
2850 :
2851 :
2852 :
2853 :
2854 :
2855 :
2856 :
2857 :
2858 :
2859 :
2860 :
2861 :
2862 :
2863 :
2864 :
2865 :
2866 :
2867 :
2868 :
2869 :
2870 :
2871 :
2872 :
2873 :
2874 :
2875 :
2876 :
2877 :
2878 :
2879 :
2880 0 : fromBinMethods["antennaName"] = &CalAntennaSolutionsRow::antennaNameFromBin;
2881 0 : fromBinMethods["atmPhaseCorrection"] = &CalAntennaSolutionsRow::atmPhaseCorrectionFromBin;
2882 0 : fromBinMethods["receiverBand"] = &CalAntennaSolutionsRow::receiverBandFromBin;
2883 0 : fromBinMethods["basebandName"] = &CalAntennaSolutionsRow::basebandNameFromBin;
2884 0 : fromBinMethods["calDataId"] = &CalAntennaSolutionsRow::calDataIdFromBin;
2885 0 : fromBinMethods["calReductionId"] = &CalAntennaSolutionsRow::calReductionIdFromBin;
2886 0 : fromBinMethods["spectralWindowId"] = &CalAntennaSolutionsRow::spectralWindowIdFromBin;
2887 0 : fromBinMethods["startValidTime"] = &CalAntennaSolutionsRow::startValidTimeFromBin;
2888 0 : fromBinMethods["endValidTime"] = &CalAntennaSolutionsRow::endValidTimeFromBin;
2889 0 : fromBinMethods["numReceptor"] = &CalAntennaSolutionsRow::numReceptorFromBin;
2890 0 : fromBinMethods["refAntennaName"] = &CalAntennaSolutionsRow::refAntennaNameFromBin;
2891 0 : fromBinMethods["direction"] = &CalAntennaSolutionsRow::directionFromBin;
2892 0 : fromBinMethods["frequencyRange"] = &CalAntennaSolutionsRow::frequencyRangeFromBin;
2893 0 : fromBinMethods["integrationTime"] = &CalAntennaSolutionsRow::integrationTimeFromBin;
2894 0 : fromBinMethods["polarizationTypes"] = &CalAntennaSolutionsRow::polarizationTypesFromBin;
2895 0 : fromBinMethods["correctionValidity"] = &CalAntennaSolutionsRow::correctionValidityFromBin;
2896 0 : fromBinMethods["phaseAnt"] = &CalAntennaSolutionsRow::phaseAntFromBin;
2897 0 : fromBinMethods["phaseAntRMS"] = &CalAntennaSolutionsRow::phaseAntRMSFromBin;
2898 0 : fromBinMethods["amplitudeAnt"] = &CalAntennaSolutionsRow::amplitudeAntFromBin;
2899 0 : fromBinMethods["amplitudeAntRMS"] = &CalAntennaSolutionsRow::amplitudeAntRMSFromBin;
2900 :
2901 :
2902 :
2903 :
2904 :
2905 :
2906 :
2907 0 : fromTextMethods["antennaName"] = &CalAntennaSolutionsRow::antennaNameFromText;
2908 :
2909 :
2910 :
2911 0 : fromTextMethods["atmPhaseCorrection"] = &CalAntennaSolutionsRow::atmPhaseCorrectionFromText;
2912 :
2913 :
2914 :
2915 0 : fromTextMethods["receiverBand"] = &CalAntennaSolutionsRow::receiverBandFromText;
2916 :
2917 :
2918 :
2919 0 : fromTextMethods["basebandName"] = &CalAntennaSolutionsRow::basebandNameFromText;
2920 :
2921 :
2922 :
2923 0 : fromTextMethods["calDataId"] = &CalAntennaSolutionsRow::calDataIdFromText;
2924 :
2925 :
2926 :
2927 0 : fromTextMethods["calReductionId"] = &CalAntennaSolutionsRow::calReductionIdFromText;
2928 :
2929 :
2930 :
2931 0 : fromTextMethods["spectralWindowId"] = &CalAntennaSolutionsRow::spectralWindowIdFromText;
2932 :
2933 :
2934 :
2935 0 : fromTextMethods["startValidTime"] = &CalAntennaSolutionsRow::startValidTimeFromText;
2936 :
2937 :
2938 :
2939 0 : fromTextMethods["endValidTime"] = &CalAntennaSolutionsRow::endValidTimeFromText;
2940 :
2941 :
2942 :
2943 0 : fromTextMethods["numReceptor"] = &CalAntennaSolutionsRow::numReceptorFromText;
2944 :
2945 :
2946 :
2947 0 : fromTextMethods["refAntennaName"] = &CalAntennaSolutionsRow::refAntennaNameFromText;
2948 :
2949 :
2950 :
2951 0 : fromTextMethods["direction"] = &CalAntennaSolutionsRow::directionFromText;
2952 :
2953 :
2954 :
2955 0 : fromTextMethods["frequencyRange"] = &CalAntennaSolutionsRow::frequencyRangeFromText;
2956 :
2957 :
2958 :
2959 0 : fromTextMethods["integrationTime"] = &CalAntennaSolutionsRow::integrationTimeFromText;
2960 :
2961 :
2962 :
2963 0 : fromTextMethods["polarizationTypes"] = &CalAntennaSolutionsRow::polarizationTypesFromText;
2964 :
2965 :
2966 :
2967 0 : fromTextMethods["correctionValidity"] = &CalAntennaSolutionsRow::correctionValidityFromText;
2968 :
2969 :
2970 :
2971 0 : fromTextMethods["phaseAnt"] = &CalAntennaSolutionsRow::phaseAntFromText;
2972 :
2973 :
2974 :
2975 0 : fromTextMethods["phaseAntRMS"] = &CalAntennaSolutionsRow::phaseAntRMSFromText;
2976 :
2977 :
2978 :
2979 0 : fromTextMethods["amplitudeAnt"] = &CalAntennaSolutionsRow::amplitudeAntFromText;
2980 :
2981 :
2982 :
2983 0 : fromTextMethods["amplitudeAntRMS"] = &CalAntennaSolutionsRow::amplitudeAntRMSFromText;
2984 :
2985 :
2986 :
2987 :
2988 0 : }
2989 :
2990 0 : CalAntennaSolutionsRow::CalAntennaSolutionsRow (CalAntennaSolutionsTable &t, CalAntennaSolutionsRow *row) : table(t) {
2991 0 : hasBeenAdded = false;
2992 :
2993 0 : if (row == 0) {
2994 :
2995 :
2996 :
2997 :
2998 :
2999 :
3000 :
3001 :
3002 :
3003 :
3004 :
3005 :
3006 :
3007 :
3008 :
3009 :
3010 :
3011 :
3012 :
3013 :
3014 :
3015 :
3016 :
3017 :
3018 :
3019 :
3020 :
3021 :
3022 :
3023 :
3024 :
3025 :
3026 :
3027 :
3028 :
3029 :
3030 :
3031 :
3032 :
3033 :
3034 :
3035 :
3036 :
3037 : }
3038 : else {
3039 :
3040 :
3041 0 : antennaName = row->antennaName;
3042 :
3043 0 : atmPhaseCorrection = row->atmPhaseCorrection;
3044 :
3045 0 : receiverBand = row->receiverBand;
3046 :
3047 0 : basebandName = row->basebandName;
3048 :
3049 0 : calDataId = row->calDataId;
3050 :
3051 0 : calReductionId = row->calReductionId;
3052 :
3053 0 : spectralWindowId = row->spectralWindowId;
3054 :
3055 :
3056 :
3057 :
3058 0 : startValidTime = row->startValidTime;
3059 :
3060 0 : endValidTime = row->endValidTime;
3061 :
3062 0 : numReceptor = row->numReceptor;
3063 :
3064 0 : refAntennaName = row->refAntennaName;
3065 :
3066 0 : direction = row->direction;
3067 :
3068 0 : frequencyRange = row->frequencyRange;
3069 :
3070 0 : integrationTime = row->integrationTime;
3071 :
3072 0 : polarizationTypes = row->polarizationTypes;
3073 :
3074 0 : correctionValidity = row->correctionValidity;
3075 :
3076 0 : phaseAnt = row->phaseAnt;
3077 :
3078 0 : phaseAntRMS = row->phaseAntRMS;
3079 :
3080 0 : amplitudeAnt = row->amplitudeAnt;
3081 :
3082 0 : amplitudeAntRMS = row->amplitudeAntRMS;
3083 :
3084 :
3085 :
3086 :
3087 : }
3088 :
3089 0 : fromBinMethods["antennaName"] = &CalAntennaSolutionsRow::antennaNameFromBin;
3090 0 : fromBinMethods["atmPhaseCorrection"] = &CalAntennaSolutionsRow::atmPhaseCorrectionFromBin;
3091 0 : fromBinMethods["receiverBand"] = &CalAntennaSolutionsRow::receiverBandFromBin;
3092 0 : fromBinMethods["basebandName"] = &CalAntennaSolutionsRow::basebandNameFromBin;
3093 0 : fromBinMethods["calDataId"] = &CalAntennaSolutionsRow::calDataIdFromBin;
3094 0 : fromBinMethods["calReductionId"] = &CalAntennaSolutionsRow::calReductionIdFromBin;
3095 0 : fromBinMethods["spectralWindowId"] = &CalAntennaSolutionsRow::spectralWindowIdFromBin;
3096 0 : fromBinMethods["startValidTime"] = &CalAntennaSolutionsRow::startValidTimeFromBin;
3097 0 : fromBinMethods["endValidTime"] = &CalAntennaSolutionsRow::endValidTimeFromBin;
3098 0 : fromBinMethods["numReceptor"] = &CalAntennaSolutionsRow::numReceptorFromBin;
3099 0 : fromBinMethods["refAntennaName"] = &CalAntennaSolutionsRow::refAntennaNameFromBin;
3100 0 : fromBinMethods["direction"] = &CalAntennaSolutionsRow::directionFromBin;
3101 0 : fromBinMethods["frequencyRange"] = &CalAntennaSolutionsRow::frequencyRangeFromBin;
3102 0 : fromBinMethods["integrationTime"] = &CalAntennaSolutionsRow::integrationTimeFromBin;
3103 0 : fromBinMethods["polarizationTypes"] = &CalAntennaSolutionsRow::polarizationTypesFromBin;
3104 0 : fromBinMethods["correctionValidity"] = &CalAntennaSolutionsRow::correctionValidityFromBin;
3105 0 : fromBinMethods["phaseAnt"] = &CalAntennaSolutionsRow::phaseAntFromBin;
3106 0 : fromBinMethods["phaseAntRMS"] = &CalAntennaSolutionsRow::phaseAntRMSFromBin;
3107 0 : fromBinMethods["amplitudeAnt"] = &CalAntennaSolutionsRow::amplitudeAntFromBin;
3108 0 : fromBinMethods["amplitudeAntRMS"] = &CalAntennaSolutionsRow::amplitudeAntRMSFromBin;
3109 :
3110 :
3111 :
3112 0 : }
3113 :
3114 :
3115 0 : bool CalAntennaSolutionsRow::compareNoAutoInc(std::string antennaName, AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, ReceiverBandMod::ReceiverBand receiverBand, BasebandNameMod::BasebandName basebandName, Tag calDataId, Tag calReductionId, Tag spectralWindowId, ArrayTime startValidTime, ArrayTime endValidTime, int numReceptor, std::string refAntennaName, std::vector<Angle > direction, std::vector<Frequency > frequencyRange, Interval integrationTime, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, bool correctionValidity, std::vector<float > phaseAnt, std::vector<float > phaseAntRMS, std::vector<float > amplitudeAnt, std::vector<float > amplitudeAntRMS) {
3116 : bool result;
3117 0 : result = true;
3118 :
3119 :
3120 :
3121 0 : result = result && (this->antennaName == antennaName);
3122 :
3123 0 : if (!result) return false;
3124 :
3125 :
3126 :
3127 :
3128 0 : result = result && (this->atmPhaseCorrection == atmPhaseCorrection);
3129 :
3130 0 : if (!result) return false;
3131 :
3132 :
3133 :
3134 :
3135 0 : result = result && (this->receiverBand == receiverBand);
3136 :
3137 0 : if (!result) return false;
3138 :
3139 :
3140 :
3141 :
3142 0 : result = result && (this->basebandName == basebandName);
3143 :
3144 0 : if (!result) return false;
3145 :
3146 :
3147 :
3148 :
3149 0 : result = result && (this->calDataId == calDataId);
3150 :
3151 0 : if (!result) return false;
3152 :
3153 :
3154 :
3155 :
3156 0 : result = result && (this->calReductionId == calReductionId);
3157 :
3158 0 : if (!result) return false;
3159 :
3160 :
3161 :
3162 :
3163 0 : result = result && (this->spectralWindowId == spectralWindowId);
3164 :
3165 0 : if (!result) return false;
3166 :
3167 :
3168 :
3169 :
3170 0 : result = result && (this->startValidTime == startValidTime);
3171 :
3172 0 : if (!result) return false;
3173 :
3174 :
3175 :
3176 :
3177 0 : result = result && (this->endValidTime == endValidTime);
3178 :
3179 0 : if (!result) return false;
3180 :
3181 :
3182 :
3183 :
3184 0 : result = result && (this->numReceptor == numReceptor);
3185 :
3186 0 : if (!result) return false;
3187 :
3188 :
3189 :
3190 :
3191 0 : result = result && (this->refAntennaName == refAntennaName);
3192 :
3193 0 : if (!result) return false;
3194 :
3195 :
3196 :
3197 :
3198 0 : result = result && (this->direction == direction);
3199 :
3200 0 : if (!result) return false;
3201 :
3202 :
3203 :
3204 :
3205 0 : result = result && (this->frequencyRange == frequencyRange);
3206 :
3207 0 : if (!result) return false;
3208 :
3209 :
3210 :
3211 :
3212 0 : result = result && (this->integrationTime == integrationTime);
3213 :
3214 0 : if (!result) return false;
3215 :
3216 :
3217 :
3218 :
3219 0 : result = result && (this->polarizationTypes == polarizationTypes);
3220 :
3221 0 : if (!result) return false;
3222 :
3223 :
3224 :
3225 :
3226 0 : result = result && (this->correctionValidity == correctionValidity);
3227 :
3228 0 : if (!result) return false;
3229 :
3230 :
3231 :
3232 :
3233 0 : result = result && (this->phaseAnt == phaseAnt);
3234 :
3235 0 : if (!result) return false;
3236 :
3237 :
3238 :
3239 :
3240 0 : result = result && (this->phaseAntRMS == phaseAntRMS);
3241 :
3242 0 : if (!result) return false;
3243 :
3244 :
3245 :
3246 :
3247 0 : result = result && (this->amplitudeAnt == amplitudeAnt);
3248 :
3249 0 : if (!result) return false;
3250 :
3251 :
3252 :
3253 :
3254 0 : result = result && (this->amplitudeAntRMS == amplitudeAntRMS);
3255 :
3256 0 : if (!result) return false;
3257 :
3258 :
3259 0 : return result;
3260 : }
3261 :
3262 :
3263 :
3264 0 : bool CalAntennaSolutionsRow::compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, int numReceptor, std::string refAntennaName, std::vector<Angle > direction, std::vector<Frequency > frequencyRange, Interval integrationTime, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, bool correctionValidity, std::vector<float > phaseAnt, std::vector<float > phaseAntRMS, std::vector<float > amplitudeAnt, std::vector<float > amplitudeAntRMS) {
3265 : bool result;
3266 0 : result = true;
3267 :
3268 :
3269 0 : if (!(this->startValidTime == startValidTime)) return false;
3270 :
3271 :
3272 :
3273 0 : if (!(this->endValidTime == endValidTime)) return false;
3274 :
3275 :
3276 :
3277 0 : if (!(this->numReceptor == numReceptor)) return false;
3278 :
3279 :
3280 :
3281 0 : if (!(this->refAntennaName == refAntennaName)) return false;
3282 :
3283 :
3284 :
3285 0 : if (!(this->direction == direction)) return false;
3286 :
3287 :
3288 :
3289 0 : if (!(this->frequencyRange == frequencyRange)) return false;
3290 :
3291 :
3292 :
3293 0 : if (!(this->integrationTime == integrationTime)) return false;
3294 :
3295 :
3296 :
3297 0 : if (!(this->polarizationTypes == polarizationTypes)) return false;
3298 :
3299 :
3300 :
3301 0 : if (!(this->correctionValidity == correctionValidity)) return false;
3302 :
3303 :
3304 :
3305 0 : if (!(this->phaseAnt == phaseAnt)) return false;
3306 :
3307 :
3308 :
3309 0 : if (!(this->phaseAntRMS == phaseAntRMS)) return false;
3310 :
3311 :
3312 :
3313 0 : if (!(this->amplitudeAnt == amplitudeAnt)) return false;
3314 :
3315 :
3316 :
3317 0 : if (!(this->amplitudeAntRMS == amplitudeAntRMS)) return false;
3318 :
3319 :
3320 0 : return result;
3321 : }
3322 :
3323 :
3324 : /**
3325 : * Return true if all required attributes of the value part are equal to their homologues
3326 : * in x and false otherwise.
3327 : *
3328 :
3329 : * @param x a pointer on the CalAntennaSolutionsRow whose required attributes of the value part
3330 :
3331 : * will be compared with those of this.
3332 : * @return a boolean.
3333 : */
3334 0 : bool CalAntennaSolutionsRow::equalByRequiredValue(CalAntennaSolutionsRow* x ) {
3335 :
3336 :
3337 0 : if (this->startValidTime != x->startValidTime) return false;
3338 :
3339 0 : if (this->endValidTime != x->endValidTime) return false;
3340 :
3341 0 : if (this->numReceptor != x->numReceptor) return false;
3342 :
3343 0 : if (this->refAntennaName != x->refAntennaName) return false;
3344 :
3345 0 : if (this->direction != x->direction) return false;
3346 :
3347 0 : if (this->frequencyRange != x->frequencyRange) return false;
3348 :
3349 0 : if (this->integrationTime != x->integrationTime) return false;
3350 :
3351 0 : if (this->polarizationTypes != x->polarizationTypes) return false;
3352 :
3353 0 : if (this->correctionValidity != x->correctionValidity) return false;
3354 :
3355 0 : if (this->phaseAnt != x->phaseAnt) return false;
3356 :
3357 0 : if (this->phaseAntRMS != x->phaseAntRMS) return false;
3358 :
3359 0 : if (this->amplitudeAnt != x->amplitudeAnt) return false;
3360 :
3361 0 : if (this->amplitudeAntRMS != x->amplitudeAntRMS) return false;
3362 :
3363 :
3364 0 : return true;
3365 : }
3366 :
3367 : /*
3368 : map<string, CalAntennaSolutionsAttributeFromBin> CalAntennaSolutionsRow::initFromBinMethods() {
3369 : map<string, CalAntennaSolutionsAttributeFromBin> result;
3370 :
3371 : result["antennaName"] = &CalAntennaSolutionsRow::antennaNameFromBin;
3372 : result["atmPhaseCorrection"] = &CalAntennaSolutionsRow::atmPhaseCorrectionFromBin;
3373 : result["receiverBand"] = &CalAntennaSolutionsRow::receiverBandFromBin;
3374 : result["basebandName"] = &CalAntennaSolutionsRow::basebandNameFromBin;
3375 : result["calDataId"] = &CalAntennaSolutionsRow::calDataIdFromBin;
3376 : result["calReductionId"] = &CalAntennaSolutionsRow::calReductionIdFromBin;
3377 : result["spectralWindowId"] = &CalAntennaSolutionsRow::spectralWindowIdFromBin;
3378 : result["startValidTime"] = &CalAntennaSolutionsRow::startValidTimeFromBin;
3379 : result["endValidTime"] = &CalAntennaSolutionsRow::endValidTimeFromBin;
3380 : result["numReceptor"] = &CalAntennaSolutionsRow::numReceptorFromBin;
3381 : result["refAntennaName"] = &CalAntennaSolutionsRow::refAntennaNameFromBin;
3382 : result["direction"] = &CalAntennaSolutionsRow::directionFromBin;
3383 : result["frequencyRange"] = &CalAntennaSolutionsRow::frequencyRangeFromBin;
3384 : result["integrationTime"] = &CalAntennaSolutionsRow::integrationTimeFromBin;
3385 : result["polarizationTypes"] = &CalAntennaSolutionsRow::polarizationTypesFromBin;
3386 : result["correctionValidity"] = &CalAntennaSolutionsRow::correctionValidityFromBin;
3387 : result["phaseAnt"] = &CalAntennaSolutionsRow::phaseAntFromBin;
3388 : result["phaseAntRMS"] = &CalAntennaSolutionsRow::phaseAntRMSFromBin;
3389 : result["amplitudeAnt"] = &CalAntennaSolutionsRow::amplitudeAntFromBin;
3390 : result["amplitudeAntRMS"] = &CalAntennaSolutionsRow::amplitudeAntRMSFromBin;
3391 :
3392 :
3393 :
3394 :
3395 : return result;
3396 : }
3397 : */
3398 : } // End namespace asdm
3399 :
|
