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 CalPhaseRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalPhaseRow.h>
39 : #include <alma/ASDM/CalPhaseTable.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 :
48 : using asdm::ASDM;
49 : using asdm::CalPhaseRow;
50 : using asdm::CalPhaseTable;
51 :
52 : using asdm::CalDataTable;
53 : using asdm::CalDataRow;
54 :
55 : using asdm::CalReductionTable;
56 : using asdm::CalReductionRow;
57 :
58 :
59 : #include <alma/ASDM/Parser.h>
60 :
61 : #include <alma/ASDM/EnumerationParser.h>
62 : #include <alma/ASDM/ASDMValuesParser.h>
63 :
64 : #include <alma/ASDM/InvalidArgumentException.h>
65 :
66 : using namespace std;
67 :
68 : namespace asdm {
69 0 : CalPhaseRow::~CalPhaseRow() {
70 0 : }
71 :
72 : /**
73 : * Return the table to which this row belongs.
74 : */
75 0 : CalPhaseTable &CalPhaseRow::getTable() const {
76 0 : return table;
77 : }
78 :
79 0 : bool CalPhaseRow::isAdded() const {
80 0 : return hasBeenAdded;
81 : }
82 :
83 0 : void CalPhaseRow::isAdded(bool added) {
84 0 : hasBeenAdded = added;
85 0 : }
86 :
87 : #ifndef WITHOUT_ACS
88 : using asdmIDL::CalPhaseRowIDL;
89 : #endif
90 :
91 : #ifndef WITHOUT_ACS
92 : /**
93 : * Return this row in the form of an IDL struct.
94 : * @return The values of this row as a CalPhaseRowIDL struct.
95 : */
96 : CalPhaseRowIDL *CalPhaseRow::toIDL() const {
97 : CalPhaseRowIDL *x = new CalPhaseRowIDL ();
98 :
99 : // Fill the IDL structure.
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 :
108 : x->basebandName = basebandName;
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 :
120 : x->receiverBand = receiverBand;
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 : x->atmPhaseCorrection = atmPhaseCorrection;
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 : x->startValidTime = startValidTime.toIDLArrayTime();
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 : x->endValidTime = endValidTime.toIDLArrayTime();
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 : x->numBaseline = numBaseline;
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 : x->numReceptor = numReceptor;
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 : x->ampli.length(ampli.size());
188 : for (unsigned int i = 0; i < ampli.size(); i++) {
189 : x->ampli[i].length(ampli.at(i).size());
190 : }
191 :
192 : for (unsigned int i = 0; i < ampli.size() ; i++)
193 : for (unsigned int j = 0; j < ampli.at(i).size(); j++)
194 :
195 :
196 : x->ampli[i][j] = ampli.at(i).at(j);
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 : x->antennaNames.length(antennaNames.size());
210 : for (unsigned int i = 0; i < antennaNames.size(); i++) {
211 : x->antennaNames[i].length(antennaNames.at(i).size());
212 : }
213 :
214 : for (unsigned int i = 0; i < antennaNames.size() ; i++)
215 : for (unsigned int j = 0; j < antennaNames.at(i).size(); j++)
216 :
217 :
218 : x->antennaNames[i][j] = CORBA::string_dup(antennaNames.at(i).at(j).c_str());
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 : x->baselineLengths.length(baselineLengths.size());
232 : for (unsigned int i = 0; i < baselineLengths.size(); ++i) {
233 :
234 : x->baselineLengths[i] = baselineLengths.at(i).toIDLLength();
235 :
236 : }
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 : x->decorrelationFactor.length(decorrelationFactor.size());
247 : for (unsigned int i = 0; i < decorrelationFactor.size(); i++) {
248 : x->decorrelationFactor[i].length(decorrelationFactor.at(i).size());
249 : }
250 :
251 : for (unsigned int i = 0; i < decorrelationFactor.size() ; i++)
252 : for (unsigned int j = 0; j < decorrelationFactor.at(i).size(); j++)
253 :
254 :
255 : x->decorrelationFactor[i][j] = decorrelationFactor.at(i).at(j);
256 :
257 :
258 :
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 : x->direction.length(direction.size());
269 : for (unsigned int i = 0; i < direction.size(); ++i) {
270 :
271 : x->direction[i] = direction.at(i).toIDLAngle();
272 :
273 : }
274 :
275 :
276 :
277 :
278 :
279 :
280 :
281 :
282 :
283 : x->frequencyRange.length(frequencyRange.size());
284 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
285 :
286 : x->frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
287 :
288 : }
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 : x->integrationTime = integrationTime.toIDLInterval();
299 :
300 :
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 : x->phase.length(phase.size());
309 : for (unsigned int i = 0; i < phase.size(); i++) {
310 : x->phase[i].length(phase.at(i).size());
311 : }
312 :
313 : for (unsigned int i = 0; i < phase.size() ; i++)
314 : for (unsigned int j = 0; j < phase.at(i).size(); j++)
315 :
316 :
317 : x->phase[i][j] = phase.at(i).at(j);
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 : x->polarizationTypes.length(polarizationTypes.size());
331 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
332 :
333 :
334 : x->polarizationTypes[i] = polarizationTypes.at(i);
335 :
336 :
337 : }
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 : x->phaseRMS.length(phaseRMS.size());
348 : for (unsigned int i = 0; i < phaseRMS.size(); i++) {
349 : x->phaseRMS[i].length(phaseRMS.at(i).size());
350 : }
351 :
352 : for (unsigned int i = 0; i < phaseRMS.size() ; i++)
353 : for (unsigned int j = 0; j < phaseRMS.at(i).size(); j++)
354 :
355 :
356 : x->phaseRMS[i][j] = phaseRMS.at(i).at(j);
357 :
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 : x->statPhaseRMS.length(statPhaseRMS.size());
370 : for (unsigned int i = 0; i < statPhaseRMS.size(); i++) {
371 : x->statPhaseRMS[i].length(statPhaseRMS.at(i).size());
372 : }
373 :
374 : for (unsigned int i = 0; i < statPhaseRMS.size() ; i++)
375 : for (unsigned int j = 0; j < statPhaseRMS.at(i).size(); j++)
376 :
377 :
378 : x->statPhaseRMS[i][j] = statPhaseRMS.at(i).at(j);
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 : x->correctionValidityExists = correctionValidityExists;
390 :
391 :
392 :
393 : x->correctionValidity.length(correctionValidity.size());
394 : for (unsigned int i = 0; i < correctionValidity.size(); ++i) {
395 :
396 :
397 : x->correctionValidity[i] = correctionValidity.at(i);
398 :
399 :
400 : }
401 :
402 :
403 :
404 :
405 :
406 :
407 :
408 : x->numAntennaExists = numAntennaExists;
409 :
410 :
411 :
412 :
413 : x->numAntenna = numAntenna;
414 :
415 :
416 :
417 :
418 :
419 :
420 :
421 :
422 : x->singleAntennaNameExists = singleAntennaNameExists;
423 :
424 :
425 :
426 : x->singleAntennaName.length(singleAntennaName.size());
427 : for (unsigned int i = 0; i < singleAntennaName.size(); ++i) {
428 :
429 :
430 : x->singleAntennaName[i] = CORBA::string_dup(singleAntennaName.at(i).c_str());
431 :
432 :
433 : }
434 :
435 :
436 :
437 :
438 :
439 :
440 :
441 : x->refAntennaNameExists = refAntennaNameExists;
442 :
443 :
444 :
445 :
446 : x->refAntennaName = CORBA::string_dup(refAntennaName.c_str());
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 :
455 : x->phaseAntExists = phaseAntExists;
456 :
457 :
458 :
459 : x->phaseAnt.length(phaseAnt.size());
460 : for (unsigned int i = 0; i < phaseAnt.size(); i++) {
461 : x->phaseAnt[i].length(phaseAnt.at(i).size());
462 : }
463 :
464 : for (unsigned int i = 0; i < phaseAnt.size() ; i++)
465 : for (unsigned int j = 0; j < phaseAnt.at(i).size(); j++)
466 :
467 :
468 : x->phaseAnt[i][j] = phaseAnt.at(i).at(j);
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 : x->phaseAntRMSExists = phaseAntRMSExists;
480 :
481 :
482 :
483 : x->phaseAntRMS.length(phaseAntRMS.size());
484 : for (unsigned int i = 0; i < phaseAntRMS.size(); i++) {
485 : x->phaseAntRMS[i].length(phaseAntRMS.at(i).size());
486 : }
487 :
488 : for (unsigned int i = 0; i < phaseAntRMS.size() ; i++)
489 : for (unsigned int j = 0; j < phaseAntRMS.at(i).size(); j++)
490 :
491 :
492 : x->phaseAntRMS[i][j] = phaseAntRMS.at(i).at(j);
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 : x->calDataId = calDataId.toIDLTag();
510 :
511 :
512 :
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 : x->calReductionId = calReductionId.toIDLTag();
521 :
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 :
532 : return x;
533 :
534 : }
535 :
536 : void CalPhaseRow::toIDL(asdmIDL::CalPhaseRowIDL& x) const {
537 : // Set the x's fields.
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 :
546 : x.basebandName = basebandName;
547 :
548 :
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 :
558 : x.receiverBand = receiverBand;
559 :
560 :
561 :
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 :
570 : x.atmPhaseCorrection = atmPhaseCorrection;
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 :
581 : x.startValidTime = startValidTime.toIDLArrayTime();
582 :
583 :
584 :
585 :
586 :
587 :
588 :
589 :
590 :
591 : x.endValidTime = endValidTime.toIDLArrayTime();
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 :
601 :
602 : x.numBaseline = numBaseline;
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 :
612 :
613 :
614 : x.numReceptor = numReceptor;
615 :
616 :
617 :
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 : x.ampli.length(ampli.size());
626 : for (unsigned int i = 0; i < ampli.size(); i++) {
627 : x.ampli[i].length(ampli.at(i).size());
628 : }
629 :
630 : for (unsigned int i = 0; i < ampli.size() ; i++)
631 : for (unsigned int j = 0; j < ampli.at(i).size(); j++)
632 :
633 :
634 : x.ampli[i][j] = ampli.at(i).at(j);
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 :
645 :
646 :
647 : x.antennaNames.length(antennaNames.size());
648 : for (unsigned int i = 0; i < antennaNames.size(); i++) {
649 : x.antennaNames[i].length(antennaNames.at(i).size());
650 : }
651 :
652 : for (unsigned int i = 0; i < antennaNames.size() ; i++)
653 : for (unsigned int j = 0; j < antennaNames.at(i).size(); j++)
654 :
655 :
656 : x.antennaNames[i][j] = CORBA::string_dup(antennaNames.at(i).at(j).c_str());
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 : x.baselineLengths.length(baselineLengths.size());
670 : for (unsigned int i = 0; i < baselineLengths.size(); ++i) {
671 :
672 : x.baselineLengths[i] = baselineLengths.at(i).toIDLLength();
673 :
674 : }
675 :
676 :
677 :
678 :
679 :
680 :
681 :
682 :
683 :
684 : x.decorrelationFactor.length(decorrelationFactor.size());
685 : for (unsigned int i = 0; i < decorrelationFactor.size(); i++) {
686 : x.decorrelationFactor[i].length(decorrelationFactor.at(i).size());
687 : }
688 :
689 : for (unsigned int i = 0; i < decorrelationFactor.size() ; i++)
690 : for (unsigned int j = 0; j < decorrelationFactor.at(i).size(); j++)
691 :
692 :
693 : x.decorrelationFactor[i][j] = decorrelationFactor.at(i).at(j);
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 :
703 :
704 :
705 :
706 : x.direction.length(direction.size());
707 : for (unsigned int i = 0; i < direction.size(); ++i) {
708 :
709 : x.direction[i] = direction.at(i).toIDLAngle();
710 :
711 : }
712 :
713 :
714 :
715 :
716 :
717 :
718 :
719 :
720 :
721 : x.frequencyRange.length(frequencyRange.size());
722 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
723 :
724 : x.frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
725 :
726 : }
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 :
735 :
736 : x.integrationTime = integrationTime.toIDLInterval();
737 :
738 :
739 :
740 :
741 :
742 :
743 :
744 :
745 :
746 : x.phase.length(phase.size());
747 : for (unsigned int i = 0; i < phase.size(); i++) {
748 : x.phase[i].length(phase.at(i).size());
749 : }
750 :
751 : for (unsigned int i = 0; i < phase.size() ; i++)
752 : for (unsigned int j = 0; j < phase.at(i).size(); j++)
753 :
754 :
755 : x.phase[i][j] = phase.at(i).at(j);
756 :
757 :
758 :
759 :
760 :
761 :
762 :
763 :
764 :
765 :
766 :
767 :
768 : x.polarizationTypes.length(polarizationTypes.size());
769 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
770 :
771 :
772 : x.polarizationTypes[i] = polarizationTypes.at(i);
773 :
774 :
775 : }
776 :
777 :
778 :
779 :
780 :
781 :
782 :
783 :
784 :
785 : x.phaseRMS.length(phaseRMS.size());
786 : for (unsigned int i = 0; i < phaseRMS.size(); i++) {
787 : x.phaseRMS[i].length(phaseRMS.at(i).size());
788 : }
789 :
790 : for (unsigned int i = 0; i < phaseRMS.size() ; i++)
791 : for (unsigned int j = 0; j < phaseRMS.at(i).size(); j++)
792 :
793 :
794 : x.phaseRMS[i][j] = phaseRMS.at(i).at(j);
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 :
807 : x.statPhaseRMS.length(statPhaseRMS.size());
808 : for (unsigned int i = 0; i < statPhaseRMS.size(); i++) {
809 : x.statPhaseRMS[i].length(statPhaseRMS.at(i).size());
810 : }
811 :
812 : for (unsigned int i = 0; i < statPhaseRMS.size() ; i++)
813 : for (unsigned int j = 0; j < statPhaseRMS.at(i).size(); j++)
814 :
815 :
816 : x.statPhaseRMS[i][j] = statPhaseRMS.at(i).at(j);
817 :
818 :
819 :
820 :
821 :
822 :
823 :
824 :
825 :
826 :
827 : x.correctionValidityExists = correctionValidityExists;
828 :
829 :
830 :
831 : x.correctionValidity.length(correctionValidity.size());
832 : for (unsigned int i = 0; i < correctionValidity.size(); ++i) {
833 :
834 :
835 : x.correctionValidity[i] = correctionValidity.at(i);
836 :
837 :
838 : }
839 :
840 :
841 :
842 :
843 :
844 :
845 :
846 : x.numAntennaExists = numAntennaExists;
847 :
848 :
849 :
850 :
851 : x.numAntenna = numAntenna;
852 :
853 :
854 :
855 :
856 :
857 :
858 :
859 :
860 : x.singleAntennaNameExists = singleAntennaNameExists;
861 :
862 :
863 :
864 : x.singleAntennaName.length(singleAntennaName.size());
865 : for (unsigned int i = 0; i < singleAntennaName.size(); ++i) {
866 :
867 :
868 : x.singleAntennaName[i] = CORBA::string_dup(singleAntennaName.at(i).c_str());
869 :
870 :
871 : }
872 :
873 :
874 :
875 :
876 :
877 :
878 :
879 : x.refAntennaNameExists = refAntennaNameExists;
880 :
881 :
882 :
883 :
884 : x.refAntennaName = CORBA::string_dup(refAntennaName.c_str());
885 :
886 :
887 :
888 :
889 :
890 :
891 :
892 :
893 : x.phaseAntExists = phaseAntExists;
894 :
895 :
896 :
897 : x.phaseAnt.length(phaseAnt.size());
898 : for (unsigned int i = 0; i < phaseAnt.size(); i++) {
899 : x.phaseAnt[i].length(phaseAnt.at(i).size());
900 : }
901 :
902 : for (unsigned int i = 0; i < phaseAnt.size() ; i++)
903 : for (unsigned int j = 0; j < phaseAnt.at(i).size(); j++)
904 :
905 :
906 : x.phaseAnt[i][j] = phaseAnt.at(i).at(j);
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 :
915 :
916 :
917 : x.phaseAntRMSExists = phaseAntRMSExists;
918 :
919 :
920 :
921 : x.phaseAntRMS.length(phaseAntRMS.size());
922 : for (unsigned int i = 0; i < phaseAntRMS.size(); i++) {
923 : x.phaseAntRMS[i].length(phaseAntRMS.at(i).size());
924 : }
925 :
926 : for (unsigned int i = 0; i < phaseAntRMS.size() ; i++)
927 : for (unsigned int j = 0; j < phaseAntRMS.at(i).size(); j++)
928 :
929 :
930 : x.phaseAntRMS[i][j] = phaseAntRMS.at(i).at(j);
931 :
932 :
933 :
934 :
935 :
936 :
937 :
938 :
939 :
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 : x.calDataId = calDataId.toIDLTag();
948 :
949 :
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 :
958 : x.calReductionId = calReductionId.toIDLTag();
959 :
960 :
961 :
962 :
963 :
964 :
965 :
966 :
967 :
968 :
969 :
970 : }
971 : #endif
972 :
973 :
974 : #ifndef WITHOUT_ACS
975 : /**
976 : * Fill the values of this row from the IDL struct CalPhaseRowIDL.
977 : * @param x The IDL struct containing the values used to fill this row.
978 : */
979 : void CalPhaseRow::setFromIDL (CalPhaseRowIDL x){
980 : try {
981 : // Fill the values from x.
982 :
983 :
984 :
985 :
986 :
987 :
988 : setBasebandName(x.basebandName);
989 :
990 :
991 :
992 :
993 :
994 :
995 :
996 :
997 :
998 : setReceiverBand(x.receiverBand);
999 :
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 :
1008 : setAtmPhaseCorrection(x.atmPhaseCorrection);
1009 :
1010 :
1011 :
1012 :
1013 :
1014 :
1015 :
1016 :
1017 :
1018 : setStartValidTime(ArrayTime (x.startValidTime));
1019 :
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 : setEndValidTime(ArrayTime (x.endValidTime));
1029 :
1030 :
1031 :
1032 :
1033 :
1034 :
1035 :
1036 :
1037 :
1038 : setNumBaseline(x.numBaseline);
1039 :
1040 :
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 : setNumReceptor(x.numReceptor);
1049 :
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 :
1057 :
1058 : ampli .clear();
1059 :
1060 : vector<float> v_aux_ampli;
1061 :
1062 : for (unsigned int i = 0; i < x.ampli.length(); ++i) {
1063 : v_aux_ampli.clear();
1064 : for (unsigned int j = 0; j < x.ampli[0].length(); ++j) {
1065 :
1066 : v_aux_ampli.push_back(x.ampli[i][j]);
1067 :
1068 : }
1069 : ampli.push_back(v_aux_ampli);
1070 : }
1071 :
1072 :
1073 :
1074 :
1075 :
1076 :
1077 :
1078 :
1079 :
1080 : antennaNames .clear();
1081 :
1082 : vector<string> v_aux_antennaNames;
1083 :
1084 : for (unsigned int i = 0; i < x.antennaNames.length(); ++i) {
1085 : v_aux_antennaNames.clear();
1086 : for (unsigned int j = 0; j < x.antennaNames[0].length(); ++j) {
1087 :
1088 : v_aux_antennaNames.push_back(string (x.antennaNames[i][j]));
1089 :
1090 : }
1091 : antennaNames.push_back(v_aux_antennaNames);
1092 : }
1093 :
1094 :
1095 :
1096 :
1097 :
1098 :
1099 :
1100 :
1101 :
1102 : baselineLengths .clear();
1103 : for (unsigned int i = 0; i <x.baselineLengths.length(); ++i) {
1104 :
1105 : baselineLengths.push_back(Length (x.baselineLengths[i]));
1106 :
1107 : }
1108 :
1109 :
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 :
1117 : decorrelationFactor .clear();
1118 :
1119 : vector<float> v_aux_decorrelationFactor;
1120 :
1121 : for (unsigned int i = 0; i < x.decorrelationFactor.length(); ++i) {
1122 : v_aux_decorrelationFactor.clear();
1123 : for (unsigned int j = 0; j < x.decorrelationFactor[0].length(); ++j) {
1124 :
1125 : v_aux_decorrelationFactor.push_back(x.decorrelationFactor[i][j]);
1126 :
1127 : }
1128 : decorrelationFactor.push_back(v_aux_decorrelationFactor);
1129 : }
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 : direction .clear();
1140 : for (unsigned int i = 0; i <x.direction.length(); ++i) {
1141 :
1142 : direction.push_back(Angle (x.direction[i]));
1143 :
1144 : }
1145 :
1146 :
1147 :
1148 :
1149 :
1150 :
1151 :
1152 :
1153 :
1154 : frequencyRange .clear();
1155 : for (unsigned int i = 0; i <x.frequencyRange.length(); ++i) {
1156 :
1157 : frequencyRange.push_back(Frequency (x.frequencyRange[i]));
1158 :
1159 : }
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 :
1167 :
1168 :
1169 : setIntegrationTime(Interval (x.integrationTime));
1170 :
1171 :
1172 :
1173 :
1174 :
1175 :
1176 :
1177 :
1178 :
1179 : phase .clear();
1180 :
1181 : vector<float> v_aux_phase;
1182 :
1183 : for (unsigned int i = 0; i < x.phase.length(); ++i) {
1184 : v_aux_phase.clear();
1185 : for (unsigned int j = 0; j < x.phase[0].length(); ++j) {
1186 :
1187 : v_aux_phase.push_back(x.phase[i][j]);
1188 :
1189 : }
1190 : phase.push_back(v_aux_phase);
1191 : }
1192 :
1193 :
1194 :
1195 :
1196 :
1197 :
1198 :
1199 :
1200 :
1201 : polarizationTypes .clear();
1202 : for (unsigned int i = 0; i <x.polarizationTypes.length(); ++i) {
1203 :
1204 : polarizationTypes.push_back(x.polarizationTypes[i]);
1205 :
1206 : }
1207 :
1208 :
1209 :
1210 :
1211 :
1212 :
1213 :
1214 :
1215 :
1216 : phaseRMS .clear();
1217 :
1218 : vector<float> v_aux_phaseRMS;
1219 :
1220 : for (unsigned int i = 0; i < x.phaseRMS.length(); ++i) {
1221 : v_aux_phaseRMS.clear();
1222 : for (unsigned int j = 0; j < x.phaseRMS[0].length(); ++j) {
1223 :
1224 : v_aux_phaseRMS.push_back(x.phaseRMS[i][j]);
1225 :
1226 : }
1227 : phaseRMS.push_back(v_aux_phaseRMS);
1228 : }
1229 :
1230 :
1231 :
1232 :
1233 :
1234 :
1235 :
1236 :
1237 :
1238 : statPhaseRMS .clear();
1239 :
1240 : vector<float> v_aux_statPhaseRMS;
1241 :
1242 : for (unsigned int i = 0; i < x.statPhaseRMS.length(); ++i) {
1243 : v_aux_statPhaseRMS.clear();
1244 : for (unsigned int j = 0; j < x.statPhaseRMS[0].length(); ++j) {
1245 :
1246 : v_aux_statPhaseRMS.push_back(x.statPhaseRMS[i][j]);
1247 :
1248 : }
1249 : statPhaseRMS.push_back(v_aux_statPhaseRMS);
1250 : }
1251 :
1252 :
1253 :
1254 :
1255 :
1256 :
1257 :
1258 : correctionValidityExists = x.correctionValidityExists;
1259 : if (x.correctionValidityExists) {
1260 :
1261 :
1262 :
1263 : correctionValidity .clear();
1264 : for (unsigned int i = 0; i <x.correctionValidity.length(); ++i) {
1265 :
1266 : correctionValidity.push_back(x.correctionValidity[i]);
1267 :
1268 : }
1269 :
1270 :
1271 :
1272 : }
1273 :
1274 :
1275 :
1276 :
1277 :
1278 : numAntennaExists = x.numAntennaExists;
1279 : if (x.numAntennaExists) {
1280 :
1281 :
1282 :
1283 : setNumAntenna(x.numAntenna);
1284 :
1285 :
1286 :
1287 : }
1288 :
1289 :
1290 :
1291 :
1292 :
1293 : singleAntennaNameExists = x.singleAntennaNameExists;
1294 : if (x.singleAntennaNameExists) {
1295 :
1296 :
1297 :
1298 : singleAntennaName .clear();
1299 : for (unsigned int i = 0; i <x.singleAntennaName.length(); ++i) {
1300 :
1301 : singleAntennaName.push_back(string (x.singleAntennaName[i]));
1302 :
1303 : }
1304 :
1305 :
1306 :
1307 : }
1308 :
1309 :
1310 :
1311 :
1312 :
1313 : refAntennaNameExists = x.refAntennaNameExists;
1314 : if (x.refAntennaNameExists) {
1315 :
1316 :
1317 :
1318 : setRefAntennaName(string (x.refAntennaName));
1319 :
1320 :
1321 :
1322 : }
1323 :
1324 :
1325 :
1326 :
1327 :
1328 : phaseAntExists = x.phaseAntExists;
1329 : if (x.phaseAntExists) {
1330 :
1331 :
1332 :
1333 : phaseAnt .clear();
1334 :
1335 : vector<float> v_aux_phaseAnt;
1336 :
1337 : for (unsigned int i = 0; i < x.phaseAnt.length(); ++i) {
1338 : v_aux_phaseAnt.clear();
1339 : for (unsigned int j = 0; j < x.phaseAnt[0].length(); ++j) {
1340 :
1341 : v_aux_phaseAnt.push_back(x.phaseAnt[i][j]);
1342 :
1343 : }
1344 : phaseAnt.push_back(v_aux_phaseAnt);
1345 : }
1346 :
1347 :
1348 :
1349 : }
1350 :
1351 :
1352 :
1353 :
1354 :
1355 : phaseAntRMSExists = x.phaseAntRMSExists;
1356 : if (x.phaseAntRMSExists) {
1357 :
1358 :
1359 :
1360 : phaseAntRMS .clear();
1361 :
1362 : vector<float> v_aux_phaseAntRMS;
1363 :
1364 : for (unsigned int i = 0; i < x.phaseAntRMS.length(); ++i) {
1365 : v_aux_phaseAntRMS.clear();
1366 : for (unsigned int j = 0; j < x.phaseAntRMS[0].length(); ++j) {
1367 :
1368 : v_aux_phaseAntRMS.push_back(x.phaseAntRMS[i][j]);
1369 :
1370 : }
1371 : phaseAntRMS.push_back(v_aux_phaseAntRMS);
1372 : }
1373 :
1374 :
1375 :
1376 : }
1377 :
1378 :
1379 :
1380 :
1381 :
1382 :
1383 :
1384 :
1385 :
1386 :
1387 : setCalDataId(Tag (x.calDataId));
1388 :
1389 :
1390 :
1391 :
1392 :
1393 :
1394 :
1395 :
1396 :
1397 : setCalReductionId(Tag (x.calReductionId));
1398 :
1399 :
1400 :
1401 :
1402 :
1403 :
1404 :
1405 :
1406 :
1407 :
1408 :
1409 : } catch (const IllegalAccessException &err) {
1410 : throw ConversionException (err.getMessage(),"CalPhase");
1411 : }
1412 : }
1413 : #endif
1414 :
1415 : /**
1416 : * Return this row in the form of an XML string.
1417 : * @return The values of this row as an XML string.
1418 : */
1419 0 : string CalPhaseRow::toXML() const {
1420 0 : string buf;
1421 0 : buf.append("<row> \n");
1422 :
1423 :
1424 :
1425 :
1426 :
1427 :
1428 0 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
1429 :
1430 :
1431 :
1432 :
1433 :
1434 :
1435 :
1436 0 : buf.append(EnumerationParser::toXML("receiverBand", receiverBand));
1437 :
1438 :
1439 :
1440 :
1441 :
1442 :
1443 :
1444 0 : buf.append(EnumerationParser::toXML("atmPhaseCorrection", atmPhaseCorrection));
1445 :
1446 :
1447 :
1448 :
1449 :
1450 :
1451 :
1452 0 : Parser::toXML(startValidTime, "startValidTime", buf);
1453 :
1454 :
1455 :
1456 :
1457 :
1458 :
1459 :
1460 0 : Parser::toXML(endValidTime, "endValidTime", buf);
1461 :
1462 :
1463 :
1464 :
1465 :
1466 :
1467 :
1468 0 : Parser::toXML(numBaseline, "numBaseline", buf);
1469 :
1470 :
1471 :
1472 :
1473 :
1474 :
1475 :
1476 0 : Parser::toXML(numReceptor, "numReceptor", buf);
1477 :
1478 :
1479 :
1480 :
1481 :
1482 :
1483 :
1484 0 : Parser::toXML(ampli, "ampli", buf);
1485 :
1486 :
1487 :
1488 :
1489 :
1490 :
1491 :
1492 0 : Parser::toXML(antennaNames, "antennaNames", buf);
1493 :
1494 :
1495 :
1496 :
1497 :
1498 :
1499 :
1500 0 : Parser::toXML(baselineLengths, "baselineLengths", buf);
1501 :
1502 :
1503 :
1504 :
1505 :
1506 :
1507 :
1508 0 : Parser::toXML(decorrelationFactor, "decorrelationFactor", buf);
1509 :
1510 :
1511 :
1512 :
1513 :
1514 :
1515 :
1516 0 : Parser::toXML(direction, "direction", buf);
1517 :
1518 :
1519 :
1520 :
1521 :
1522 :
1523 :
1524 0 : Parser::toXML(frequencyRange, "frequencyRange", buf);
1525 :
1526 :
1527 :
1528 :
1529 :
1530 :
1531 :
1532 0 : Parser::toXML(integrationTime, "integrationTime", buf);
1533 :
1534 :
1535 :
1536 :
1537 :
1538 :
1539 :
1540 0 : Parser::toXML(phase, "phase", buf);
1541 :
1542 :
1543 :
1544 :
1545 :
1546 :
1547 :
1548 0 : buf.append(EnumerationParser::toXML("polarizationTypes", polarizationTypes));
1549 :
1550 :
1551 :
1552 :
1553 :
1554 :
1555 :
1556 0 : Parser::toXML(phaseRMS, "phaseRMS", buf);
1557 :
1558 :
1559 :
1560 :
1561 :
1562 :
1563 :
1564 0 : Parser::toXML(statPhaseRMS, "statPhaseRMS", buf);
1565 :
1566 :
1567 :
1568 :
1569 :
1570 :
1571 0 : if (correctionValidityExists) {
1572 :
1573 :
1574 0 : Parser::toXML(correctionValidity, "correctionValidity", buf);
1575 :
1576 :
1577 : }
1578 :
1579 :
1580 :
1581 :
1582 :
1583 0 : if (numAntennaExists) {
1584 :
1585 :
1586 0 : Parser::toXML(numAntenna, "numAntenna", buf);
1587 :
1588 :
1589 : }
1590 :
1591 :
1592 :
1593 :
1594 :
1595 0 : if (singleAntennaNameExists) {
1596 :
1597 :
1598 0 : Parser::toXML(singleAntennaName, "singleAntennaName", buf);
1599 :
1600 :
1601 : }
1602 :
1603 :
1604 :
1605 :
1606 :
1607 0 : if (refAntennaNameExists) {
1608 :
1609 :
1610 0 : Parser::toXML(refAntennaName, "refAntennaName", buf);
1611 :
1612 :
1613 : }
1614 :
1615 :
1616 :
1617 :
1618 :
1619 0 : if (phaseAntExists) {
1620 :
1621 :
1622 0 : Parser::toXML(phaseAnt, "phaseAnt", buf);
1623 :
1624 :
1625 : }
1626 :
1627 :
1628 :
1629 :
1630 :
1631 0 : if (phaseAntRMSExists) {
1632 :
1633 :
1634 0 : Parser::toXML(phaseAntRMS, "phaseAntRMS", buf);
1635 :
1636 :
1637 : }
1638 :
1639 :
1640 :
1641 :
1642 :
1643 :
1644 :
1645 :
1646 :
1647 0 : Parser::toXML(calDataId, "calDataId", buf);
1648 :
1649 :
1650 :
1651 :
1652 :
1653 :
1654 :
1655 0 : Parser::toXML(calReductionId, "calReductionId", buf);
1656 :
1657 :
1658 :
1659 :
1660 :
1661 :
1662 :
1663 :
1664 :
1665 :
1666 :
1667 0 : buf.append("</row>\n");
1668 0 : return buf;
1669 0 : }
1670 :
1671 : /**
1672 : * Fill the values of this row from an XML string
1673 : * that was produced by the toXML() method.
1674 : * @param x The XML string being used to set the values of this row.
1675 : */
1676 0 : void CalPhaseRow::setFromXML (string rowDoc) {
1677 0 : Parser row(rowDoc);
1678 0 : string s = "";
1679 : try {
1680 :
1681 :
1682 :
1683 :
1684 :
1685 :
1686 0 : basebandName = EnumerationParser::getBasebandName("basebandName","CalPhase",rowDoc);
1687 :
1688 :
1689 :
1690 :
1691 :
1692 :
1693 :
1694 :
1695 :
1696 0 : receiverBand = EnumerationParser::getReceiverBand("receiverBand","CalPhase",rowDoc);
1697 :
1698 :
1699 :
1700 :
1701 :
1702 :
1703 :
1704 :
1705 :
1706 0 : atmPhaseCorrection = EnumerationParser::getAtmPhaseCorrection("atmPhaseCorrection","CalPhase",rowDoc);
1707 :
1708 :
1709 :
1710 :
1711 :
1712 :
1713 :
1714 :
1715 0 : setStartValidTime(Parser::getArrayTime("startValidTime","CalPhase",rowDoc));
1716 :
1717 :
1718 :
1719 :
1720 :
1721 :
1722 :
1723 0 : setEndValidTime(Parser::getArrayTime("endValidTime","CalPhase",rowDoc));
1724 :
1725 :
1726 :
1727 :
1728 :
1729 :
1730 :
1731 0 : setNumBaseline(Parser::getInteger("numBaseline","CalPhase",rowDoc));
1732 :
1733 :
1734 :
1735 :
1736 :
1737 :
1738 :
1739 0 : setNumReceptor(Parser::getInteger("numReceptor","CalPhase",rowDoc));
1740 :
1741 :
1742 :
1743 :
1744 :
1745 :
1746 :
1747 :
1748 0 : setAmpli(Parser::get2DFloat("ampli","CalPhase",rowDoc));
1749 :
1750 :
1751 :
1752 :
1753 :
1754 :
1755 :
1756 :
1757 :
1758 0 : setAntennaNames(Parser::get2DString("antennaNames","CalPhase",rowDoc));
1759 :
1760 :
1761 :
1762 :
1763 :
1764 :
1765 :
1766 :
1767 :
1768 0 : setBaselineLengths(Parser::get1DLength("baselineLengths","CalPhase",rowDoc));
1769 :
1770 :
1771 :
1772 :
1773 :
1774 :
1775 :
1776 :
1777 :
1778 0 : setDecorrelationFactor(Parser::get2DFloat("decorrelationFactor","CalPhase",rowDoc));
1779 :
1780 :
1781 :
1782 :
1783 :
1784 :
1785 :
1786 :
1787 :
1788 0 : setDirection(Parser::get1DAngle("direction","CalPhase",rowDoc));
1789 :
1790 :
1791 :
1792 :
1793 :
1794 :
1795 :
1796 :
1797 :
1798 0 : setFrequencyRange(Parser::get1DFrequency("frequencyRange","CalPhase",rowDoc));
1799 :
1800 :
1801 :
1802 :
1803 :
1804 :
1805 :
1806 :
1807 0 : setIntegrationTime(Parser::getInterval("integrationTime","CalPhase",rowDoc));
1808 :
1809 :
1810 :
1811 :
1812 :
1813 :
1814 :
1815 :
1816 0 : setPhase(Parser::get2DFloat("phase","CalPhase",rowDoc));
1817 :
1818 :
1819 :
1820 :
1821 :
1822 :
1823 :
1824 :
1825 :
1826 0 : polarizationTypes = EnumerationParser::getPolarizationType1D("polarizationTypes","CalPhase",rowDoc);
1827 :
1828 :
1829 :
1830 :
1831 :
1832 :
1833 :
1834 :
1835 :
1836 0 : setPhaseRMS(Parser::get2DFloat("phaseRMS","CalPhase",rowDoc));
1837 :
1838 :
1839 :
1840 :
1841 :
1842 :
1843 :
1844 :
1845 :
1846 0 : setStatPhaseRMS(Parser::get2DFloat("statPhaseRMS","CalPhase",rowDoc));
1847 :
1848 :
1849 :
1850 :
1851 :
1852 :
1853 :
1854 0 : if (row.isStr("<correctionValidity>")) {
1855 :
1856 :
1857 0 : setCorrectionValidity(Parser::get1DBoolean("correctionValidity","CalPhase",rowDoc));
1858 :
1859 :
1860 : }
1861 :
1862 :
1863 :
1864 :
1865 :
1866 0 : if (row.isStr("<numAntenna>")) {
1867 :
1868 0 : setNumAntenna(Parser::getInteger("numAntenna","CalPhase",rowDoc));
1869 :
1870 : }
1871 :
1872 :
1873 :
1874 :
1875 :
1876 0 : if (row.isStr("<singleAntennaName>")) {
1877 :
1878 :
1879 0 : setSingleAntennaName(Parser::get1DString("singleAntennaName","CalPhase",rowDoc));
1880 :
1881 :
1882 : }
1883 :
1884 :
1885 :
1886 :
1887 :
1888 0 : if (row.isStr("<refAntennaName>")) {
1889 :
1890 0 : setRefAntennaName(Parser::getString("refAntennaName","CalPhase",rowDoc));
1891 :
1892 : }
1893 :
1894 :
1895 :
1896 :
1897 :
1898 0 : if (row.isStr("<phaseAnt>")) {
1899 :
1900 :
1901 0 : setPhaseAnt(Parser::get2DFloat("phaseAnt","CalPhase",rowDoc));
1902 :
1903 :
1904 : }
1905 :
1906 :
1907 :
1908 :
1909 :
1910 0 : if (row.isStr("<phaseAntRMS>")) {
1911 :
1912 :
1913 0 : setPhaseAntRMS(Parser::get2DFloat("phaseAntRMS","CalPhase",rowDoc));
1914 :
1915 :
1916 : }
1917 :
1918 :
1919 :
1920 :
1921 :
1922 :
1923 :
1924 :
1925 :
1926 0 : setCalDataId(Parser::getTag("calDataId","CalData",rowDoc));
1927 :
1928 :
1929 :
1930 :
1931 :
1932 :
1933 :
1934 0 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
1935 :
1936 :
1937 :
1938 :
1939 :
1940 :
1941 :
1942 :
1943 :
1944 :
1945 0 : } catch (const IllegalAccessException &err) {
1946 0 : throw ConversionException (err.getMessage(),"CalPhase");
1947 0 : }
1948 0 : }
1949 :
1950 0 : void CalPhaseRow::toBin(EndianOSStream& eoss) {
1951 :
1952 :
1953 :
1954 :
1955 :
1956 :
1957 0 : eoss.writeString(CBasebandName::name(basebandName));
1958 : /* eoss.writeInt(basebandName); */
1959 :
1960 :
1961 :
1962 :
1963 :
1964 :
1965 :
1966 :
1967 0 : eoss.writeString(CReceiverBand::name(receiverBand));
1968 : /* eoss.writeInt(receiverBand); */
1969 :
1970 :
1971 :
1972 :
1973 :
1974 :
1975 :
1976 :
1977 0 : eoss.writeString(CAtmPhaseCorrection::name(atmPhaseCorrection));
1978 : /* eoss.writeInt(atmPhaseCorrection); */
1979 :
1980 :
1981 :
1982 :
1983 :
1984 :
1985 :
1986 0 : calDataId.toBin(eoss);
1987 :
1988 :
1989 :
1990 :
1991 :
1992 :
1993 0 : calReductionId.toBin(eoss);
1994 :
1995 :
1996 :
1997 :
1998 :
1999 :
2000 0 : startValidTime.toBin(eoss);
2001 :
2002 :
2003 :
2004 :
2005 :
2006 :
2007 0 : endValidTime.toBin(eoss);
2008 :
2009 :
2010 :
2011 :
2012 :
2013 :
2014 :
2015 0 : eoss.writeInt(numBaseline);
2016 :
2017 :
2018 :
2019 :
2020 :
2021 :
2022 :
2023 :
2024 0 : eoss.writeInt(numReceptor);
2025 :
2026 :
2027 :
2028 :
2029 :
2030 :
2031 :
2032 :
2033 :
2034 0 : eoss.writeInt((int) ampli.size());
2035 0 : eoss.writeInt((int) ampli.at(0).size());
2036 0 : for (unsigned int i = 0; i < ampli.size(); i++)
2037 0 : for (unsigned int j = 0; j < ampli.at(0).size(); j++)
2038 :
2039 0 : eoss.writeFloat(ampli.at(i).at(j));
2040 :
2041 :
2042 :
2043 :
2044 :
2045 :
2046 :
2047 :
2048 :
2049 :
2050 :
2051 0 : eoss.writeInt((int) antennaNames.size());
2052 0 : eoss.writeInt((int) antennaNames.at(0).size());
2053 0 : for (unsigned int i = 0; i < antennaNames.size(); i++)
2054 0 : for (unsigned int j = 0; j < antennaNames.at(0).size(); j++)
2055 :
2056 0 : eoss.writeString(antennaNames.at(i).at(j));
2057 :
2058 :
2059 :
2060 :
2061 :
2062 :
2063 :
2064 :
2065 :
2066 0 : Length::toBin(baselineLengths, eoss);
2067 :
2068 :
2069 :
2070 :
2071 :
2072 :
2073 :
2074 :
2075 0 : eoss.writeInt((int) decorrelationFactor.size());
2076 0 : eoss.writeInt((int) decorrelationFactor.at(0).size());
2077 0 : for (unsigned int i = 0; i < decorrelationFactor.size(); i++)
2078 0 : for (unsigned int j = 0; j < decorrelationFactor.at(0).size(); j++)
2079 :
2080 0 : eoss.writeFloat(decorrelationFactor.at(i).at(j));
2081 :
2082 :
2083 :
2084 :
2085 :
2086 :
2087 :
2088 :
2089 :
2090 0 : Angle::toBin(direction, eoss);
2091 :
2092 :
2093 :
2094 :
2095 :
2096 :
2097 0 : Frequency::toBin(frequencyRange, eoss);
2098 :
2099 :
2100 :
2101 :
2102 :
2103 :
2104 0 : integrationTime.toBin(eoss);
2105 :
2106 :
2107 :
2108 :
2109 :
2110 :
2111 :
2112 :
2113 0 : eoss.writeInt((int) phase.size());
2114 0 : eoss.writeInt((int) phase.at(0).size());
2115 0 : for (unsigned int i = 0; i < phase.size(); i++)
2116 0 : for (unsigned int j = 0; j < phase.at(0).size(); j++)
2117 :
2118 0 : eoss.writeFloat(phase.at(i).at(j));
2119 :
2120 :
2121 :
2122 :
2123 :
2124 :
2125 :
2126 :
2127 :
2128 :
2129 :
2130 0 : eoss.writeInt((int) polarizationTypes.size());
2131 0 : for (unsigned int i = 0; i < polarizationTypes.size(); i++)
2132 :
2133 0 : eoss.writeString(CPolarizationType::name(polarizationTypes.at(i)));
2134 : /* eoss.writeInt(polarizationTypes.at(i)); */
2135 :
2136 :
2137 :
2138 :
2139 :
2140 :
2141 :
2142 :
2143 :
2144 :
2145 :
2146 0 : eoss.writeInt((int) phaseRMS.size());
2147 0 : eoss.writeInt((int) phaseRMS.at(0).size());
2148 0 : for (unsigned int i = 0; i < phaseRMS.size(); i++)
2149 0 : for (unsigned int j = 0; j < phaseRMS.at(0).size(); j++)
2150 :
2151 0 : eoss.writeFloat(phaseRMS.at(i).at(j));
2152 :
2153 :
2154 :
2155 :
2156 :
2157 :
2158 :
2159 :
2160 :
2161 :
2162 :
2163 0 : eoss.writeInt((int) statPhaseRMS.size());
2164 0 : eoss.writeInt((int) statPhaseRMS.at(0).size());
2165 0 : for (unsigned int i = 0; i < statPhaseRMS.size(); i++)
2166 0 : for (unsigned int j = 0; j < statPhaseRMS.at(0).size(); j++)
2167 :
2168 0 : eoss.writeFloat(statPhaseRMS.at(i).at(j));
2169 :
2170 :
2171 :
2172 :
2173 :
2174 :
2175 :
2176 :
2177 :
2178 0 : eoss.writeBoolean(correctionValidityExists);
2179 0 : if (correctionValidityExists) {
2180 :
2181 :
2182 :
2183 :
2184 :
2185 :
2186 0 : eoss.writeInt((int) correctionValidity.size());
2187 0 : for (unsigned int i = 0; i < correctionValidity.size(); i++)
2188 :
2189 0 : eoss.writeBoolean(correctionValidity.at(i));
2190 :
2191 :
2192 :
2193 :
2194 :
2195 :
2196 : }
2197 :
2198 0 : eoss.writeBoolean(numAntennaExists);
2199 0 : if (numAntennaExists) {
2200 :
2201 :
2202 :
2203 :
2204 :
2205 0 : eoss.writeInt(numAntenna);
2206 :
2207 :
2208 :
2209 :
2210 : }
2211 :
2212 0 : eoss.writeBoolean(singleAntennaNameExists);
2213 0 : if (singleAntennaNameExists) {
2214 :
2215 :
2216 :
2217 :
2218 :
2219 :
2220 0 : eoss.writeInt((int) singleAntennaName.size());
2221 0 : for (unsigned int i = 0; i < singleAntennaName.size(); i++)
2222 :
2223 0 : eoss.writeString(singleAntennaName.at(i));
2224 :
2225 :
2226 :
2227 :
2228 :
2229 :
2230 : }
2231 :
2232 0 : eoss.writeBoolean(refAntennaNameExists);
2233 0 : if (refAntennaNameExists) {
2234 :
2235 :
2236 :
2237 :
2238 :
2239 0 : eoss.writeString(refAntennaName);
2240 :
2241 :
2242 :
2243 :
2244 : }
2245 :
2246 0 : eoss.writeBoolean(phaseAntExists);
2247 0 : if (phaseAntExists) {
2248 :
2249 :
2250 :
2251 :
2252 :
2253 :
2254 0 : eoss.writeInt((int) phaseAnt.size());
2255 0 : eoss.writeInt((int) phaseAnt.at(0).size());
2256 0 : for (unsigned int i = 0; i < phaseAnt.size(); i++)
2257 0 : for (unsigned int j = 0; j < phaseAnt.at(0).size(); j++)
2258 :
2259 0 : eoss.writeFloat(phaseAnt.at(i).at(j));
2260 :
2261 :
2262 :
2263 :
2264 :
2265 :
2266 : }
2267 :
2268 0 : eoss.writeBoolean(phaseAntRMSExists);
2269 0 : if (phaseAntRMSExists) {
2270 :
2271 :
2272 :
2273 :
2274 :
2275 :
2276 0 : eoss.writeInt((int) phaseAntRMS.size());
2277 0 : eoss.writeInt((int) phaseAntRMS.at(0).size());
2278 0 : for (unsigned int i = 0; i < phaseAntRMS.size(); i++)
2279 0 : for (unsigned int j = 0; j < phaseAntRMS.at(0).size(); j++)
2280 :
2281 0 : eoss.writeFloat(phaseAntRMS.at(i).at(j));
2282 :
2283 :
2284 :
2285 :
2286 :
2287 :
2288 : }
2289 :
2290 0 : }
2291 :
2292 0 : void CalPhaseRow::basebandNameFromBin(EndianIStream& eis) {
2293 :
2294 :
2295 :
2296 :
2297 :
2298 0 : basebandName = CBasebandName::literal(eis.readString());
2299 :
2300 :
2301 :
2302 :
2303 0 : }
2304 0 : void CalPhaseRow::receiverBandFromBin(EndianIStream& eis) {
2305 :
2306 :
2307 :
2308 :
2309 :
2310 0 : receiverBand = CReceiverBand::literal(eis.readString());
2311 :
2312 :
2313 :
2314 :
2315 0 : }
2316 0 : void CalPhaseRow::atmPhaseCorrectionFromBin(EndianIStream& eis) {
2317 :
2318 :
2319 :
2320 :
2321 :
2322 0 : atmPhaseCorrection = CAtmPhaseCorrection::literal(eis.readString());
2323 :
2324 :
2325 :
2326 :
2327 0 : }
2328 0 : void CalPhaseRow::calDataIdFromBin(EndianIStream& eis) {
2329 :
2330 :
2331 :
2332 :
2333 0 : calDataId = Tag::fromBin(eis);
2334 :
2335 :
2336 :
2337 0 : }
2338 0 : void CalPhaseRow::calReductionIdFromBin(EndianIStream& eis) {
2339 :
2340 :
2341 :
2342 :
2343 0 : calReductionId = Tag::fromBin(eis);
2344 :
2345 :
2346 :
2347 0 : }
2348 0 : void CalPhaseRow::startValidTimeFromBin(EndianIStream& eis) {
2349 :
2350 :
2351 :
2352 :
2353 0 : startValidTime = ArrayTime::fromBin(eis);
2354 :
2355 :
2356 :
2357 0 : }
2358 0 : void CalPhaseRow::endValidTimeFromBin(EndianIStream& eis) {
2359 :
2360 :
2361 :
2362 :
2363 0 : endValidTime = ArrayTime::fromBin(eis);
2364 :
2365 :
2366 :
2367 0 : }
2368 0 : void CalPhaseRow::numBaselineFromBin(EndianIStream& eis) {
2369 :
2370 :
2371 :
2372 :
2373 :
2374 0 : numBaseline = eis.readInt();
2375 :
2376 :
2377 :
2378 :
2379 0 : }
2380 0 : void CalPhaseRow::numReceptorFromBin(EndianIStream& eis) {
2381 :
2382 :
2383 :
2384 :
2385 :
2386 0 : numReceptor = eis.readInt();
2387 :
2388 :
2389 :
2390 :
2391 0 : }
2392 0 : void CalPhaseRow::ampliFromBin(EndianIStream& eis) {
2393 :
2394 :
2395 :
2396 :
2397 :
2398 :
2399 0 : ampli.clear();
2400 :
2401 0 : unsigned int ampliDim1 = eis.readInt();
2402 0 : unsigned int ampliDim2 = eis.readInt();
2403 :
2404 0 : vector <float> ampliAux1;
2405 :
2406 0 : for (unsigned int i = 0; i < ampliDim1; i++) {
2407 0 : ampliAux1.clear();
2408 0 : for (unsigned int j = 0; j < ampliDim2 ; j++)
2409 :
2410 0 : ampliAux1.push_back(eis.readFloat());
2411 :
2412 0 : ampli.push_back(ampliAux1);
2413 : }
2414 :
2415 :
2416 :
2417 :
2418 :
2419 :
2420 0 : }
2421 0 : void CalPhaseRow::antennaNamesFromBin(EndianIStream& eis) {
2422 :
2423 :
2424 :
2425 :
2426 :
2427 :
2428 0 : antennaNames.clear();
2429 :
2430 0 : unsigned int antennaNamesDim1 = eis.readInt();
2431 0 : unsigned int antennaNamesDim2 = eis.readInt();
2432 :
2433 0 : vector <string> antennaNamesAux1;
2434 :
2435 0 : for (unsigned int i = 0; i < antennaNamesDim1; i++) {
2436 0 : antennaNamesAux1.clear();
2437 0 : for (unsigned int j = 0; j < antennaNamesDim2 ; j++)
2438 :
2439 0 : antennaNamesAux1.push_back(eis.readString());
2440 :
2441 0 : antennaNames.push_back(antennaNamesAux1);
2442 : }
2443 :
2444 :
2445 :
2446 :
2447 :
2448 :
2449 0 : }
2450 0 : void CalPhaseRow::baselineLengthsFromBin(EndianIStream& eis) {
2451 :
2452 :
2453 :
2454 :
2455 :
2456 :
2457 0 : baselineLengths = Length::from1DBin(eis);
2458 :
2459 :
2460 :
2461 :
2462 :
2463 0 : }
2464 0 : void CalPhaseRow::decorrelationFactorFromBin(EndianIStream& eis) {
2465 :
2466 :
2467 :
2468 :
2469 :
2470 :
2471 0 : decorrelationFactor.clear();
2472 :
2473 0 : unsigned int decorrelationFactorDim1 = eis.readInt();
2474 0 : unsigned int decorrelationFactorDim2 = eis.readInt();
2475 :
2476 0 : vector <float> decorrelationFactorAux1;
2477 :
2478 0 : for (unsigned int i = 0; i < decorrelationFactorDim1; i++) {
2479 0 : decorrelationFactorAux1.clear();
2480 0 : for (unsigned int j = 0; j < decorrelationFactorDim2 ; j++)
2481 :
2482 0 : decorrelationFactorAux1.push_back(eis.readFloat());
2483 :
2484 0 : decorrelationFactor.push_back(decorrelationFactorAux1);
2485 : }
2486 :
2487 :
2488 :
2489 :
2490 :
2491 :
2492 0 : }
2493 0 : void CalPhaseRow::directionFromBin(EndianIStream& eis) {
2494 :
2495 :
2496 :
2497 :
2498 :
2499 :
2500 0 : direction = Angle::from1DBin(eis);
2501 :
2502 :
2503 :
2504 :
2505 :
2506 0 : }
2507 0 : void CalPhaseRow::frequencyRangeFromBin(EndianIStream& eis) {
2508 :
2509 :
2510 :
2511 :
2512 :
2513 :
2514 0 : frequencyRange = Frequency::from1DBin(eis);
2515 :
2516 :
2517 :
2518 :
2519 :
2520 0 : }
2521 0 : void CalPhaseRow::integrationTimeFromBin(EndianIStream& eis) {
2522 :
2523 :
2524 :
2525 :
2526 0 : integrationTime = Interval::fromBin(eis);
2527 :
2528 :
2529 :
2530 0 : }
2531 0 : void CalPhaseRow::phaseFromBin(EndianIStream& eis) {
2532 :
2533 :
2534 :
2535 :
2536 :
2537 :
2538 0 : phase.clear();
2539 :
2540 0 : unsigned int phaseDim1 = eis.readInt();
2541 0 : unsigned int phaseDim2 = eis.readInt();
2542 :
2543 0 : vector <float> phaseAux1;
2544 :
2545 0 : for (unsigned int i = 0; i < phaseDim1; i++) {
2546 0 : phaseAux1.clear();
2547 0 : for (unsigned int j = 0; j < phaseDim2 ; j++)
2548 :
2549 0 : phaseAux1.push_back(eis.readFloat());
2550 :
2551 0 : phase.push_back(phaseAux1);
2552 : }
2553 :
2554 :
2555 :
2556 :
2557 :
2558 :
2559 0 : }
2560 0 : void CalPhaseRow::polarizationTypesFromBin(EndianIStream& eis) {
2561 :
2562 :
2563 :
2564 :
2565 :
2566 :
2567 0 : polarizationTypes.clear();
2568 :
2569 0 : unsigned int polarizationTypesDim1 = eis.readInt();
2570 0 : for (unsigned int i = 0 ; i < polarizationTypesDim1; i++)
2571 :
2572 0 : polarizationTypes.push_back(CPolarizationType::literal(eis.readString()));
2573 :
2574 :
2575 :
2576 :
2577 :
2578 :
2579 0 : }
2580 0 : void CalPhaseRow::phaseRMSFromBin(EndianIStream& eis) {
2581 :
2582 :
2583 :
2584 :
2585 :
2586 :
2587 0 : phaseRMS.clear();
2588 :
2589 0 : unsigned int phaseRMSDim1 = eis.readInt();
2590 0 : unsigned int phaseRMSDim2 = eis.readInt();
2591 :
2592 0 : vector <float> phaseRMSAux1;
2593 :
2594 0 : for (unsigned int i = 0; i < phaseRMSDim1; i++) {
2595 0 : phaseRMSAux1.clear();
2596 0 : for (unsigned int j = 0; j < phaseRMSDim2 ; j++)
2597 :
2598 0 : phaseRMSAux1.push_back(eis.readFloat());
2599 :
2600 0 : phaseRMS.push_back(phaseRMSAux1);
2601 : }
2602 :
2603 :
2604 :
2605 :
2606 :
2607 :
2608 0 : }
2609 0 : void CalPhaseRow::statPhaseRMSFromBin(EndianIStream& eis) {
2610 :
2611 :
2612 :
2613 :
2614 :
2615 :
2616 0 : statPhaseRMS.clear();
2617 :
2618 0 : unsigned int statPhaseRMSDim1 = eis.readInt();
2619 0 : unsigned int statPhaseRMSDim2 = eis.readInt();
2620 :
2621 0 : vector <float> statPhaseRMSAux1;
2622 :
2623 0 : for (unsigned int i = 0; i < statPhaseRMSDim1; i++) {
2624 0 : statPhaseRMSAux1.clear();
2625 0 : for (unsigned int j = 0; j < statPhaseRMSDim2 ; j++)
2626 :
2627 0 : statPhaseRMSAux1.push_back(eis.readFloat());
2628 :
2629 0 : statPhaseRMS.push_back(statPhaseRMSAux1);
2630 : }
2631 :
2632 :
2633 :
2634 :
2635 :
2636 :
2637 0 : }
2638 :
2639 0 : void CalPhaseRow::correctionValidityFromBin(EndianIStream& eis) {
2640 :
2641 0 : correctionValidityExists = eis.readBoolean();
2642 0 : if (correctionValidityExists) {
2643 :
2644 :
2645 :
2646 :
2647 :
2648 :
2649 0 : correctionValidity.clear();
2650 :
2651 0 : unsigned int correctionValidityDim1 = eis.readInt();
2652 0 : for (unsigned int i = 0 ; i < correctionValidityDim1; i++)
2653 :
2654 0 : correctionValidity.push_back(eis.readBoolean());
2655 :
2656 :
2657 :
2658 :
2659 :
2660 :
2661 : }
2662 :
2663 0 : }
2664 0 : void CalPhaseRow::numAntennaFromBin(EndianIStream& eis) {
2665 :
2666 0 : numAntennaExists = eis.readBoolean();
2667 0 : if (numAntennaExists) {
2668 :
2669 :
2670 :
2671 :
2672 :
2673 0 : numAntenna = eis.readInt();
2674 :
2675 :
2676 :
2677 :
2678 : }
2679 :
2680 0 : }
2681 0 : void CalPhaseRow::singleAntennaNameFromBin(EndianIStream& eis) {
2682 :
2683 0 : singleAntennaNameExists = eis.readBoolean();
2684 0 : if (singleAntennaNameExists) {
2685 :
2686 :
2687 :
2688 :
2689 :
2690 :
2691 0 : singleAntennaName.clear();
2692 :
2693 0 : unsigned int singleAntennaNameDim1 = eis.readInt();
2694 0 : for (unsigned int i = 0 ; i < singleAntennaNameDim1; i++)
2695 :
2696 0 : singleAntennaName.push_back(eis.readString());
2697 :
2698 :
2699 :
2700 :
2701 :
2702 :
2703 : }
2704 :
2705 0 : }
2706 0 : void CalPhaseRow::refAntennaNameFromBin(EndianIStream& eis) {
2707 :
2708 0 : refAntennaNameExists = eis.readBoolean();
2709 0 : if (refAntennaNameExists) {
2710 :
2711 :
2712 :
2713 :
2714 :
2715 0 : refAntennaName = eis.readString();
2716 :
2717 :
2718 :
2719 :
2720 : }
2721 :
2722 0 : }
2723 0 : void CalPhaseRow::phaseAntFromBin(EndianIStream& eis) {
2724 :
2725 0 : phaseAntExists = eis.readBoolean();
2726 0 : if (phaseAntExists) {
2727 :
2728 :
2729 :
2730 :
2731 :
2732 :
2733 0 : phaseAnt.clear();
2734 :
2735 0 : unsigned int phaseAntDim1 = eis.readInt();
2736 0 : unsigned int phaseAntDim2 = eis.readInt();
2737 :
2738 0 : vector <float> phaseAntAux1;
2739 :
2740 0 : for (unsigned int i = 0; i < phaseAntDim1; i++) {
2741 0 : phaseAntAux1.clear();
2742 0 : for (unsigned int j = 0; j < phaseAntDim2 ; j++)
2743 :
2744 0 : phaseAntAux1.push_back(eis.readFloat());
2745 :
2746 0 : phaseAnt.push_back(phaseAntAux1);
2747 : }
2748 :
2749 :
2750 :
2751 :
2752 :
2753 :
2754 0 : }
2755 :
2756 0 : }
2757 0 : void CalPhaseRow::phaseAntRMSFromBin(EndianIStream& eis) {
2758 :
2759 0 : phaseAntRMSExists = eis.readBoolean();
2760 0 : if (phaseAntRMSExists) {
2761 :
2762 :
2763 :
2764 :
2765 :
2766 :
2767 0 : phaseAntRMS.clear();
2768 :
2769 0 : unsigned int phaseAntRMSDim1 = eis.readInt();
2770 0 : unsigned int phaseAntRMSDim2 = eis.readInt();
2771 :
2772 0 : vector <float> phaseAntRMSAux1;
2773 :
2774 0 : for (unsigned int i = 0; i < phaseAntRMSDim1; i++) {
2775 0 : phaseAntRMSAux1.clear();
2776 0 : for (unsigned int j = 0; j < phaseAntRMSDim2 ; j++)
2777 :
2778 0 : phaseAntRMSAux1.push_back(eis.readFloat());
2779 :
2780 0 : phaseAntRMS.push_back(phaseAntRMSAux1);
2781 : }
2782 :
2783 :
2784 :
2785 :
2786 :
2787 :
2788 0 : }
2789 :
2790 0 : }
2791 :
2792 :
2793 0 : CalPhaseRow* CalPhaseRow::fromBin(EndianIStream& eis, CalPhaseTable& table, const vector<string>& attributesSeq) {
2794 0 : CalPhaseRow* row = new CalPhaseRow(table);
2795 :
2796 0 : map<string, CalPhaseAttributeFromBin>::iterator iter ;
2797 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
2798 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
2799 0 : if (iter != row->fromBinMethods.end()) {
2800 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
2801 : }
2802 : else {
2803 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
2804 0 : if (functorP)
2805 0 : (*functorP)(eis);
2806 : else
2807 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalPhaseTable");
2808 : }
2809 :
2810 : }
2811 0 : return row;
2812 : }
2813 :
2814 : //
2815 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
2816 : // of one row.
2817 : //
2818 :
2819 : // Convert a string into an BasebandName
2820 0 : void CalPhaseRow::basebandNameFromText(const string & s) {
2821 :
2822 :
2823 0 : basebandName = ASDMValuesParser::parse<BasebandNameMod::BasebandName>(s);
2824 :
2825 :
2826 0 : }
2827 :
2828 :
2829 : // Convert a string into an ReceiverBand
2830 0 : void CalPhaseRow::receiverBandFromText(const string & s) {
2831 :
2832 :
2833 0 : receiverBand = ASDMValuesParser::parse<ReceiverBandMod::ReceiverBand>(s);
2834 :
2835 :
2836 0 : }
2837 :
2838 :
2839 : // Convert a string into an AtmPhaseCorrection
2840 0 : void CalPhaseRow::atmPhaseCorrectionFromText(const string & s) {
2841 :
2842 :
2843 0 : atmPhaseCorrection = ASDMValuesParser::parse<AtmPhaseCorrectionMod::AtmPhaseCorrection>(s);
2844 :
2845 :
2846 0 : }
2847 :
2848 :
2849 : // Convert a string into an Tag
2850 0 : void CalPhaseRow::calDataIdFromText(const string & s) {
2851 :
2852 :
2853 0 : calDataId = ASDMValuesParser::parse<Tag>(s);
2854 :
2855 :
2856 0 : }
2857 :
2858 :
2859 : // Convert a string into an Tag
2860 0 : void CalPhaseRow::calReductionIdFromText(const string & s) {
2861 :
2862 :
2863 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
2864 :
2865 :
2866 0 : }
2867 :
2868 :
2869 : // Convert a string into an ArrayTime
2870 0 : void CalPhaseRow::startValidTimeFromText(const string & s) {
2871 :
2872 :
2873 0 : startValidTime = ASDMValuesParser::parse<ArrayTime>(s);
2874 :
2875 :
2876 0 : }
2877 :
2878 :
2879 : // Convert a string into an ArrayTime
2880 0 : void CalPhaseRow::endValidTimeFromText(const string & s) {
2881 :
2882 :
2883 0 : endValidTime = ASDMValuesParser::parse<ArrayTime>(s);
2884 :
2885 :
2886 0 : }
2887 :
2888 :
2889 : // Convert a string into an int
2890 0 : void CalPhaseRow::numBaselineFromText(const string & s) {
2891 :
2892 :
2893 0 : numBaseline = ASDMValuesParser::parse<int>(s);
2894 :
2895 :
2896 0 : }
2897 :
2898 :
2899 : // Convert a string into an int
2900 0 : void CalPhaseRow::numReceptorFromText(const string & s) {
2901 :
2902 :
2903 0 : numReceptor = ASDMValuesParser::parse<int>(s);
2904 :
2905 :
2906 0 : }
2907 :
2908 :
2909 : // Convert a string into an float
2910 0 : void CalPhaseRow::ampliFromText(const string & s) {
2911 :
2912 :
2913 0 : ampli = ASDMValuesParser::parse2D<float>(s);
2914 :
2915 :
2916 0 : }
2917 :
2918 :
2919 : // Convert a string into an String
2920 0 : void CalPhaseRow::antennaNamesFromText(const string & s) {
2921 :
2922 :
2923 0 : antennaNames = ASDMValuesParser::parse2D<string>(s);
2924 :
2925 :
2926 0 : }
2927 :
2928 :
2929 : // Convert a string into an Length
2930 0 : void CalPhaseRow::baselineLengthsFromText(const string & s) {
2931 :
2932 :
2933 0 : baselineLengths = ASDMValuesParser::parse1D<Length>(s);
2934 :
2935 :
2936 0 : }
2937 :
2938 :
2939 : // Convert a string into an float
2940 0 : void CalPhaseRow::decorrelationFactorFromText(const string & s) {
2941 :
2942 :
2943 0 : decorrelationFactor = ASDMValuesParser::parse2D<float>(s);
2944 :
2945 :
2946 0 : }
2947 :
2948 :
2949 : // Convert a string into an Angle
2950 0 : void CalPhaseRow::directionFromText(const string & s) {
2951 :
2952 :
2953 0 : direction = ASDMValuesParser::parse1D<Angle>(s);
2954 :
2955 :
2956 0 : }
2957 :
2958 :
2959 : // Convert a string into an Frequency
2960 0 : void CalPhaseRow::frequencyRangeFromText(const string & s) {
2961 :
2962 :
2963 0 : frequencyRange = ASDMValuesParser::parse1D<Frequency>(s);
2964 :
2965 :
2966 0 : }
2967 :
2968 :
2969 : // Convert a string into an Interval
2970 0 : void CalPhaseRow::integrationTimeFromText(const string & s) {
2971 :
2972 :
2973 0 : integrationTime = ASDMValuesParser::parse<Interval>(s);
2974 :
2975 :
2976 0 : }
2977 :
2978 :
2979 : // Convert a string into an float
2980 0 : void CalPhaseRow::phaseFromText(const string & s) {
2981 :
2982 :
2983 0 : phase = ASDMValuesParser::parse2D<float>(s);
2984 :
2985 :
2986 0 : }
2987 :
2988 :
2989 : // Convert a string into an PolarizationType
2990 0 : void CalPhaseRow::polarizationTypesFromText(const string & s) {
2991 :
2992 :
2993 0 : polarizationTypes = ASDMValuesParser::parse1D<PolarizationTypeMod::PolarizationType>(s);
2994 :
2995 :
2996 0 : }
2997 :
2998 :
2999 : // Convert a string into an float
3000 0 : void CalPhaseRow::phaseRMSFromText(const string & s) {
3001 :
3002 :
3003 0 : phaseRMS = ASDMValuesParser::parse2D<float>(s);
3004 :
3005 :
3006 0 : }
3007 :
3008 :
3009 : // Convert a string into an float
3010 0 : void CalPhaseRow::statPhaseRMSFromText(const string & s) {
3011 :
3012 :
3013 0 : statPhaseRMS = ASDMValuesParser::parse2D<float>(s);
3014 :
3015 :
3016 0 : }
3017 :
3018 :
3019 :
3020 : // Convert a string into an boolean
3021 0 : void CalPhaseRow::correctionValidityFromText(const string & s) {
3022 0 : correctionValidityExists = true;
3023 :
3024 :
3025 0 : correctionValidity = ASDMValuesParser::parse1D<bool>(s);
3026 :
3027 :
3028 0 : }
3029 :
3030 :
3031 : // Convert a string into an int
3032 0 : void CalPhaseRow::numAntennaFromText(const string & s) {
3033 0 : numAntennaExists = true;
3034 :
3035 :
3036 0 : numAntenna = ASDMValuesParser::parse<int>(s);
3037 :
3038 :
3039 0 : }
3040 :
3041 :
3042 : // Convert a string into an String
3043 0 : void CalPhaseRow::singleAntennaNameFromText(const string & s) {
3044 0 : singleAntennaNameExists = true;
3045 :
3046 :
3047 0 : singleAntennaName = ASDMValuesParser::parse1D<string>(s);
3048 :
3049 :
3050 0 : }
3051 :
3052 :
3053 : // Convert a string into an String
3054 0 : void CalPhaseRow::refAntennaNameFromText(const string & s) {
3055 0 : refAntennaNameExists = true;
3056 :
3057 :
3058 0 : refAntennaName = ASDMValuesParser::parse<string>(s);
3059 :
3060 :
3061 0 : }
3062 :
3063 :
3064 : // Convert a string into an float
3065 0 : void CalPhaseRow::phaseAntFromText(const string & s) {
3066 0 : phaseAntExists = true;
3067 :
3068 :
3069 0 : phaseAnt = ASDMValuesParser::parse2D<float>(s);
3070 :
3071 :
3072 0 : }
3073 :
3074 :
3075 : // Convert a string into an float
3076 0 : void CalPhaseRow::phaseAntRMSFromText(const string & s) {
3077 0 : phaseAntRMSExists = true;
3078 :
3079 :
3080 0 : phaseAntRMS = ASDMValuesParser::parse2D<float>(s);
3081 :
3082 :
3083 0 : }
3084 :
3085 :
3086 :
3087 0 : void CalPhaseRow::fromText(const std::string& attributeName, const std::string& t) {
3088 0 : map<string, CalPhaseAttributeFromText>::iterator iter;
3089 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
3090 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalPhaseTable");
3091 0 : (this->*(iter->second))(t);
3092 0 : }
3093 :
3094 : ////////////////////////////////////////////////
3095 : // Intrinsic Table Attributes getters/setters //
3096 : ////////////////////////////////////////////////
3097 :
3098 :
3099 :
3100 :
3101 : /**
3102 : * Get basebandName.
3103 : * @return basebandName as BasebandNameMod::BasebandName
3104 : */
3105 0 : BasebandNameMod::BasebandName CalPhaseRow::getBasebandName() const {
3106 :
3107 0 : return basebandName;
3108 : }
3109 :
3110 : /**
3111 : * Set basebandName with the specified BasebandNameMod::BasebandName.
3112 : * @param basebandName The BasebandNameMod::BasebandName value to which basebandName is to be set.
3113 :
3114 :
3115 :
3116 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3117 :
3118 : */
3119 0 : void CalPhaseRow::setBasebandName (BasebandNameMod::BasebandName basebandName) {
3120 :
3121 :
3122 0 : if (hasBeenAdded) {
3123 :
3124 0 : throw IllegalAccessException("basebandName", "CalPhase");
3125 :
3126 : }
3127 :
3128 0 : this->basebandName = basebandName;
3129 :
3130 0 : }
3131 :
3132 :
3133 :
3134 :
3135 :
3136 :
3137 : /**
3138 : * Get receiverBand.
3139 : * @return receiverBand as ReceiverBandMod::ReceiverBand
3140 : */
3141 0 : ReceiverBandMod::ReceiverBand CalPhaseRow::getReceiverBand() const {
3142 :
3143 0 : return receiverBand;
3144 : }
3145 :
3146 : /**
3147 : * Set receiverBand with the specified ReceiverBandMod::ReceiverBand.
3148 : * @param receiverBand The ReceiverBandMod::ReceiverBand value to which receiverBand is to be set.
3149 :
3150 :
3151 :
3152 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3153 :
3154 : */
3155 0 : void CalPhaseRow::setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand) {
3156 :
3157 :
3158 0 : if (hasBeenAdded) {
3159 :
3160 0 : throw IllegalAccessException("receiverBand", "CalPhase");
3161 :
3162 : }
3163 :
3164 0 : this->receiverBand = receiverBand;
3165 :
3166 0 : }
3167 :
3168 :
3169 :
3170 :
3171 :
3172 :
3173 : /**
3174 : * Get atmPhaseCorrection.
3175 : * @return atmPhaseCorrection as AtmPhaseCorrectionMod::AtmPhaseCorrection
3176 : */
3177 0 : AtmPhaseCorrectionMod::AtmPhaseCorrection CalPhaseRow::getAtmPhaseCorrection() const {
3178 :
3179 0 : return atmPhaseCorrection;
3180 : }
3181 :
3182 : /**
3183 : * Set atmPhaseCorrection with the specified AtmPhaseCorrectionMod::AtmPhaseCorrection.
3184 : * @param atmPhaseCorrection The AtmPhaseCorrectionMod::AtmPhaseCorrection value to which atmPhaseCorrection is to be set.
3185 :
3186 :
3187 :
3188 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3189 :
3190 : */
3191 0 : void CalPhaseRow::setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection) {
3192 :
3193 :
3194 0 : if (hasBeenAdded) {
3195 :
3196 0 : throw IllegalAccessException("atmPhaseCorrection", "CalPhase");
3197 :
3198 : }
3199 :
3200 0 : this->atmPhaseCorrection = atmPhaseCorrection;
3201 :
3202 0 : }
3203 :
3204 :
3205 :
3206 :
3207 :
3208 :
3209 : /**
3210 : * Get startValidTime.
3211 : * @return startValidTime as ArrayTime
3212 : */
3213 0 : ArrayTime CalPhaseRow::getStartValidTime() const {
3214 :
3215 0 : return startValidTime;
3216 : }
3217 :
3218 : /**
3219 : * Set startValidTime with the specified ArrayTime.
3220 : * @param startValidTime The ArrayTime value to which startValidTime is to be set.
3221 :
3222 :
3223 :
3224 : */
3225 0 : void CalPhaseRow::setStartValidTime (ArrayTime startValidTime) {
3226 :
3227 :
3228 0 : if (hasBeenAdded) {
3229 :
3230 : }
3231 :
3232 0 : this->startValidTime = startValidTime;
3233 :
3234 0 : }
3235 :
3236 :
3237 :
3238 :
3239 :
3240 :
3241 : /**
3242 : * Get endValidTime.
3243 : * @return endValidTime as ArrayTime
3244 : */
3245 0 : ArrayTime CalPhaseRow::getEndValidTime() const {
3246 :
3247 0 : return endValidTime;
3248 : }
3249 :
3250 : /**
3251 : * Set endValidTime with the specified ArrayTime.
3252 : * @param endValidTime The ArrayTime value to which endValidTime is to be set.
3253 :
3254 :
3255 :
3256 : */
3257 0 : void CalPhaseRow::setEndValidTime (ArrayTime endValidTime) {
3258 :
3259 :
3260 0 : if (hasBeenAdded) {
3261 :
3262 : }
3263 :
3264 0 : this->endValidTime = endValidTime;
3265 :
3266 0 : }
3267 :
3268 :
3269 :
3270 :
3271 :
3272 :
3273 : /**
3274 : * Get numBaseline.
3275 : * @return numBaseline as int
3276 : */
3277 0 : int CalPhaseRow::getNumBaseline() const {
3278 :
3279 0 : return numBaseline;
3280 : }
3281 :
3282 : /**
3283 : * Set numBaseline with the specified int.
3284 : * @param numBaseline The int value to which numBaseline is to be set.
3285 :
3286 :
3287 :
3288 : */
3289 0 : void CalPhaseRow::setNumBaseline (int numBaseline) {
3290 :
3291 :
3292 0 : if (hasBeenAdded) {
3293 :
3294 : }
3295 :
3296 0 : this->numBaseline = numBaseline;
3297 :
3298 0 : }
3299 :
3300 :
3301 :
3302 :
3303 :
3304 :
3305 : /**
3306 : * Get numReceptor.
3307 : * @return numReceptor as int
3308 : */
3309 0 : int CalPhaseRow::getNumReceptor() const {
3310 :
3311 0 : return numReceptor;
3312 : }
3313 :
3314 : /**
3315 : * Set numReceptor with the specified int.
3316 : * @param numReceptor The int value to which numReceptor is to be set.
3317 :
3318 :
3319 :
3320 : */
3321 0 : void CalPhaseRow::setNumReceptor (int numReceptor) {
3322 :
3323 :
3324 0 : if (hasBeenAdded) {
3325 :
3326 : }
3327 :
3328 0 : this->numReceptor = numReceptor;
3329 :
3330 0 : }
3331 :
3332 :
3333 :
3334 :
3335 :
3336 :
3337 : /**
3338 : * Get ampli.
3339 : * @return ampli as std::vector<std::vector<float > >
3340 : */
3341 0 : std::vector<std::vector<float > > CalPhaseRow::getAmpli() const {
3342 :
3343 0 : return ampli;
3344 : }
3345 :
3346 : /**
3347 : * Set ampli with the specified std::vector<std::vector<float > >.
3348 : * @param ampli The std::vector<std::vector<float > > value to which ampli is to be set.
3349 :
3350 :
3351 :
3352 : */
3353 0 : void CalPhaseRow::setAmpli (std::vector<std::vector<float > > ampli) {
3354 :
3355 :
3356 0 : if (hasBeenAdded) {
3357 :
3358 : }
3359 :
3360 0 : this->ampli = ampli;
3361 :
3362 0 : }
3363 :
3364 :
3365 :
3366 :
3367 :
3368 :
3369 : /**
3370 : * Get antennaNames.
3371 : * @return antennaNames as std::vector<std::vector<std::string > >
3372 : */
3373 0 : std::vector<std::vector<std::string > > CalPhaseRow::getAntennaNames() const {
3374 :
3375 0 : return antennaNames;
3376 : }
3377 :
3378 : /**
3379 : * Set antennaNames with the specified std::vector<std::vector<std::string > >.
3380 : * @param antennaNames The std::vector<std::vector<std::string > > value to which antennaNames is to be set.
3381 :
3382 :
3383 :
3384 : */
3385 0 : void CalPhaseRow::setAntennaNames (std::vector<std::vector<std::string > > antennaNames) {
3386 :
3387 :
3388 0 : if (hasBeenAdded) {
3389 :
3390 : }
3391 :
3392 0 : this->antennaNames = antennaNames;
3393 :
3394 0 : }
3395 :
3396 :
3397 :
3398 :
3399 :
3400 :
3401 : /**
3402 : * Get baselineLengths.
3403 : * @return baselineLengths as std::vector<Length >
3404 : */
3405 0 : std::vector<Length > CalPhaseRow::getBaselineLengths() const {
3406 :
3407 0 : return baselineLengths;
3408 : }
3409 :
3410 : /**
3411 : * Set baselineLengths with the specified std::vector<Length >.
3412 : * @param baselineLengths The std::vector<Length > value to which baselineLengths is to be set.
3413 :
3414 :
3415 :
3416 : */
3417 0 : void CalPhaseRow::setBaselineLengths (std::vector<Length > baselineLengths) {
3418 :
3419 :
3420 0 : if (hasBeenAdded) {
3421 :
3422 : }
3423 :
3424 0 : this->baselineLengths = baselineLengths;
3425 :
3426 0 : }
3427 :
3428 :
3429 :
3430 :
3431 :
3432 :
3433 : /**
3434 : * Get decorrelationFactor.
3435 : * @return decorrelationFactor as std::vector<std::vector<float > >
3436 : */
3437 0 : std::vector<std::vector<float > > CalPhaseRow::getDecorrelationFactor() const {
3438 :
3439 0 : return decorrelationFactor;
3440 : }
3441 :
3442 : /**
3443 : * Set decorrelationFactor with the specified std::vector<std::vector<float > >.
3444 : * @param decorrelationFactor The std::vector<std::vector<float > > value to which decorrelationFactor is to be set.
3445 :
3446 :
3447 :
3448 : */
3449 0 : void CalPhaseRow::setDecorrelationFactor (std::vector<std::vector<float > > decorrelationFactor) {
3450 :
3451 :
3452 0 : if (hasBeenAdded) {
3453 :
3454 : }
3455 :
3456 0 : this->decorrelationFactor = decorrelationFactor;
3457 :
3458 0 : }
3459 :
3460 :
3461 :
3462 :
3463 :
3464 :
3465 : /**
3466 : * Get direction.
3467 : * @return direction as std::vector<Angle >
3468 : */
3469 0 : std::vector<Angle > CalPhaseRow::getDirection() const {
3470 :
3471 0 : return direction;
3472 : }
3473 :
3474 : /**
3475 : * Set direction with the specified std::vector<Angle >.
3476 : * @param direction The std::vector<Angle > value to which direction is to be set.
3477 :
3478 :
3479 :
3480 : */
3481 0 : void CalPhaseRow::setDirection (std::vector<Angle > direction) {
3482 :
3483 :
3484 0 : if (hasBeenAdded) {
3485 :
3486 : }
3487 :
3488 0 : this->direction = direction;
3489 :
3490 0 : }
3491 :
3492 :
3493 :
3494 :
3495 :
3496 :
3497 : /**
3498 : * Get frequencyRange.
3499 : * @return frequencyRange as std::vector<Frequency >
3500 : */
3501 0 : std::vector<Frequency > CalPhaseRow::getFrequencyRange() const {
3502 :
3503 0 : return frequencyRange;
3504 : }
3505 :
3506 : /**
3507 : * Set frequencyRange with the specified std::vector<Frequency >.
3508 : * @param frequencyRange The std::vector<Frequency > value to which frequencyRange is to be set.
3509 :
3510 :
3511 :
3512 : */
3513 0 : void CalPhaseRow::setFrequencyRange (std::vector<Frequency > frequencyRange) {
3514 :
3515 :
3516 0 : if (hasBeenAdded) {
3517 :
3518 : }
3519 :
3520 0 : this->frequencyRange = frequencyRange;
3521 :
3522 0 : }
3523 :
3524 :
3525 :
3526 :
3527 :
3528 :
3529 : /**
3530 : * Get integrationTime.
3531 : * @return integrationTime as Interval
3532 : */
3533 0 : Interval CalPhaseRow::getIntegrationTime() const {
3534 :
3535 0 : return integrationTime;
3536 : }
3537 :
3538 : /**
3539 : * Set integrationTime with the specified Interval.
3540 : * @param integrationTime The Interval value to which integrationTime is to be set.
3541 :
3542 :
3543 :
3544 : */
3545 0 : void CalPhaseRow::setIntegrationTime (Interval integrationTime) {
3546 :
3547 :
3548 0 : if (hasBeenAdded) {
3549 :
3550 : }
3551 :
3552 0 : this->integrationTime = integrationTime;
3553 :
3554 0 : }
3555 :
3556 :
3557 :
3558 :
3559 :
3560 :
3561 : /**
3562 : * Get phase.
3563 : * @return phase as std::vector<std::vector<float > >
3564 : */
3565 0 : std::vector<std::vector<float > > CalPhaseRow::getPhase() const {
3566 :
3567 0 : return phase;
3568 : }
3569 :
3570 : /**
3571 : * Set phase with the specified std::vector<std::vector<float > >.
3572 : * @param phase The std::vector<std::vector<float > > value to which phase is to be set.
3573 :
3574 :
3575 :
3576 : */
3577 0 : void CalPhaseRow::setPhase (std::vector<std::vector<float > > phase) {
3578 :
3579 :
3580 0 : if (hasBeenAdded) {
3581 :
3582 : }
3583 :
3584 0 : this->phase = phase;
3585 :
3586 0 : }
3587 :
3588 :
3589 :
3590 :
3591 :
3592 :
3593 : /**
3594 : * Get polarizationTypes.
3595 : * @return polarizationTypes as std::vector<PolarizationTypeMod::PolarizationType >
3596 : */
3597 0 : std::vector<PolarizationTypeMod::PolarizationType > CalPhaseRow::getPolarizationTypes() const {
3598 :
3599 0 : return polarizationTypes;
3600 : }
3601 :
3602 : /**
3603 : * Set polarizationTypes with the specified std::vector<PolarizationTypeMod::PolarizationType >.
3604 : * @param polarizationTypes The std::vector<PolarizationTypeMod::PolarizationType > value to which polarizationTypes is to be set.
3605 :
3606 :
3607 :
3608 : */
3609 0 : void CalPhaseRow::setPolarizationTypes (std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes) {
3610 :
3611 :
3612 0 : if (hasBeenAdded) {
3613 :
3614 : }
3615 :
3616 0 : this->polarizationTypes = polarizationTypes;
3617 :
3618 0 : }
3619 :
3620 :
3621 :
3622 :
3623 :
3624 :
3625 : /**
3626 : * Get phaseRMS.
3627 : * @return phaseRMS as std::vector<std::vector<float > >
3628 : */
3629 0 : std::vector<std::vector<float > > CalPhaseRow::getPhaseRMS() const {
3630 :
3631 0 : return phaseRMS;
3632 : }
3633 :
3634 : /**
3635 : * Set phaseRMS with the specified std::vector<std::vector<float > >.
3636 : * @param phaseRMS The std::vector<std::vector<float > > value to which phaseRMS is to be set.
3637 :
3638 :
3639 :
3640 : */
3641 0 : void CalPhaseRow::setPhaseRMS (std::vector<std::vector<float > > phaseRMS) {
3642 :
3643 :
3644 0 : if (hasBeenAdded) {
3645 :
3646 : }
3647 :
3648 0 : this->phaseRMS = phaseRMS;
3649 :
3650 0 : }
3651 :
3652 :
3653 :
3654 :
3655 :
3656 :
3657 : /**
3658 : * Get statPhaseRMS.
3659 : * @return statPhaseRMS as std::vector<std::vector<float > >
3660 : */
3661 0 : std::vector<std::vector<float > > CalPhaseRow::getStatPhaseRMS() const {
3662 :
3663 0 : return statPhaseRMS;
3664 : }
3665 :
3666 : /**
3667 : * Set statPhaseRMS with the specified std::vector<std::vector<float > >.
3668 : * @param statPhaseRMS The std::vector<std::vector<float > > value to which statPhaseRMS is to be set.
3669 :
3670 :
3671 :
3672 : */
3673 0 : void CalPhaseRow::setStatPhaseRMS (std::vector<std::vector<float > > statPhaseRMS) {
3674 :
3675 :
3676 0 : if (hasBeenAdded) {
3677 :
3678 : }
3679 :
3680 0 : this->statPhaseRMS = statPhaseRMS;
3681 :
3682 0 : }
3683 :
3684 :
3685 :
3686 :
3687 : /**
3688 : * The attribute correctionValidity is optional. Return true if this attribute exists.
3689 : * @return true if and only if the correctionValidity attribute exists.
3690 : */
3691 0 : bool CalPhaseRow::isCorrectionValidityExists() const {
3692 0 : return correctionValidityExists;
3693 : }
3694 :
3695 :
3696 :
3697 : /**
3698 : * Get correctionValidity, which is optional.
3699 : * @return correctionValidity as std::vector<bool >
3700 : * @throw IllegalAccessException If correctionValidity does not exist.
3701 : */
3702 0 : std::vector<bool > CalPhaseRow::getCorrectionValidity() const {
3703 0 : if (!correctionValidityExists) {
3704 0 : throw IllegalAccessException("correctionValidity", "CalPhase");
3705 : }
3706 :
3707 0 : return correctionValidity;
3708 : }
3709 :
3710 : /**
3711 : * Set correctionValidity with the specified std::vector<bool >.
3712 : * @param correctionValidity The std::vector<bool > value to which correctionValidity is to be set.
3713 :
3714 :
3715 : */
3716 0 : void CalPhaseRow::setCorrectionValidity (std::vector<bool > correctionValidity) {
3717 :
3718 0 : this->correctionValidity = correctionValidity;
3719 :
3720 0 : correctionValidityExists = true;
3721 :
3722 0 : }
3723 :
3724 :
3725 : /**
3726 : * Mark correctionValidity, which is an optional field, as non-existent.
3727 : */
3728 0 : void CalPhaseRow::clearCorrectionValidity () {
3729 0 : correctionValidityExists = false;
3730 0 : }
3731 :
3732 :
3733 :
3734 : /**
3735 : * The attribute numAntenna is optional. Return true if this attribute exists.
3736 : * @return true if and only if the numAntenna attribute exists.
3737 : */
3738 0 : bool CalPhaseRow::isNumAntennaExists() const {
3739 0 : return numAntennaExists;
3740 : }
3741 :
3742 :
3743 :
3744 : /**
3745 : * Get numAntenna, which is optional.
3746 : * @return numAntenna as int
3747 : * @throw IllegalAccessException If numAntenna does not exist.
3748 : */
3749 0 : int CalPhaseRow::getNumAntenna() const {
3750 0 : if (!numAntennaExists) {
3751 0 : throw IllegalAccessException("numAntenna", "CalPhase");
3752 : }
3753 :
3754 0 : return numAntenna;
3755 : }
3756 :
3757 : /**
3758 : * Set numAntenna with the specified int.
3759 : * @param numAntenna The int value to which numAntenna is to be set.
3760 :
3761 :
3762 : */
3763 0 : void CalPhaseRow::setNumAntenna (int numAntenna) {
3764 :
3765 0 : this->numAntenna = numAntenna;
3766 :
3767 0 : numAntennaExists = true;
3768 :
3769 0 : }
3770 :
3771 :
3772 : /**
3773 : * Mark numAntenna, which is an optional field, as non-existent.
3774 : */
3775 0 : void CalPhaseRow::clearNumAntenna () {
3776 0 : numAntennaExists = false;
3777 0 : }
3778 :
3779 :
3780 :
3781 : /**
3782 : * The attribute singleAntennaName is optional. Return true if this attribute exists.
3783 : * @return true if and only if the singleAntennaName attribute exists.
3784 : */
3785 0 : bool CalPhaseRow::isSingleAntennaNameExists() const {
3786 0 : return singleAntennaNameExists;
3787 : }
3788 :
3789 :
3790 :
3791 : /**
3792 : * Get singleAntennaName, which is optional.
3793 : * @return singleAntennaName as std::vector<std::string >
3794 : * @throw IllegalAccessException If singleAntennaName does not exist.
3795 : */
3796 0 : std::vector<std::string > CalPhaseRow::getSingleAntennaName() const {
3797 0 : if (!singleAntennaNameExists) {
3798 0 : throw IllegalAccessException("singleAntennaName", "CalPhase");
3799 : }
3800 :
3801 0 : return singleAntennaName;
3802 : }
3803 :
3804 : /**
3805 : * Set singleAntennaName with the specified std::vector<std::string >.
3806 : * @param singleAntennaName The std::vector<std::string > value to which singleAntennaName is to be set.
3807 :
3808 :
3809 : */
3810 0 : void CalPhaseRow::setSingleAntennaName (std::vector<std::string > singleAntennaName) {
3811 :
3812 0 : this->singleAntennaName = singleAntennaName;
3813 :
3814 0 : singleAntennaNameExists = true;
3815 :
3816 0 : }
3817 :
3818 :
3819 : /**
3820 : * Mark singleAntennaName, which is an optional field, as non-existent.
3821 : */
3822 0 : void CalPhaseRow::clearSingleAntennaName () {
3823 0 : singleAntennaNameExists = false;
3824 0 : }
3825 :
3826 :
3827 :
3828 : /**
3829 : * The attribute refAntennaName is optional. Return true if this attribute exists.
3830 : * @return true if and only if the refAntennaName attribute exists.
3831 : */
3832 0 : bool CalPhaseRow::isRefAntennaNameExists() const {
3833 0 : return refAntennaNameExists;
3834 : }
3835 :
3836 :
3837 :
3838 : /**
3839 : * Get refAntennaName, which is optional.
3840 : * @return refAntennaName as std::string
3841 : * @throw IllegalAccessException If refAntennaName does not exist.
3842 : */
3843 0 : std::string CalPhaseRow::getRefAntennaName() const {
3844 0 : if (!refAntennaNameExists) {
3845 0 : throw IllegalAccessException("refAntennaName", "CalPhase");
3846 : }
3847 :
3848 0 : return refAntennaName;
3849 : }
3850 :
3851 : /**
3852 : * Set refAntennaName with the specified std::string.
3853 : * @param refAntennaName The std::string value to which refAntennaName is to be set.
3854 :
3855 :
3856 : */
3857 0 : void CalPhaseRow::setRefAntennaName (std::string refAntennaName) {
3858 :
3859 0 : this->refAntennaName = refAntennaName;
3860 :
3861 0 : refAntennaNameExists = true;
3862 :
3863 0 : }
3864 :
3865 :
3866 : /**
3867 : * Mark refAntennaName, which is an optional field, as non-existent.
3868 : */
3869 0 : void CalPhaseRow::clearRefAntennaName () {
3870 0 : refAntennaNameExists = false;
3871 0 : }
3872 :
3873 :
3874 :
3875 : /**
3876 : * The attribute phaseAnt is optional. Return true if this attribute exists.
3877 : * @return true if and only if the phaseAnt attribute exists.
3878 : */
3879 0 : bool CalPhaseRow::isPhaseAntExists() const {
3880 0 : return phaseAntExists;
3881 : }
3882 :
3883 :
3884 :
3885 : /**
3886 : * Get phaseAnt, which is optional.
3887 : * @return phaseAnt as std::vector<std::vector<float > >
3888 : * @throw IllegalAccessException If phaseAnt does not exist.
3889 : */
3890 0 : std::vector<std::vector<float > > CalPhaseRow::getPhaseAnt() const {
3891 0 : if (!phaseAntExists) {
3892 0 : throw IllegalAccessException("phaseAnt", "CalPhase");
3893 : }
3894 :
3895 0 : return phaseAnt;
3896 : }
3897 :
3898 : /**
3899 : * Set phaseAnt with the specified std::vector<std::vector<float > >.
3900 : * @param phaseAnt The std::vector<std::vector<float > > value to which phaseAnt is to be set.
3901 :
3902 :
3903 : */
3904 0 : void CalPhaseRow::setPhaseAnt (std::vector<std::vector<float > > phaseAnt) {
3905 :
3906 0 : this->phaseAnt = phaseAnt;
3907 :
3908 0 : phaseAntExists = true;
3909 :
3910 0 : }
3911 :
3912 :
3913 : /**
3914 : * Mark phaseAnt, which is an optional field, as non-existent.
3915 : */
3916 0 : void CalPhaseRow::clearPhaseAnt () {
3917 0 : phaseAntExists = false;
3918 0 : }
3919 :
3920 :
3921 :
3922 : /**
3923 : * The attribute phaseAntRMS is optional. Return true if this attribute exists.
3924 : * @return true if and only if the phaseAntRMS attribute exists.
3925 : */
3926 0 : bool CalPhaseRow::isPhaseAntRMSExists() const {
3927 0 : return phaseAntRMSExists;
3928 : }
3929 :
3930 :
3931 :
3932 : /**
3933 : * Get phaseAntRMS, which is optional.
3934 : * @return phaseAntRMS as std::vector<std::vector<float > >
3935 : * @throw IllegalAccessException If phaseAntRMS does not exist.
3936 : */
3937 0 : std::vector<std::vector<float > > CalPhaseRow::getPhaseAntRMS() const {
3938 0 : if (!phaseAntRMSExists) {
3939 0 : throw IllegalAccessException("phaseAntRMS", "CalPhase");
3940 : }
3941 :
3942 0 : return phaseAntRMS;
3943 : }
3944 :
3945 : /**
3946 : * Set phaseAntRMS with the specified std::vector<std::vector<float > >.
3947 : * @param phaseAntRMS The std::vector<std::vector<float > > value to which phaseAntRMS is to be set.
3948 :
3949 :
3950 : */
3951 0 : void CalPhaseRow::setPhaseAntRMS (std::vector<std::vector<float > > phaseAntRMS) {
3952 :
3953 0 : this->phaseAntRMS = phaseAntRMS;
3954 :
3955 0 : phaseAntRMSExists = true;
3956 :
3957 0 : }
3958 :
3959 :
3960 : /**
3961 : * Mark phaseAntRMS, which is an optional field, as non-existent.
3962 : */
3963 0 : void CalPhaseRow::clearPhaseAntRMS () {
3964 0 : phaseAntRMSExists = false;
3965 0 : }
3966 :
3967 :
3968 :
3969 : ///////////////////////////////////////////////
3970 : // Extrinsic Table Attributes getters/setters//
3971 : ///////////////////////////////////////////////
3972 :
3973 :
3974 :
3975 :
3976 : /**
3977 : * Get calDataId.
3978 : * @return calDataId as Tag
3979 : */
3980 0 : Tag CalPhaseRow::getCalDataId() const {
3981 :
3982 0 : return calDataId;
3983 : }
3984 :
3985 : /**
3986 : * Set calDataId with the specified Tag.
3987 : * @param calDataId The Tag value to which calDataId is to be set.
3988 :
3989 :
3990 :
3991 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3992 :
3993 : */
3994 0 : void CalPhaseRow::setCalDataId (Tag calDataId) {
3995 :
3996 :
3997 0 : if (hasBeenAdded) {
3998 :
3999 0 : throw IllegalAccessException("calDataId", "CalPhase");
4000 :
4001 : }
4002 :
4003 0 : this->calDataId = calDataId;
4004 :
4005 0 : }
4006 :
4007 :
4008 :
4009 :
4010 :
4011 :
4012 : /**
4013 : * Get calReductionId.
4014 : * @return calReductionId as Tag
4015 : */
4016 0 : Tag CalPhaseRow::getCalReductionId() const {
4017 :
4018 0 : return calReductionId;
4019 : }
4020 :
4021 : /**
4022 : * Set calReductionId with the specified Tag.
4023 : * @param calReductionId The Tag value to which calReductionId is to be set.
4024 :
4025 :
4026 :
4027 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4028 :
4029 : */
4030 0 : void CalPhaseRow::setCalReductionId (Tag calReductionId) {
4031 :
4032 :
4033 0 : if (hasBeenAdded) {
4034 :
4035 0 : throw IllegalAccessException("calReductionId", "CalPhase");
4036 :
4037 : }
4038 :
4039 0 : this->calReductionId = calReductionId;
4040 :
4041 0 : }
4042 :
4043 :
4044 :
4045 :
4046 : //////////////////////////////////////
4047 : // Links Attributes getters/setters //
4048 : //////////////////////////////////////
4049 :
4050 :
4051 :
4052 :
4053 :
4054 :
4055 : /**
4056 : * Returns the pointer to the row in the CalData table having CalData.calDataId == calDataId
4057 : * @return a CalDataRow*
4058 : *
4059 :
4060 : */
4061 0 : CalDataRow* CalPhaseRow::getCalDataUsingCalDataId() {
4062 :
4063 0 : return table.getContainer().getCalData().getRowByKey(calDataId);
4064 : }
4065 :
4066 :
4067 :
4068 :
4069 :
4070 :
4071 :
4072 :
4073 :
4074 : /**
4075 : * Returns the pointer to the row in the CalReduction table having CalReduction.calReductionId == calReductionId
4076 : * @return a CalReductionRow*
4077 : *
4078 :
4079 : */
4080 0 : CalReductionRow* CalPhaseRow::getCalReductionUsingCalReductionId() {
4081 :
4082 0 : return table.getContainer().getCalReduction().getRowByKey(calReductionId);
4083 : }
4084 :
4085 :
4086 :
4087 :
4088 :
4089 : /**
4090 : * Create a CalPhaseRow.
4091 : * <p>
4092 : * This constructor is private because only the
4093 : * table can create rows. All rows know the table
4094 : * to which they belong.
4095 : * @param table The table to which this row belongs.
4096 : */
4097 0 : CalPhaseRow::CalPhaseRow (CalPhaseTable &t) : table(t) {
4098 0 : hasBeenAdded = false;
4099 :
4100 :
4101 :
4102 :
4103 :
4104 :
4105 :
4106 :
4107 :
4108 :
4109 :
4110 :
4111 :
4112 :
4113 :
4114 :
4115 :
4116 :
4117 :
4118 :
4119 :
4120 :
4121 :
4122 :
4123 :
4124 :
4125 :
4126 :
4127 :
4128 :
4129 :
4130 :
4131 :
4132 :
4133 :
4134 :
4135 :
4136 :
4137 :
4138 0 : correctionValidityExists = false;
4139 :
4140 :
4141 :
4142 0 : numAntennaExists = false;
4143 :
4144 :
4145 :
4146 0 : singleAntennaNameExists = false;
4147 :
4148 :
4149 :
4150 0 : refAntennaNameExists = false;
4151 :
4152 :
4153 :
4154 0 : phaseAntExists = false;
4155 :
4156 :
4157 :
4158 0 : phaseAntRMSExists = false;
4159 :
4160 :
4161 :
4162 :
4163 :
4164 :
4165 :
4166 :
4167 :
4168 :
4169 :
4170 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
4171 0 : basebandName = CBasebandName::from_int(0);
4172 :
4173 :
4174 :
4175 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
4176 0 : receiverBand = CReceiverBand::from_int(0);
4177 :
4178 :
4179 :
4180 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
4181 0 : atmPhaseCorrection = CAtmPhaseCorrection::from_int(0);
4182 :
4183 :
4184 :
4185 :
4186 :
4187 :
4188 :
4189 :
4190 :
4191 :
4192 :
4193 :
4194 :
4195 :
4196 :
4197 :
4198 :
4199 :
4200 :
4201 :
4202 :
4203 :
4204 :
4205 :
4206 :
4207 :
4208 :
4209 :
4210 :
4211 :
4212 :
4213 :
4214 :
4215 :
4216 :
4217 :
4218 :
4219 :
4220 :
4221 :
4222 :
4223 :
4224 :
4225 :
4226 :
4227 :
4228 0 : fromBinMethods["basebandName"] = &CalPhaseRow::basebandNameFromBin;
4229 0 : fromBinMethods["receiverBand"] = &CalPhaseRow::receiverBandFromBin;
4230 0 : fromBinMethods["atmPhaseCorrection"] = &CalPhaseRow::atmPhaseCorrectionFromBin;
4231 0 : fromBinMethods["calDataId"] = &CalPhaseRow::calDataIdFromBin;
4232 0 : fromBinMethods["calReductionId"] = &CalPhaseRow::calReductionIdFromBin;
4233 0 : fromBinMethods["startValidTime"] = &CalPhaseRow::startValidTimeFromBin;
4234 0 : fromBinMethods["endValidTime"] = &CalPhaseRow::endValidTimeFromBin;
4235 0 : fromBinMethods["numBaseline"] = &CalPhaseRow::numBaselineFromBin;
4236 0 : fromBinMethods["numReceptor"] = &CalPhaseRow::numReceptorFromBin;
4237 0 : fromBinMethods["ampli"] = &CalPhaseRow::ampliFromBin;
4238 0 : fromBinMethods["antennaNames"] = &CalPhaseRow::antennaNamesFromBin;
4239 0 : fromBinMethods["baselineLengths"] = &CalPhaseRow::baselineLengthsFromBin;
4240 0 : fromBinMethods["decorrelationFactor"] = &CalPhaseRow::decorrelationFactorFromBin;
4241 0 : fromBinMethods["direction"] = &CalPhaseRow::directionFromBin;
4242 0 : fromBinMethods["frequencyRange"] = &CalPhaseRow::frequencyRangeFromBin;
4243 0 : fromBinMethods["integrationTime"] = &CalPhaseRow::integrationTimeFromBin;
4244 0 : fromBinMethods["phase"] = &CalPhaseRow::phaseFromBin;
4245 0 : fromBinMethods["polarizationTypes"] = &CalPhaseRow::polarizationTypesFromBin;
4246 0 : fromBinMethods["phaseRMS"] = &CalPhaseRow::phaseRMSFromBin;
4247 0 : fromBinMethods["statPhaseRMS"] = &CalPhaseRow::statPhaseRMSFromBin;
4248 :
4249 :
4250 0 : fromBinMethods["correctionValidity"] = &CalPhaseRow::correctionValidityFromBin;
4251 0 : fromBinMethods["numAntenna"] = &CalPhaseRow::numAntennaFromBin;
4252 0 : fromBinMethods["singleAntennaName"] = &CalPhaseRow::singleAntennaNameFromBin;
4253 0 : fromBinMethods["refAntennaName"] = &CalPhaseRow::refAntennaNameFromBin;
4254 0 : fromBinMethods["phaseAnt"] = &CalPhaseRow::phaseAntFromBin;
4255 0 : fromBinMethods["phaseAntRMS"] = &CalPhaseRow::phaseAntRMSFromBin;
4256 :
4257 :
4258 :
4259 :
4260 :
4261 0 : fromTextMethods["basebandName"] = &CalPhaseRow::basebandNameFromText;
4262 :
4263 :
4264 :
4265 0 : fromTextMethods["receiverBand"] = &CalPhaseRow::receiverBandFromText;
4266 :
4267 :
4268 :
4269 0 : fromTextMethods["atmPhaseCorrection"] = &CalPhaseRow::atmPhaseCorrectionFromText;
4270 :
4271 :
4272 :
4273 0 : fromTextMethods["calDataId"] = &CalPhaseRow::calDataIdFromText;
4274 :
4275 :
4276 :
4277 0 : fromTextMethods["calReductionId"] = &CalPhaseRow::calReductionIdFromText;
4278 :
4279 :
4280 :
4281 0 : fromTextMethods["startValidTime"] = &CalPhaseRow::startValidTimeFromText;
4282 :
4283 :
4284 :
4285 0 : fromTextMethods["endValidTime"] = &CalPhaseRow::endValidTimeFromText;
4286 :
4287 :
4288 :
4289 0 : fromTextMethods["numBaseline"] = &CalPhaseRow::numBaselineFromText;
4290 :
4291 :
4292 :
4293 0 : fromTextMethods["numReceptor"] = &CalPhaseRow::numReceptorFromText;
4294 :
4295 :
4296 :
4297 0 : fromTextMethods["ampli"] = &CalPhaseRow::ampliFromText;
4298 :
4299 :
4300 :
4301 0 : fromTextMethods["antennaNames"] = &CalPhaseRow::antennaNamesFromText;
4302 :
4303 :
4304 :
4305 0 : fromTextMethods["baselineLengths"] = &CalPhaseRow::baselineLengthsFromText;
4306 :
4307 :
4308 :
4309 0 : fromTextMethods["decorrelationFactor"] = &CalPhaseRow::decorrelationFactorFromText;
4310 :
4311 :
4312 :
4313 0 : fromTextMethods["direction"] = &CalPhaseRow::directionFromText;
4314 :
4315 :
4316 :
4317 0 : fromTextMethods["frequencyRange"] = &CalPhaseRow::frequencyRangeFromText;
4318 :
4319 :
4320 :
4321 0 : fromTextMethods["integrationTime"] = &CalPhaseRow::integrationTimeFromText;
4322 :
4323 :
4324 :
4325 0 : fromTextMethods["phase"] = &CalPhaseRow::phaseFromText;
4326 :
4327 :
4328 :
4329 0 : fromTextMethods["polarizationTypes"] = &CalPhaseRow::polarizationTypesFromText;
4330 :
4331 :
4332 :
4333 0 : fromTextMethods["phaseRMS"] = &CalPhaseRow::phaseRMSFromText;
4334 :
4335 :
4336 :
4337 0 : fromTextMethods["statPhaseRMS"] = &CalPhaseRow::statPhaseRMSFromText;
4338 :
4339 :
4340 :
4341 :
4342 :
4343 0 : fromTextMethods["correctionValidity"] = &CalPhaseRow::correctionValidityFromText;
4344 :
4345 :
4346 :
4347 0 : fromTextMethods["numAntenna"] = &CalPhaseRow::numAntennaFromText;
4348 :
4349 :
4350 :
4351 0 : fromTextMethods["singleAntennaName"] = &CalPhaseRow::singleAntennaNameFromText;
4352 :
4353 :
4354 :
4355 0 : fromTextMethods["refAntennaName"] = &CalPhaseRow::refAntennaNameFromText;
4356 :
4357 :
4358 :
4359 0 : fromTextMethods["phaseAnt"] = &CalPhaseRow::phaseAntFromText;
4360 :
4361 :
4362 :
4363 0 : fromTextMethods["phaseAntRMS"] = &CalPhaseRow::phaseAntRMSFromText;
4364 :
4365 :
4366 0 : }
4367 :
4368 0 : CalPhaseRow::CalPhaseRow (CalPhaseTable &t, CalPhaseRow *row) : table(t) {
4369 0 : hasBeenAdded = false;
4370 :
4371 0 : if (row == 0) {
4372 :
4373 :
4374 :
4375 :
4376 :
4377 :
4378 :
4379 :
4380 :
4381 :
4382 :
4383 :
4384 :
4385 :
4386 :
4387 :
4388 :
4389 :
4390 :
4391 :
4392 :
4393 :
4394 :
4395 :
4396 :
4397 :
4398 :
4399 :
4400 :
4401 :
4402 :
4403 :
4404 :
4405 :
4406 :
4407 :
4408 :
4409 :
4410 :
4411 0 : correctionValidityExists = false;
4412 :
4413 :
4414 :
4415 0 : numAntennaExists = false;
4416 :
4417 :
4418 :
4419 0 : singleAntennaNameExists = false;
4420 :
4421 :
4422 :
4423 0 : refAntennaNameExists = false;
4424 :
4425 :
4426 :
4427 0 : phaseAntExists = false;
4428 :
4429 :
4430 :
4431 0 : phaseAntRMSExists = false;
4432 :
4433 :
4434 :
4435 :
4436 :
4437 :
4438 :
4439 : }
4440 : else {
4441 :
4442 :
4443 0 : basebandName = row->basebandName;
4444 :
4445 0 : receiverBand = row->receiverBand;
4446 :
4447 0 : atmPhaseCorrection = row->atmPhaseCorrection;
4448 :
4449 0 : calDataId = row->calDataId;
4450 :
4451 0 : calReductionId = row->calReductionId;
4452 :
4453 :
4454 :
4455 :
4456 0 : startValidTime = row->startValidTime;
4457 :
4458 0 : endValidTime = row->endValidTime;
4459 :
4460 0 : numBaseline = row->numBaseline;
4461 :
4462 0 : numReceptor = row->numReceptor;
4463 :
4464 0 : ampli = row->ampli;
4465 :
4466 0 : antennaNames = row->antennaNames;
4467 :
4468 0 : baselineLengths = row->baselineLengths;
4469 :
4470 0 : decorrelationFactor = row->decorrelationFactor;
4471 :
4472 0 : direction = row->direction;
4473 :
4474 0 : frequencyRange = row->frequencyRange;
4475 :
4476 0 : integrationTime = row->integrationTime;
4477 :
4478 0 : phase = row->phase;
4479 :
4480 0 : polarizationTypes = row->polarizationTypes;
4481 :
4482 0 : phaseRMS = row->phaseRMS;
4483 :
4484 0 : statPhaseRMS = row->statPhaseRMS;
4485 :
4486 :
4487 :
4488 :
4489 0 : if (row->correctionValidityExists) {
4490 0 : correctionValidity = row->correctionValidity;
4491 0 : correctionValidityExists = true;
4492 : }
4493 : else
4494 0 : correctionValidityExists = false;
4495 :
4496 0 : if (row->numAntennaExists) {
4497 0 : numAntenna = row->numAntenna;
4498 0 : numAntennaExists = true;
4499 : }
4500 : else
4501 0 : numAntennaExists = false;
4502 :
4503 0 : if (row->singleAntennaNameExists) {
4504 0 : singleAntennaName = row->singleAntennaName;
4505 0 : singleAntennaNameExists = true;
4506 : }
4507 : else
4508 0 : singleAntennaNameExists = false;
4509 :
4510 0 : if (row->refAntennaNameExists) {
4511 0 : refAntennaName = row->refAntennaName;
4512 0 : refAntennaNameExists = true;
4513 : }
4514 : else
4515 0 : refAntennaNameExists = false;
4516 :
4517 0 : if (row->phaseAntExists) {
4518 0 : phaseAnt = row->phaseAnt;
4519 0 : phaseAntExists = true;
4520 : }
4521 : else
4522 0 : phaseAntExists = false;
4523 :
4524 0 : if (row->phaseAntRMSExists) {
4525 0 : phaseAntRMS = row->phaseAntRMS;
4526 0 : phaseAntRMSExists = true;
4527 : }
4528 : else
4529 0 : phaseAntRMSExists = false;
4530 :
4531 : }
4532 :
4533 0 : fromBinMethods["basebandName"] = &CalPhaseRow::basebandNameFromBin;
4534 0 : fromBinMethods["receiverBand"] = &CalPhaseRow::receiverBandFromBin;
4535 0 : fromBinMethods["atmPhaseCorrection"] = &CalPhaseRow::atmPhaseCorrectionFromBin;
4536 0 : fromBinMethods["calDataId"] = &CalPhaseRow::calDataIdFromBin;
4537 0 : fromBinMethods["calReductionId"] = &CalPhaseRow::calReductionIdFromBin;
4538 0 : fromBinMethods["startValidTime"] = &CalPhaseRow::startValidTimeFromBin;
4539 0 : fromBinMethods["endValidTime"] = &CalPhaseRow::endValidTimeFromBin;
4540 0 : fromBinMethods["numBaseline"] = &CalPhaseRow::numBaselineFromBin;
4541 0 : fromBinMethods["numReceptor"] = &CalPhaseRow::numReceptorFromBin;
4542 0 : fromBinMethods["ampli"] = &CalPhaseRow::ampliFromBin;
4543 0 : fromBinMethods["antennaNames"] = &CalPhaseRow::antennaNamesFromBin;
4544 0 : fromBinMethods["baselineLengths"] = &CalPhaseRow::baselineLengthsFromBin;
4545 0 : fromBinMethods["decorrelationFactor"] = &CalPhaseRow::decorrelationFactorFromBin;
4546 0 : fromBinMethods["direction"] = &CalPhaseRow::directionFromBin;
4547 0 : fromBinMethods["frequencyRange"] = &CalPhaseRow::frequencyRangeFromBin;
4548 0 : fromBinMethods["integrationTime"] = &CalPhaseRow::integrationTimeFromBin;
4549 0 : fromBinMethods["phase"] = &CalPhaseRow::phaseFromBin;
4550 0 : fromBinMethods["polarizationTypes"] = &CalPhaseRow::polarizationTypesFromBin;
4551 0 : fromBinMethods["phaseRMS"] = &CalPhaseRow::phaseRMSFromBin;
4552 0 : fromBinMethods["statPhaseRMS"] = &CalPhaseRow::statPhaseRMSFromBin;
4553 :
4554 :
4555 0 : fromBinMethods["correctionValidity"] = &CalPhaseRow::correctionValidityFromBin;
4556 0 : fromBinMethods["numAntenna"] = &CalPhaseRow::numAntennaFromBin;
4557 0 : fromBinMethods["singleAntennaName"] = &CalPhaseRow::singleAntennaNameFromBin;
4558 0 : fromBinMethods["refAntennaName"] = &CalPhaseRow::refAntennaNameFromBin;
4559 0 : fromBinMethods["phaseAnt"] = &CalPhaseRow::phaseAntFromBin;
4560 0 : fromBinMethods["phaseAntRMS"] = &CalPhaseRow::phaseAntRMSFromBin;
4561 :
4562 0 : }
4563 :
4564 :
4565 0 : bool CalPhaseRow::compareNoAutoInc(BasebandNameMod::BasebandName basebandName, ReceiverBandMod::ReceiverBand receiverBand, AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, int numBaseline, int numReceptor, std::vector<std::vector<float > > ampli, std::vector<std::vector<std::string > > antennaNames, std::vector<Length > baselineLengths, std::vector<std::vector<float > > decorrelationFactor, std::vector<Angle > direction, std::vector<Frequency > frequencyRange, Interval integrationTime, std::vector<std::vector<float > > phase, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, std::vector<std::vector<float > > phaseRMS, std::vector<std::vector<float > > statPhaseRMS) {
4566 : bool result;
4567 0 : result = true;
4568 :
4569 :
4570 :
4571 0 : result = result && (this->basebandName == basebandName);
4572 :
4573 0 : if (!result) return false;
4574 :
4575 :
4576 :
4577 :
4578 0 : result = result && (this->receiverBand == receiverBand);
4579 :
4580 0 : if (!result) return false;
4581 :
4582 :
4583 :
4584 :
4585 0 : result = result && (this->atmPhaseCorrection == atmPhaseCorrection);
4586 :
4587 0 : if (!result) return false;
4588 :
4589 :
4590 :
4591 :
4592 0 : result = result && (this->calDataId == calDataId);
4593 :
4594 0 : if (!result) return false;
4595 :
4596 :
4597 :
4598 :
4599 0 : result = result && (this->calReductionId == calReductionId);
4600 :
4601 0 : if (!result) return false;
4602 :
4603 :
4604 :
4605 :
4606 0 : result = result && (this->startValidTime == startValidTime);
4607 :
4608 0 : if (!result) return false;
4609 :
4610 :
4611 :
4612 :
4613 0 : result = result && (this->endValidTime == endValidTime);
4614 :
4615 0 : if (!result) return false;
4616 :
4617 :
4618 :
4619 :
4620 0 : result = result && (this->numBaseline == numBaseline);
4621 :
4622 0 : if (!result) return false;
4623 :
4624 :
4625 :
4626 :
4627 0 : result = result && (this->numReceptor == numReceptor);
4628 :
4629 0 : if (!result) return false;
4630 :
4631 :
4632 :
4633 :
4634 0 : result = result && (this->ampli == ampli);
4635 :
4636 0 : if (!result) return false;
4637 :
4638 :
4639 :
4640 :
4641 0 : result = result && (this->antennaNames == antennaNames);
4642 :
4643 0 : if (!result) return false;
4644 :
4645 :
4646 :
4647 :
4648 0 : result = result && (this->baselineLengths == baselineLengths);
4649 :
4650 0 : if (!result) return false;
4651 :
4652 :
4653 :
4654 :
4655 0 : result = result && (this->decorrelationFactor == decorrelationFactor);
4656 :
4657 0 : if (!result) return false;
4658 :
4659 :
4660 :
4661 :
4662 0 : result = result && (this->direction == direction);
4663 :
4664 0 : if (!result) return false;
4665 :
4666 :
4667 :
4668 :
4669 0 : result = result && (this->frequencyRange == frequencyRange);
4670 :
4671 0 : if (!result) return false;
4672 :
4673 :
4674 :
4675 :
4676 0 : result = result && (this->integrationTime == integrationTime);
4677 :
4678 0 : if (!result) return false;
4679 :
4680 :
4681 :
4682 :
4683 0 : result = result && (this->phase == phase);
4684 :
4685 0 : if (!result) return false;
4686 :
4687 :
4688 :
4689 :
4690 0 : result = result && (this->polarizationTypes == polarizationTypes);
4691 :
4692 0 : if (!result) return false;
4693 :
4694 :
4695 :
4696 :
4697 0 : result = result && (this->phaseRMS == phaseRMS);
4698 :
4699 0 : if (!result) return false;
4700 :
4701 :
4702 :
4703 :
4704 0 : result = result && (this->statPhaseRMS == statPhaseRMS);
4705 :
4706 0 : if (!result) return false;
4707 :
4708 :
4709 0 : return result;
4710 : }
4711 :
4712 :
4713 :
4714 0 : bool CalPhaseRow::compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, int numBaseline, int numReceptor, std::vector<std::vector<float > > ampli, std::vector<std::vector<std::string > > antennaNames, std::vector<Length > baselineLengths, std::vector<std::vector<float > > decorrelationFactor, std::vector<Angle > direction, std::vector<Frequency > frequencyRange, Interval integrationTime, std::vector<std::vector<float > > phase, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, std::vector<std::vector<float > > phaseRMS, std::vector<std::vector<float > > statPhaseRMS) {
4715 : bool result;
4716 0 : result = true;
4717 :
4718 :
4719 0 : if (!(this->startValidTime == startValidTime)) return false;
4720 :
4721 :
4722 :
4723 0 : if (!(this->endValidTime == endValidTime)) return false;
4724 :
4725 :
4726 :
4727 0 : if (!(this->numBaseline == numBaseline)) return false;
4728 :
4729 :
4730 :
4731 0 : if (!(this->numReceptor == numReceptor)) return false;
4732 :
4733 :
4734 :
4735 0 : if (!(this->ampli == ampli)) return false;
4736 :
4737 :
4738 :
4739 0 : if (!(this->antennaNames == antennaNames)) return false;
4740 :
4741 :
4742 :
4743 0 : if (!(this->baselineLengths == baselineLengths)) return false;
4744 :
4745 :
4746 :
4747 0 : if (!(this->decorrelationFactor == decorrelationFactor)) return false;
4748 :
4749 :
4750 :
4751 0 : if (!(this->direction == direction)) return false;
4752 :
4753 :
4754 :
4755 0 : if (!(this->frequencyRange == frequencyRange)) return false;
4756 :
4757 :
4758 :
4759 0 : if (!(this->integrationTime == integrationTime)) return false;
4760 :
4761 :
4762 :
4763 0 : if (!(this->phase == phase)) return false;
4764 :
4765 :
4766 :
4767 0 : if (!(this->polarizationTypes == polarizationTypes)) return false;
4768 :
4769 :
4770 :
4771 0 : if (!(this->phaseRMS == phaseRMS)) return false;
4772 :
4773 :
4774 :
4775 0 : if (!(this->statPhaseRMS == statPhaseRMS)) return false;
4776 :
4777 :
4778 0 : return result;
4779 : }
4780 :
4781 :
4782 : /**
4783 : * Return true if all required attributes of the value part are equal to their homologues
4784 : * in x and false otherwise.
4785 : *
4786 :
4787 : * @param x a pointer on the CalPhaseRow whose required attributes of the value part
4788 :
4789 : * will be compared with those of this.
4790 : * @return a boolean.
4791 : */
4792 0 : bool CalPhaseRow::equalByRequiredValue(CalPhaseRow* x ) {
4793 :
4794 :
4795 0 : if (this->startValidTime != x->startValidTime) return false;
4796 :
4797 0 : if (this->endValidTime != x->endValidTime) return false;
4798 :
4799 0 : if (this->numBaseline != x->numBaseline) return false;
4800 :
4801 0 : if (this->numReceptor != x->numReceptor) return false;
4802 :
4803 0 : if (this->ampli != x->ampli) return false;
4804 :
4805 0 : if (this->antennaNames != x->antennaNames) return false;
4806 :
4807 0 : if (this->baselineLengths != x->baselineLengths) return false;
4808 :
4809 0 : if (this->decorrelationFactor != x->decorrelationFactor) return false;
4810 :
4811 0 : if (this->direction != x->direction) return false;
4812 :
4813 0 : if (this->frequencyRange != x->frequencyRange) return false;
4814 :
4815 0 : if (this->integrationTime != x->integrationTime) return false;
4816 :
4817 0 : if (this->phase != x->phase) return false;
4818 :
4819 0 : if (this->polarizationTypes != x->polarizationTypes) return false;
4820 :
4821 0 : if (this->phaseRMS != x->phaseRMS) return false;
4822 :
4823 0 : if (this->statPhaseRMS != x->statPhaseRMS) return false;
4824 :
4825 :
4826 0 : return true;
4827 : }
4828 :
4829 : /*
4830 : map<string, CalPhaseAttributeFromBin> CalPhaseRow::initFromBinMethods() {
4831 : map<string, CalPhaseAttributeFromBin> result;
4832 :
4833 : result["basebandName"] = &CalPhaseRow::basebandNameFromBin;
4834 : result["receiverBand"] = &CalPhaseRow::receiverBandFromBin;
4835 : result["atmPhaseCorrection"] = &CalPhaseRow::atmPhaseCorrectionFromBin;
4836 : result["calDataId"] = &CalPhaseRow::calDataIdFromBin;
4837 : result["calReductionId"] = &CalPhaseRow::calReductionIdFromBin;
4838 : result["startValidTime"] = &CalPhaseRow::startValidTimeFromBin;
4839 : result["endValidTime"] = &CalPhaseRow::endValidTimeFromBin;
4840 : result["numBaseline"] = &CalPhaseRow::numBaselineFromBin;
4841 : result["numReceptor"] = &CalPhaseRow::numReceptorFromBin;
4842 : result["ampli"] = &CalPhaseRow::ampliFromBin;
4843 : result["antennaNames"] = &CalPhaseRow::antennaNamesFromBin;
4844 : result["baselineLengths"] = &CalPhaseRow::baselineLengthsFromBin;
4845 : result["decorrelationFactor"] = &CalPhaseRow::decorrelationFactorFromBin;
4846 : result["direction"] = &CalPhaseRow::directionFromBin;
4847 : result["frequencyRange"] = &CalPhaseRow::frequencyRangeFromBin;
4848 : result["integrationTime"] = &CalPhaseRow::integrationTimeFromBin;
4849 : result["phase"] = &CalPhaseRow::phaseFromBin;
4850 : result["polarizationTypes"] = &CalPhaseRow::polarizationTypesFromBin;
4851 : result["phaseRMS"] = &CalPhaseRow::phaseRMSFromBin;
4852 : result["statPhaseRMS"] = &CalPhaseRow::statPhaseRMSFromBin;
4853 :
4854 :
4855 : result["correctionValidity"] = &CalPhaseRow::correctionValidityFromBin;
4856 : result["numAntenna"] = &CalPhaseRow::numAntennaFromBin;
4857 : result["singleAntennaName"] = &CalPhaseRow::singleAntennaNameFromBin;
4858 : result["refAntennaName"] = &CalPhaseRow::refAntennaNameFromBin;
4859 : result["phaseAnt"] = &CalPhaseRow::phaseAntFromBin;
4860 : result["phaseAntRMS"] = &CalPhaseRow::phaseAntRMSFromBin;
4861 :
4862 :
4863 : return result;
4864 : }
4865 : */
4866 : } // End namespace asdm
4867 :
|
