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 SysCalRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/SysCalRow.h>
39 : #include <alma/ASDM/SysCalTable.h>
40 :
41 : #include <alma/ASDM/AntennaTable.h>
42 : #include <alma/ASDM/AntennaRow.h>
43 :
44 : #include <alma/ASDM/FeedTable.h>
45 : #include <alma/ASDM/FeedRow.h>
46 :
47 : #include <alma/ASDM/SpectralWindowTable.h>
48 : #include <alma/ASDM/SpectralWindowRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::SysCalRow;
53 : using asdm::SysCalTable;
54 :
55 : using asdm::AntennaTable;
56 : using asdm::AntennaRow;
57 :
58 : using asdm::FeedTable;
59 : using asdm::FeedRow;
60 :
61 : using asdm::SpectralWindowTable;
62 : using asdm::SpectralWindowRow;
63 :
64 :
65 : #include <alma/ASDM/Parser.h>
66 :
67 : #include <alma/ASDM/EnumerationParser.h>
68 : #include <alma/ASDM/ASDMValuesParser.h>
69 :
70 : #include <alma/ASDM/InvalidArgumentException.h>
71 :
72 : using namespace std;
73 :
74 : namespace asdm {
75 0 : SysCalRow::~SysCalRow() {
76 0 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 0 : SysCalTable &SysCalRow::getTable() const {
82 0 : return table;
83 : }
84 :
85 0 : bool SysCalRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 0 : void SysCalRow::isAdded(bool added) {
90 0 : hasBeenAdded = added;
91 0 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::SysCalRowIDL;
95 : #endif
96 :
97 : #ifndef WITHOUT_ACS
98 : /**
99 : * Return this row in the form of an IDL struct.
100 : * @return The values of this row as a SysCalRowIDL struct.
101 : */
102 : SysCalRowIDL *SysCalRow::toIDL() const {
103 : SysCalRowIDL *x = new SysCalRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->timeInterval = timeInterval.toIDLArrayTimeInterval();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 : x->numReceptor = numReceptor;
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 : x->numChan = numChan;
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 : x->tcalFlagExists = tcalFlagExists;
146 :
147 :
148 :
149 :
150 : x->tcalFlag = tcalFlag;
151 :
152 :
153 :
154 :
155 :
156 :
157 :
158 :
159 : x->tcalSpectrumExists = tcalSpectrumExists;
160 :
161 :
162 :
163 : x->tcalSpectrum.length(tcalSpectrum.size());
164 : for (unsigned int i = 0; i < tcalSpectrum.size(); i++) {
165 : x->tcalSpectrum[i].length(tcalSpectrum.at(i).size());
166 : }
167 :
168 : for (unsigned int i = 0; i < tcalSpectrum.size() ; i++)
169 : for (unsigned int j = 0; j < tcalSpectrum.at(i).size(); j++)
170 :
171 : x->tcalSpectrum[i][j]= tcalSpectrum.at(i).at(j).toIDLTemperature();
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 : x->trxFlagExists = trxFlagExists;
182 :
183 :
184 :
185 :
186 : x->trxFlag = trxFlag;
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 :
195 : x->trxSpectrumExists = trxSpectrumExists;
196 :
197 :
198 :
199 : x->trxSpectrum.length(trxSpectrum.size());
200 : for (unsigned int i = 0; i < trxSpectrum.size(); i++) {
201 : x->trxSpectrum[i].length(trxSpectrum.at(i).size());
202 : }
203 :
204 : for (unsigned int i = 0; i < trxSpectrum.size() ; i++)
205 : for (unsigned int j = 0; j < trxSpectrum.at(i).size(); j++)
206 :
207 : x->trxSpectrum[i][j]= trxSpectrum.at(i).at(j).toIDLTemperature();
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 : x->tskyFlagExists = tskyFlagExists;
218 :
219 :
220 :
221 :
222 : x->tskyFlag = tskyFlag;
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 : x->tskySpectrumExists = tskySpectrumExists;
232 :
233 :
234 :
235 : x->tskySpectrum.length(tskySpectrum.size());
236 : for (unsigned int i = 0; i < tskySpectrum.size(); i++) {
237 : x->tskySpectrum[i].length(tskySpectrum.at(i).size());
238 : }
239 :
240 : for (unsigned int i = 0; i < tskySpectrum.size() ; i++)
241 : for (unsigned int j = 0; j < tskySpectrum.at(i).size(); j++)
242 :
243 : x->tskySpectrum[i][j]= tskySpectrum.at(i).at(j).toIDLTemperature();
244 :
245 :
246 :
247 :
248 :
249 :
250 :
251 :
252 :
253 : x->tsysFlagExists = tsysFlagExists;
254 :
255 :
256 :
257 :
258 : x->tsysFlag = tsysFlag;
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 : x->tsysSpectrumExists = tsysSpectrumExists;
268 :
269 :
270 :
271 : x->tsysSpectrum.length(tsysSpectrum.size());
272 : for (unsigned int i = 0; i < tsysSpectrum.size(); i++) {
273 : x->tsysSpectrum[i].length(tsysSpectrum.at(i).size());
274 : }
275 :
276 : for (unsigned int i = 0; i < tsysSpectrum.size() ; i++)
277 : for (unsigned int j = 0; j < tsysSpectrum.at(i).size(); j++)
278 :
279 : x->tsysSpectrum[i][j]= tsysSpectrum.at(i).at(j).toIDLTemperature();
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 : x->tantFlagExists = tantFlagExists;
290 :
291 :
292 :
293 :
294 : x->tantFlag = tantFlag;
295 :
296 :
297 :
298 :
299 :
300 :
301 :
302 :
303 : x->tantSpectrumExists = tantSpectrumExists;
304 :
305 :
306 :
307 : x->tantSpectrum.length(tantSpectrum.size());
308 : for (unsigned int i = 0; i < tantSpectrum.size(); i++) {
309 : x->tantSpectrum[i].length(tantSpectrum.at(i).size());
310 : }
311 :
312 : for (unsigned int i = 0; i < tantSpectrum.size() ; i++)
313 : for (unsigned int j = 0; j < tantSpectrum.at(i).size(); j++)
314 :
315 :
316 : x->tantSpectrum[i][j] = tantSpectrum.at(i).at(j);
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 : x->tantTsysFlagExists = tantTsysFlagExists;
328 :
329 :
330 :
331 :
332 : x->tantTsysFlag = tantTsysFlag;
333 :
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 : x->tantTsysSpectrumExists = tantTsysSpectrumExists;
342 :
343 :
344 :
345 : x->tantTsysSpectrum.length(tantTsysSpectrum.size());
346 : for (unsigned int i = 0; i < tantTsysSpectrum.size(); i++) {
347 : x->tantTsysSpectrum[i].length(tantTsysSpectrum.at(i).size());
348 : }
349 :
350 : for (unsigned int i = 0; i < tantTsysSpectrum.size() ; i++)
351 : for (unsigned int j = 0; j < tantTsysSpectrum.at(i).size(); j++)
352 :
353 :
354 : x->tantTsysSpectrum[i][j] = tantTsysSpectrum.at(i).at(j);
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 : x->phaseDiffFlagExists = phaseDiffFlagExists;
366 :
367 :
368 :
369 :
370 : x->phaseDiffFlag = phaseDiffFlag;
371 :
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 : x->phaseDiffSpectrumExists = phaseDiffSpectrumExists;
380 :
381 :
382 :
383 : x->phaseDiffSpectrum.length(phaseDiffSpectrum.size());
384 : for (unsigned int i = 0; i < phaseDiffSpectrum.size(); i++) {
385 : x->phaseDiffSpectrum[i].length(phaseDiffSpectrum.at(i).size());
386 : }
387 :
388 : for (unsigned int i = 0; i < phaseDiffSpectrum.size() ; i++)
389 : for (unsigned int j = 0; j < phaseDiffSpectrum.at(i).size(); j++)
390 :
391 :
392 : x->phaseDiffSpectrum[i][j] = phaseDiffSpectrum.at(i).at(j);
393 :
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 : x->antennaId = antennaId.toIDLTag();
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 :
420 :
421 : x->feedId = feedId;
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 :
433 : x->spectralWindowId = spectralWindowId.toIDLTag();
434 :
435 :
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 :
446 :
447 : return x;
448 :
449 : }
450 :
451 : void SysCalRow::toIDL(asdmIDL::SysCalRowIDL& x) const {
452 : // Set the x's fields.
453 :
454 :
455 :
456 :
457 :
458 :
459 :
460 : x.timeInterval = timeInterval.toIDLArrayTimeInterval();
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 : x.numReceptor = numReceptor;
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 :
481 :
482 :
483 : x.numChan = numChan;
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 : x.tcalFlagExists = tcalFlagExists;
493 :
494 :
495 :
496 :
497 : x.tcalFlag = tcalFlag;
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 :
506 : x.tcalSpectrumExists = tcalSpectrumExists;
507 :
508 :
509 :
510 : x.tcalSpectrum.length(tcalSpectrum.size());
511 : for (unsigned int i = 0; i < tcalSpectrum.size(); i++) {
512 : x.tcalSpectrum[i].length(tcalSpectrum.at(i).size());
513 : }
514 :
515 : for (unsigned int i = 0; i < tcalSpectrum.size() ; i++)
516 : for (unsigned int j = 0; j < tcalSpectrum.at(i).size(); j++)
517 :
518 : x.tcalSpectrum[i][j]= tcalSpectrum.at(i).at(j).toIDLTemperature();
519 :
520 :
521 :
522 :
523 :
524 :
525 :
526 :
527 :
528 : x.trxFlagExists = trxFlagExists;
529 :
530 :
531 :
532 :
533 : x.trxFlag = trxFlag;
534 :
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 : x.trxSpectrumExists = trxSpectrumExists;
543 :
544 :
545 :
546 : x.trxSpectrum.length(trxSpectrum.size());
547 : for (unsigned int i = 0; i < trxSpectrum.size(); i++) {
548 : x.trxSpectrum[i].length(trxSpectrum.at(i).size());
549 : }
550 :
551 : for (unsigned int i = 0; i < trxSpectrum.size() ; i++)
552 : for (unsigned int j = 0; j < trxSpectrum.at(i).size(); j++)
553 :
554 : x.trxSpectrum[i][j]= trxSpectrum.at(i).at(j).toIDLTemperature();
555 :
556 :
557 :
558 :
559 :
560 :
561 :
562 :
563 :
564 : x.tskyFlagExists = tskyFlagExists;
565 :
566 :
567 :
568 :
569 : x.tskyFlag = tskyFlag;
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 : x.tskySpectrumExists = tskySpectrumExists;
579 :
580 :
581 :
582 : x.tskySpectrum.length(tskySpectrum.size());
583 : for (unsigned int i = 0; i < tskySpectrum.size(); i++) {
584 : x.tskySpectrum[i].length(tskySpectrum.at(i).size());
585 : }
586 :
587 : for (unsigned int i = 0; i < tskySpectrum.size() ; i++)
588 : for (unsigned int j = 0; j < tskySpectrum.at(i).size(); j++)
589 :
590 : x.tskySpectrum[i][j]= tskySpectrum.at(i).at(j).toIDLTemperature();
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 : x.tsysFlagExists = tsysFlagExists;
601 :
602 :
603 :
604 :
605 : x.tsysFlag = tsysFlag;
606 :
607 :
608 :
609 :
610 :
611 :
612 :
613 :
614 : x.tsysSpectrumExists = tsysSpectrumExists;
615 :
616 :
617 :
618 : x.tsysSpectrum.length(tsysSpectrum.size());
619 : for (unsigned int i = 0; i < tsysSpectrum.size(); i++) {
620 : x.tsysSpectrum[i].length(tsysSpectrum.at(i).size());
621 : }
622 :
623 : for (unsigned int i = 0; i < tsysSpectrum.size() ; i++)
624 : for (unsigned int j = 0; j < tsysSpectrum.at(i).size(); j++)
625 :
626 : x.tsysSpectrum[i][j]= tsysSpectrum.at(i).at(j).toIDLTemperature();
627 :
628 :
629 :
630 :
631 :
632 :
633 :
634 :
635 :
636 : x.tantFlagExists = tantFlagExists;
637 :
638 :
639 :
640 :
641 : x.tantFlag = tantFlag;
642 :
643 :
644 :
645 :
646 :
647 :
648 :
649 :
650 : x.tantSpectrumExists = tantSpectrumExists;
651 :
652 :
653 :
654 : x.tantSpectrum.length(tantSpectrum.size());
655 : for (unsigned int i = 0; i < tantSpectrum.size(); i++) {
656 : x.tantSpectrum[i].length(tantSpectrum.at(i).size());
657 : }
658 :
659 : for (unsigned int i = 0; i < tantSpectrum.size() ; i++)
660 : for (unsigned int j = 0; j < tantSpectrum.at(i).size(); j++)
661 :
662 :
663 : x.tantSpectrum[i][j] = tantSpectrum.at(i).at(j);
664 :
665 :
666 :
667 :
668 :
669 :
670 :
671 :
672 :
673 :
674 : x.tantTsysFlagExists = tantTsysFlagExists;
675 :
676 :
677 :
678 :
679 : x.tantTsysFlag = tantTsysFlag;
680 :
681 :
682 :
683 :
684 :
685 :
686 :
687 :
688 : x.tantTsysSpectrumExists = tantTsysSpectrumExists;
689 :
690 :
691 :
692 : x.tantTsysSpectrum.length(tantTsysSpectrum.size());
693 : for (unsigned int i = 0; i < tantTsysSpectrum.size(); i++) {
694 : x.tantTsysSpectrum[i].length(tantTsysSpectrum.at(i).size());
695 : }
696 :
697 : for (unsigned int i = 0; i < tantTsysSpectrum.size() ; i++)
698 : for (unsigned int j = 0; j < tantTsysSpectrum.at(i).size(); j++)
699 :
700 :
701 : x.tantTsysSpectrum[i][j] = tantTsysSpectrum.at(i).at(j);
702 :
703 :
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 : x.phaseDiffFlagExists = phaseDiffFlagExists;
713 :
714 :
715 :
716 :
717 : x.phaseDiffFlag = phaseDiffFlag;
718 :
719 :
720 :
721 :
722 :
723 :
724 :
725 :
726 : x.phaseDiffSpectrumExists = phaseDiffSpectrumExists;
727 :
728 :
729 :
730 : x.phaseDiffSpectrum.length(phaseDiffSpectrum.size());
731 : for (unsigned int i = 0; i < phaseDiffSpectrum.size(); i++) {
732 : x.phaseDiffSpectrum[i].length(phaseDiffSpectrum.at(i).size());
733 : }
734 :
735 : for (unsigned int i = 0; i < phaseDiffSpectrum.size() ; i++)
736 : for (unsigned int j = 0; j < phaseDiffSpectrum.at(i).size(); j++)
737 :
738 :
739 : x.phaseDiffSpectrum[i][j] = phaseDiffSpectrum.at(i).at(j);
740 :
741 :
742 :
743 :
744 :
745 :
746 :
747 :
748 :
749 :
750 :
751 :
752 :
753 :
754 :
755 :
756 : x.antennaId = antennaId.toIDLTag();
757 :
758 :
759 :
760 :
761 :
762 :
763 :
764 :
765 :
766 :
767 :
768 : x.feedId = feedId;
769 :
770 :
771 :
772 :
773 :
774 :
775 :
776 :
777 :
778 :
779 :
780 : x.spectralWindowId = spectralWindowId.toIDLTag();
781 :
782 :
783 :
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 :
793 :
794 : }
795 : #endif
796 :
797 :
798 : #ifndef WITHOUT_ACS
799 : /**
800 : * Fill the values of this row from the IDL struct SysCalRowIDL.
801 : * @param x The IDL struct containing the values used to fill this row.
802 : */
803 : void SysCalRow::setFromIDL (SysCalRowIDL x){
804 : try {
805 : // Fill the values from x.
806 :
807 :
808 :
809 :
810 :
811 :
812 : setTimeInterval(ArrayTimeInterval (x.timeInterval));
813 :
814 :
815 :
816 :
817 :
818 :
819 :
820 :
821 :
822 : setNumReceptor(x.numReceptor);
823 :
824 :
825 :
826 :
827 :
828 :
829 :
830 :
831 :
832 : setNumChan(x.numChan);
833 :
834 :
835 :
836 :
837 :
838 :
839 :
840 : tcalFlagExists = x.tcalFlagExists;
841 : if (x.tcalFlagExists) {
842 :
843 :
844 :
845 : setTcalFlag(x.tcalFlag);
846 :
847 :
848 :
849 : }
850 :
851 :
852 :
853 :
854 :
855 : tcalSpectrumExists = x.tcalSpectrumExists;
856 : if (x.tcalSpectrumExists) {
857 :
858 :
859 :
860 : tcalSpectrum .clear();
861 :
862 : vector<Temperature> v_aux_tcalSpectrum;
863 :
864 : for (unsigned int i = 0; i < x.tcalSpectrum.length(); ++i) {
865 : v_aux_tcalSpectrum.clear();
866 : for (unsigned int j = 0; j < x.tcalSpectrum[0].length(); ++j) {
867 :
868 : v_aux_tcalSpectrum.push_back(Temperature (x.tcalSpectrum[i][j]));
869 :
870 : }
871 : tcalSpectrum.push_back(v_aux_tcalSpectrum);
872 : }
873 :
874 :
875 :
876 : }
877 :
878 :
879 :
880 :
881 :
882 : trxFlagExists = x.trxFlagExists;
883 : if (x.trxFlagExists) {
884 :
885 :
886 :
887 : setTrxFlag(x.trxFlag);
888 :
889 :
890 :
891 : }
892 :
893 :
894 :
895 :
896 :
897 : trxSpectrumExists = x.trxSpectrumExists;
898 : if (x.trxSpectrumExists) {
899 :
900 :
901 :
902 : trxSpectrum .clear();
903 :
904 : vector<Temperature> v_aux_trxSpectrum;
905 :
906 : for (unsigned int i = 0; i < x.trxSpectrum.length(); ++i) {
907 : v_aux_trxSpectrum.clear();
908 : for (unsigned int j = 0; j < x.trxSpectrum[0].length(); ++j) {
909 :
910 : v_aux_trxSpectrum.push_back(Temperature (x.trxSpectrum[i][j]));
911 :
912 : }
913 : trxSpectrum.push_back(v_aux_trxSpectrum);
914 : }
915 :
916 :
917 :
918 : }
919 :
920 :
921 :
922 :
923 :
924 : tskyFlagExists = x.tskyFlagExists;
925 : if (x.tskyFlagExists) {
926 :
927 :
928 :
929 : setTskyFlag(x.tskyFlag);
930 :
931 :
932 :
933 : }
934 :
935 :
936 :
937 :
938 :
939 : tskySpectrumExists = x.tskySpectrumExists;
940 : if (x.tskySpectrumExists) {
941 :
942 :
943 :
944 : tskySpectrum .clear();
945 :
946 : vector<Temperature> v_aux_tskySpectrum;
947 :
948 : for (unsigned int i = 0; i < x.tskySpectrum.length(); ++i) {
949 : v_aux_tskySpectrum.clear();
950 : for (unsigned int j = 0; j < x.tskySpectrum[0].length(); ++j) {
951 :
952 : v_aux_tskySpectrum.push_back(Temperature (x.tskySpectrum[i][j]));
953 :
954 : }
955 : tskySpectrum.push_back(v_aux_tskySpectrum);
956 : }
957 :
958 :
959 :
960 : }
961 :
962 :
963 :
964 :
965 :
966 : tsysFlagExists = x.tsysFlagExists;
967 : if (x.tsysFlagExists) {
968 :
969 :
970 :
971 : setTsysFlag(x.tsysFlag);
972 :
973 :
974 :
975 : }
976 :
977 :
978 :
979 :
980 :
981 : tsysSpectrumExists = x.tsysSpectrumExists;
982 : if (x.tsysSpectrumExists) {
983 :
984 :
985 :
986 : tsysSpectrum .clear();
987 :
988 : vector<Temperature> v_aux_tsysSpectrum;
989 :
990 : for (unsigned int i = 0; i < x.tsysSpectrum.length(); ++i) {
991 : v_aux_tsysSpectrum.clear();
992 : for (unsigned int j = 0; j < x.tsysSpectrum[0].length(); ++j) {
993 :
994 : v_aux_tsysSpectrum.push_back(Temperature (x.tsysSpectrum[i][j]));
995 :
996 : }
997 : tsysSpectrum.push_back(v_aux_tsysSpectrum);
998 : }
999 :
1000 :
1001 :
1002 : }
1003 :
1004 :
1005 :
1006 :
1007 :
1008 : tantFlagExists = x.tantFlagExists;
1009 : if (x.tantFlagExists) {
1010 :
1011 :
1012 :
1013 : setTantFlag(x.tantFlag);
1014 :
1015 :
1016 :
1017 : }
1018 :
1019 :
1020 :
1021 :
1022 :
1023 : tantSpectrumExists = x.tantSpectrumExists;
1024 : if (x.tantSpectrumExists) {
1025 :
1026 :
1027 :
1028 : tantSpectrum .clear();
1029 :
1030 : vector<float> v_aux_tantSpectrum;
1031 :
1032 : for (unsigned int i = 0; i < x.tantSpectrum.length(); ++i) {
1033 : v_aux_tantSpectrum.clear();
1034 : for (unsigned int j = 0; j < x.tantSpectrum[0].length(); ++j) {
1035 :
1036 : v_aux_tantSpectrum.push_back(x.tantSpectrum[i][j]);
1037 :
1038 : }
1039 : tantSpectrum.push_back(v_aux_tantSpectrum);
1040 : }
1041 :
1042 :
1043 :
1044 : }
1045 :
1046 :
1047 :
1048 :
1049 :
1050 : tantTsysFlagExists = x.tantTsysFlagExists;
1051 : if (x.tantTsysFlagExists) {
1052 :
1053 :
1054 :
1055 : setTantTsysFlag(x.tantTsysFlag);
1056 :
1057 :
1058 :
1059 : }
1060 :
1061 :
1062 :
1063 :
1064 :
1065 : tantTsysSpectrumExists = x.tantTsysSpectrumExists;
1066 : if (x.tantTsysSpectrumExists) {
1067 :
1068 :
1069 :
1070 : tantTsysSpectrum .clear();
1071 :
1072 : vector<float> v_aux_tantTsysSpectrum;
1073 :
1074 : for (unsigned int i = 0; i < x.tantTsysSpectrum.length(); ++i) {
1075 : v_aux_tantTsysSpectrum.clear();
1076 : for (unsigned int j = 0; j < x.tantTsysSpectrum[0].length(); ++j) {
1077 :
1078 : v_aux_tantTsysSpectrum.push_back(x.tantTsysSpectrum[i][j]);
1079 :
1080 : }
1081 : tantTsysSpectrum.push_back(v_aux_tantTsysSpectrum);
1082 : }
1083 :
1084 :
1085 :
1086 : }
1087 :
1088 :
1089 :
1090 :
1091 :
1092 : phaseDiffFlagExists = x.phaseDiffFlagExists;
1093 : if (x.phaseDiffFlagExists) {
1094 :
1095 :
1096 :
1097 : setPhaseDiffFlag(x.phaseDiffFlag);
1098 :
1099 :
1100 :
1101 : }
1102 :
1103 :
1104 :
1105 :
1106 :
1107 : phaseDiffSpectrumExists = x.phaseDiffSpectrumExists;
1108 : if (x.phaseDiffSpectrumExists) {
1109 :
1110 :
1111 :
1112 : phaseDiffSpectrum .clear();
1113 :
1114 : vector<float> v_aux_phaseDiffSpectrum;
1115 :
1116 : for (unsigned int i = 0; i < x.phaseDiffSpectrum.length(); ++i) {
1117 : v_aux_phaseDiffSpectrum.clear();
1118 : for (unsigned int j = 0; j < x.phaseDiffSpectrum[0].length(); ++j) {
1119 :
1120 : v_aux_phaseDiffSpectrum.push_back(x.phaseDiffSpectrum[i][j]);
1121 :
1122 : }
1123 : phaseDiffSpectrum.push_back(v_aux_phaseDiffSpectrum);
1124 : }
1125 :
1126 :
1127 :
1128 : }
1129 :
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 : setAntennaId(Tag (x.antennaId));
1140 :
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 :
1148 :
1149 : setFeedId(x.feedId);
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 :
1157 :
1158 :
1159 : setSpectralWindowId(Tag (x.spectralWindowId));
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 :
1167 :
1168 :
1169 :
1170 :
1171 :
1172 :
1173 : } catch (const IllegalAccessException &err) {
1174 : throw ConversionException (err.getMessage(),"SysCal");
1175 : }
1176 : }
1177 : #endif
1178 :
1179 : /**
1180 : * Return this row in the form of an XML string.
1181 : * @return The values of this row as an XML string.
1182 : */
1183 0 : string SysCalRow::toXML() const {
1184 0 : string buf;
1185 0 : buf.append("<row> \n");
1186 :
1187 :
1188 :
1189 :
1190 :
1191 :
1192 0 : Parser::toXML(timeInterval, "timeInterval", buf);
1193 :
1194 :
1195 :
1196 :
1197 :
1198 :
1199 :
1200 0 : Parser::toXML(numReceptor, "numReceptor", buf);
1201 :
1202 :
1203 :
1204 :
1205 :
1206 :
1207 :
1208 0 : Parser::toXML(numChan, "numChan", buf);
1209 :
1210 :
1211 :
1212 :
1213 :
1214 :
1215 0 : if (tcalFlagExists) {
1216 :
1217 :
1218 0 : Parser::toXML(tcalFlag, "tcalFlag", buf);
1219 :
1220 :
1221 : }
1222 :
1223 :
1224 :
1225 :
1226 :
1227 0 : if (tcalSpectrumExists) {
1228 :
1229 :
1230 0 : Parser::toXML(tcalSpectrum, "tcalSpectrum", buf);
1231 :
1232 :
1233 : }
1234 :
1235 :
1236 :
1237 :
1238 :
1239 0 : if (trxFlagExists) {
1240 :
1241 :
1242 0 : Parser::toXML(trxFlag, "trxFlag", buf);
1243 :
1244 :
1245 : }
1246 :
1247 :
1248 :
1249 :
1250 :
1251 0 : if (trxSpectrumExists) {
1252 :
1253 :
1254 0 : Parser::toXML(trxSpectrum, "trxSpectrum", buf);
1255 :
1256 :
1257 : }
1258 :
1259 :
1260 :
1261 :
1262 :
1263 0 : if (tskyFlagExists) {
1264 :
1265 :
1266 0 : Parser::toXML(tskyFlag, "tskyFlag", buf);
1267 :
1268 :
1269 : }
1270 :
1271 :
1272 :
1273 :
1274 :
1275 0 : if (tskySpectrumExists) {
1276 :
1277 :
1278 0 : Parser::toXML(tskySpectrum, "tskySpectrum", buf);
1279 :
1280 :
1281 : }
1282 :
1283 :
1284 :
1285 :
1286 :
1287 0 : if (tsysFlagExists) {
1288 :
1289 :
1290 0 : Parser::toXML(tsysFlag, "tsysFlag", buf);
1291 :
1292 :
1293 : }
1294 :
1295 :
1296 :
1297 :
1298 :
1299 0 : if (tsysSpectrumExists) {
1300 :
1301 :
1302 0 : Parser::toXML(tsysSpectrum, "tsysSpectrum", buf);
1303 :
1304 :
1305 : }
1306 :
1307 :
1308 :
1309 :
1310 :
1311 0 : if (tantFlagExists) {
1312 :
1313 :
1314 0 : Parser::toXML(tantFlag, "tantFlag", buf);
1315 :
1316 :
1317 : }
1318 :
1319 :
1320 :
1321 :
1322 :
1323 0 : if (tantSpectrumExists) {
1324 :
1325 :
1326 0 : Parser::toXML(tantSpectrum, "tantSpectrum", buf);
1327 :
1328 :
1329 : }
1330 :
1331 :
1332 :
1333 :
1334 :
1335 0 : if (tantTsysFlagExists) {
1336 :
1337 :
1338 0 : Parser::toXML(tantTsysFlag, "tantTsysFlag", buf);
1339 :
1340 :
1341 : }
1342 :
1343 :
1344 :
1345 :
1346 :
1347 0 : if (tantTsysSpectrumExists) {
1348 :
1349 :
1350 0 : Parser::toXML(tantTsysSpectrum, "tantTsysSpectrum", buf);
1351 :
1352 :
1353 : }
1354 :
1355 :
1356 :
1357 :
1358 :
1359 0 : if (phaseDiffFlagExists) {
1360 :
1361 :
1362 0 : Parser::toXML(phaseDiffFlag, "phaseDiffFlag", buf);
1363 :
1364 :
1365 : }
1366 :
1367 :
1368 :
1369 :
1370 :
1371 0 : if (phaseDiffSpectrumExists) {
1372 :
1373 :
1374 0 : Parser::toXML(phaseDiffSpectrum, "phaseDiffSpectrum", buf);
1375 :
1376 :
1377 : }
1378 :
1379 :
1380 :
1381 :
1382 :
1383 :
1384 :
1385 :
1386 :
1387 0 : Parser::toXML(antennaId, "antennaId", buf);
1388 :
1389 :
1390 :
1391 :
1392 :
1393 :
1394 :
1395 0 : Parser::toXML(feedId, "feedId", buf);
1396 :
1397 :
1398 :
1399 :
1400 :
1401 :
1402 :
1403 0 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
1404 :
1405 :
1406 :
1407 :
1408 :
1409 :
1410 :
1411 :
1412 :
1413 :
1414 :
1415 :
1416 :
1417 0 : buf.append("</row>\n");
1418 0 : return buf;
1419 0 : }
1420 :
1421 : /**
1422 : * Fill the values of this row from an XML string
1423 : * that was produced by the toXML() method.
1424 : * @param x The XML string being used to set the values of this row.
1425 : */
1426 0 : void SysCalRow::setFromXML (string rowDoc) {
1427 0 : Parser row(rowDoc);
1428 0 : string s = "";
1429 : try {
1430 :
1431 :
1432 :
1433 :
1434 :
1435 0 : setTimeInterval(Parser::getArrayTimeInterval("timeInterval","SysCal",rowDoc));
1436 :
1437 :
1438 :
1439 :
1440 :
1441 :
1442 :
1443 0 : setNumReceptor(Parser::getInteger("numReceptor","SysCal",rowDoc));
1444 :
1445 :
1446 :
1447 :
1448 :
1449 :
1450 :
1451 0 : setNumChan(Parser::getInteger("numChan","SysCal",rowDoc));
1452 :
1453 :
1454 :
1455 :
1456 :
1457 :
1458 0 : if (row.isStr("<tcalFlag>")) {
1459 :
1460 0 : setTcalFlag(Parser::getBoolean("tcalFlag","SysCal",rowDoc));
1461 :
1462 : }
1463 :
1464 :
1465 :
1466 :
1467 :
1468 0 : if (row.isStr("<tcalSpectrum>")) {
1469 :
1470 :
1471 0 : setTcalSpectrum(Parser::get2DTemperature("tcalSpectrum","SysCal",rowDoc));
1472 :
1473 :
1474 : }
1475 :
1476 :
1477 :
1478 :
1479 :
1480 0 : if (row.isStr("<trxFlag>")) {
1481 :
1482 0 : setTrxFlag(Parser::getBoolean("trxFlag","SysCal",rowDoc));
1483 :
1484 : }
1485 :
1486 :
1487 :
1488 :
1489 :
1490 0 : if (row.isStr("<trxSpectrum>")) {
1491 :
1492 :
1493 0 : setTrxSpectrum(Parser::get2DTemperature("trxSpectrum","SysCal",rowDoc));
1494 :
1495 :
1496 : }
1497 :
1498 :
1499 :
1500 :
1501 :
1502 0 : if (row.isStr("<tskyFlag>")) {
1503 :
1504 0 : setTskyFlag(Parser::getBoolean("tskyFlag","SysCal",rowDoc));
1505 :
1506 : }
1507 :
1508 :
1509 :
1510 :
1511 :
1512 0 : if (row.isStr("<tskySpectrum>")) {
1513 :
1514 :
1515 0 : setTskySpectrum(Parser::get2DTemperature("tskySpectrum","SysCal",rowDoc));
1516 :
1517 :
1518 : }
1519 :
1520 :
1521 :
1522 :
1523 :
1524 0 : if (row.isStr("<tsysFlag>")) {
1525 :
1526 0 : setTsysFlag(Parser::getBoolean("tsysFlag","SysCal",rowDoc));
1527 :
1528 : }
1529 :
1530 :
1531 :
1532 :
1533 :
1534 0 : if (row.isStr("<tsysSpectrum>")) {
1535 :
1536 :
1537 0 : setTsysSpectrum(Parser::get2DTemperature("tsysSpectrum","SysCal",rowDoc));
1538 :
1539 :
1540 : }
1541 :
1542 :
1543 :
1544 :
1545 :
1546 0 : if (row.isStr("<tantFlag>")) {
1547 :
1548 0 : setTantFlag(Parser::getBoolean("tantFlag","SysCal",rowDoc));
1549 :
1550 : }
1551 :
1552 :
1553 :
1554 :
1555 :
1556 0 : if (row.isStr("<tantSpectrum>")) {
1557 :
1558 :
1559 0 : setTantSpectrum(Parser::get2DFloat("tantSpectrum","SysCal",rowDoc));
1560 :
1561 :
1562 : }
1563 :
1564 :
1565 :
1566 :
1567 :
1568 0 : if (row.isStr("<tantTsysFlag>")) {
1569 :
1570 0 : setTantTsysFlag(Parser::getBoolean("tantTsysFlag","SysCal",rowDoc));
1571 :
1572 : }
1573 :
1574 :
1575 :
1576 :
1577 :
1578 0 : if (row.isStr("<tantTsysSpectrum>")) {
1579 :
1580 :
1581 0 : setTantTsysSpectrum(Parser::get2DFloat("tantTsysSpectrum","SysCal",rowDoc));
1582 :
1583 :
1584 : }
1585 :
1586 :
1587 :
1588 :
1589 :
1590 0 : if (row.isStr("<phaseDiffFlag>")) {
1591 :
1592 0 : setPhaseDiffFlag(Parser::getBoolean("phaseDiffFlag","SysCal",rowDoc));
1593 :
1594 : }
1595 :
1596 :
1597 :
1598 :
1599 :
1600 0 : if (row.isStr("<phaseDiffSpectrum>")) {
1601 :
1602 :
1603 0 : setPhaseDiffSpectrum(Parser::get2DFloat("phaseDiffSpectrum","SysCal",rowDoc));
1604 :
1605 :
1606 : }
1607 :
1608 :
1609 :
1610 :
1611 :
1612 :
1613 :
1614 :
1615 :
1616 0 : setAntennaId(Parser::getTag("antennaId","Antenna",rowDoc));
1617 :
1618 :
1619 :
1620 :
1621 :
1622 :
1623 :
1624 0 : setFeedId(Parser::getInteger("feedId","Feed",rowDoc));
1625 :
1626 :
1627 :
1628 :
1629 :
1630 :
1631 :
1632 0 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
1633 :
1634 :
1635 :
1636 :
1637 :
1638 :
1639 :
1640 :
1641 :
1642 :
1643 :
1644 :
1645 0 : } catch (const IllegalAccessException &err) {
1646 0 : throw ConversionException (err.getMessage(),"SysCal");
1647 0 : }
1648 0 : }
1649 :
1650 0 : void SysCalRow::toBin(EndianOSStream& eoss) {
1651 :
1652 :
1653 :
1654 :
1655 :
1656 0 : antennaId.toBin(eoss);
1657 :
1658 :
1659 :
1660 :
1661 :
1662 :
1663 0 : spectralWindowId.toBin(eoss);
1664 :
1665 :
1666 :
1667 :
1668 :
1669 :
1670 0 : timeInterval.toBin(eoss);
1671 :
1672 :
1673 :
1674 :
1675 :
1676 :
1677 :
1678 0 : eoss.writeInt(feedId);
1679 :
1680 :
1681 :
1682 :
1683 :
1684 :
1685 :
1686 :
1687 0 : eoss.writeInt(numReceptor);
1688 :
1689 :
1690 :
1691 :
1692 :
1693 :
1694 :
1695 :
1696 0 : eoss.writeInt(numChan);
1697 :
1698 :
1699 :
1700 :
1701 :
1702 :
1703 :
1704 0 : eoss.writeBoolean(tcalFlagExists);
1705 0 : if (tcalFlagExists) {
1706 :
1707 :
1708 :
1709 :
1710 :
1711 0 : eoss.writeBoolean(tcalFlag);
1712 :
1713 :
1714 :
1715 :
1716 : }
1717 :
1718 0 : eoss.writeBoolean(tcalSpectrumExists);
1719 0 : if (tcalSpectrumExists) {
1720 :
1721 :
1722 :
1723 :
1724 0 : Temperature::toBin(tcalSpectrum, eoss);
1725 :
1726 :
1727 :
1728 : }
1729 :
1730 0 : eoss.writeBoolean(trxFlagExists);
1731 0 : if (trxFlagExists) {
1732 :
1733 :
1734 :
1735 :
1736 :
1737 0 : eoss.writeBoolean(trxFlag);
1738 :
1739 :
1740 :
1741 :
1742 : }
1743 :
1744 0 : eoss.writeBoolean(trxSpectrumExists);
1745 0 : if (trxSpectrumExists) {
1746 :
1747 :
1748 :
1749 :
1750 0 : Temperature::toBin(trxSpectrum, eoss);
1751 :
1752 :
1753 :
1754 : }
1755 :
1756 0 : eoss.writeBoolean(tskyFlagExists);
1757 0 : if (tskyFlagExists) {
1758 :
1759 :
1760 :
1761 :
1762 :
1763 0 : eoss.writeBoolean(tskyFlag);
1764 :
1765 :
1766 :
1767 :
1768 : }
1769 :
1770 0 : eoss.writeBoolean(tskySpectrumExists);
1771 0 : if (tskySpectrumExists) {
1772 :
1773 :
1774 :
1775 :
1776 0 : Temperature::toBin(tskySpectrum, eoss);
1777 :
1778 :
1779 :
1780 : }
1781 :
1782 0 : eoss.writeBoolean(tsysFlagExists);
1783 0 : if (tsysFlagExists) {
1784 :
1785 :
1786 :
1787 :
1788 :
1789 0 : eoss.writeBoolean(tsysFlag);
1790 :
1791 :
1792 :
1793 :
1794 : }
1795 :
1796 0 : eoss.writeBoolean(tsysSpectrumExists);
1797 0 : if (tsysSpectrumExists) {
1798 :
1799 :
1800 :
1801 :
1802 0 : Temperature::toBin(tsysSpectrum, eoss);
1803 :
1804 :
1805 :
1806 : }
1807 :
1808 0 : eoss.writeBoolean(tantFlagExists);
1809 0 : if (tantFlagExists) {
1810 :
1811 :
1812 :
1813 :
1814 :
1815 0 : eoss.writeBoolean(tantFlag);
1816 :
1817 :
1818 :
1819 :
1820 : }
1821 :
1822 0 : eoss.writeBoolean(tantSpectrumExists);
1823 0 : if (tantSpectrumExists) {
1824 :
1825 :
1826 :
1827 :
1828 :
1829 :
1830 0 : eoss.writeInt((int) tantSpectrum.size());
1831 0 : eoss.writeInt((int) tantSpectrum.at(0).size());
1832 0 : for (unsigned int i = 0; i < tantSpectrum.size(); i++)
1833 0 : for (unsigned int j = 0; j < tantSpectrum.at(0).size(); j++)
1834 :
1835 0 : eoss.writeFloat(tantSpectrum.at(i).at(j));
1836 :
1837 :
1838 :
1839 :
1840 :
1841 :
1842 : }
1843 :
1844 0 : eoss.writeBoolean(tantTsysFlagExists);
1845 0 : if (tantTsysFlagExists) {
1846 :
1847 :
1848 :
1849 :
1850 :
1851 0 : eoss.writeBoolean(tantTsysFlag);
1852 :
1853 :
1854 :
1855 :
1856 : }
1857 :
1858 0 : eoss.writeBoolean(tantTsysSpectrumExists);
1859 0 : if (tantTsysSpectrumExists) {
1860 :
1861 :
1862 :
1863 :
1864 :
1865 :
1866 0 : eoss.writeInt((int) tantTsysSpectrum.size());
1867 0 : eoss.writeInt((int) tantTsysSpectrum.at(0).size());
1868 0 : for (unsigned int i = 0; i < tantTsysSpectrum.size(); i++)
1869 0 : for (unsigned int j = 0; j < tantTsysSpectrum.at(0).size(); j++)
1870 :
1871 0 : eoss.writeFloat(tantTsysSpectrum.at(i).at(j));
1872 :
1873 :
1874 :
1875 :
1876 :
1877 :
1878 : }
1879 :
1880 0 : eoss.writeBoolean(phaseDiffFlagExists);
1881 0 : if (phaseDiffFlagExists) {
1882 :
1883 :
1884 :
1885 :
1886 :
1887 0 : eoss.writeBoolean(phaseDiffFlag);
1888 :
1889 :
1890 :
1891 :
1892 : }
1893 :
1894 0 : eoss.writeBoolean(phaseDiffSpectrumExists);
1895 0 : if (phaseDiffSpectrumExists) {
1896 :
1897 :
1898 :
1899 :
1900 :
1901 :
1902 0 : eoss.writeInt((int) phaseDiffSpectrum.size());
1903 0 : eoss.writeInt((int) phaseDiffSpectrum.at(0).size());
1904 0 : for (unsigned int i = 0; i < phaseDiffSpectrum.size(); i++)
1905 0 : for (unsigned int j = 0; j < phaseDiffSpectrum.at(0).size(); j++)
1906 :
1907 0 : eoss.writeFloat(phaseDiffSpectrum.at(i).at(j));
1908 :
1909 :
1910 :
1911 :
1912 :
1913 :
1914 : }
1915 :
1916 0 : }
1917 :
1918 0 : void SysCalRow::antennaIdFromBin(EndianIStream& eis) {
1919 :
1920 :
1921 :
1922 :
1923 0 : antennaId = Tag::fromBin(eis);
1924 :
1925 :
1926 :
1927 0 : }
1928 0 : void SysCalRow::spectralWindowIdFromBin(EndianIStream& eis) {
1929 :
1930 :
1931 :
1932 :
1933 0 : spectralWindowId = Tag::fromBin(eis);
1934 :
1935 :
1936 :
1937 0 : }
1938 0 : void SysCalRow::timeIntervalFromBin(EndianIStream& eis) {
1939 :
1940 :
1941 :
1942 :
1943 0 : timeInterval = ArrayTimeInterval::fromBin(eis);
1944 :
1945 :
1946 :
1947 0 : }
1948 0 : void SysCalRow::feedIdFromBin(EndianIStream& eis) {
1949 :
1950 :
1951 :
1952 :
1953 :
1954 0 : feedId = eis.readInt();
1955 :
1956 :
1957 :
1958 :
1959 0 : }
1960 0 : void SysCalRow::numReceptorFromBin(EndianIStream& eis) {
1961 :
1962 :
1963 :
1964 :
1965 :
1966 0 : numReceptor = eis.readInt();
1967 :
1968 :
1969 :
1970 :
1971 0 : }
1972 0 : void SysCalRow::numChanFromBin(EndianIStream& eis) {
1973 :
1974 :
1975 :
1976 :
1977 :
1978 0 : numChan = eis.readInt();
1979 :
1980 :
1981 :
1982 :
1983 0 : }
1984 :
1985 0 : void SysCalRow::tcalFlagFromBin(EndianIStream& eis) {
1986 :
1987 0 : tcalFlagExists = eis.readBoolean();
1988 0 : if (tcalFlagExists) {
1989 :
1990 :
1991 :
1992 :
1993 :
1994 0 : tcalFlag = eis.readBoolean();
1995 :
1996 :
1997 :
1998 :
1999 : }
2000 :
2001 0 : }
2002 0 : void SysCalRow::tcalSpectrumFromBin(EndianIStream& eis) {
2003 :
2004 0 : tcalSpectrumExists = eis.readBoolean();
2005 0 : if (tcalSpectrumExists) {
2006 :
2007 :
2008 :
2009 :
2010 :
2011 :
2012 0 : tcalSpectrum = Temperature::from2DBin(eis);
2013 :
2014 :
2015 :
2016 :
2017 :
2018 : }
2019 :
2020 0 : }
2021 0 : void SysCalRow::trxFlagFromBin(EndianIStream& eis) {
2022 :
2023 0 : trxFlagExists = eis.readBoolean();
2024 0 : if (trxFlagExists) {
2025 :
2026 :
2027 :
2028 :
2029 :
2030 0 : trxFlag = eis.readBoolean();
2031 :
2032 :
2033 :
2034 :
2035 : }
2036 :
2037 0 : }
2038 0 : void SysCalRow::trxSpectrumFromBin(EndianIStream& eis) {
2039 :
2040 0 : trxSpectrumExists = eis.readBoolean();
2041 0 : if (trxSpectrumExists) {
2042 :
2043 :
2044 :
2045 :
2046 :
2047 :
2048 0 : trxSpectrum = Temperature::from2DBin(eis);
2049 :
2050 :
2051 :
2052 :
2053 :
2054 : }
2055 :
2056 0 : }
2057 0 : void SysCalRow::tskyFlagFromBin(EndianIStream& eis) {
2058 :
2059 0 : tskyFlagExists = eis.readBoolean();
2060 0 : if (tskyFlagExists) {
2061 :
2062 :
2063 :
2064 :
2065 :
2066 0 : tskyFlag = eis.readBoolean();
2067 :
2068 :
2069 :
2070 :
2071 : }
2072 :
2073 0 : }
2074 0 : void SysCalRow::tskySpectrumFromBin(EndianIStream& eis) {
2075 :
2076 0 : tskySpectrumExists = eis.readBoolean();
2077 0 : if (tskySpectrumExists) {
2078 :
2079 :
2080 :
2081 :
2082 :
2083 :
2084 0 : tskySpectrum = Temperature::from2DBin(eis);
2085 :
2086 :
2087 :
2088 :
2089 :
2090 : }
2091 :
2092 0 : }
2093 0 : void SysCalRow::tsysFlagFromBin(EndianIStream& eis) {
2094 :
2095 0 : tsysFlagExists = eis.readBoolean();
2096 0 : if (tsysFlagExists) {
2097 :
2098 :
2099 :
2100 :
2101 :
2102 0 : tsysFlag = eis.readBoolean();
2103 :
2104 :
2105 :
2106 :
2107 : }
2108 :
2109 0 : }
2110 0 : void SysCalRow::tsysSpectrumFromBin(EndianIStream& eis) {
2111 :
2112 0 : tsysSpectrumExists = eis.readBoolean();
2113 0 : if (tsysSpectrumExists) {
2114 :
2115 :
2116 :
2117 :
2118 :
2119 :
2120 0 : tsysSpectrum = Temperature::from2DBin(eis);
2121 :
2122 :
2123 :
2124 :
2125 :
2126 : }
2127 :
2128 0 : }
2129 0 : void SysCalRow::tantFlagFromBin(EndianIStream& eis) {
2130 :
2131 0 : tantFlagExists = eis.readBoolean();
2132 0 : if (tantFlagExists) {
2133 :
2134 :
2135 :
2136 :
2137 :
2138 0 : tantFlag = eis.readBoolean();
2139 :
2140 :
2141 :
2142 :
2143 : }
2144 :
2145 0 : }
2146 0 : void SysCalRow::tantSpectrumFromBin(EndianIStream& eis) {
2147 :
2148 0 : tantSpectrumExists = eis.readBoolean();
2149 0 : if (tantSpectrumExists) {
2150 :
2151 :
2152 :
2153 :
2154 :
2155 :
2156 0 : tantSpectrum.clear();
2157 :
2158 0 : unsigned int tantSpectrumDim1 = eis.readInt();
2159 0 : unsigned int tantSpectrumDim2 = eis.readInt();
2160 :
2161 0 : vector <float> tantSpectrumAux1;
2162 :
2163 0 : for (unsigned int i = 0; i < tantSpectrumDim1; i++) {
2164 0 : tantSpectrumAux1.clear();
2165 0 : for (unsigned int j = 0; j < tantSpectrumDim2 ; j++)
2166 :
2167 0 : tantSpectrumAux1.push_back(eis.readFloat());
2168 :
2169 0 : tantSpectrum.push_back(tantSpectrumAux1);
2170 : }
2171 :
2172 :
2173 :
2174 :
2175 :
2176 :
2177 0 : }
2178 :
2179 0 : }
2180 0 : void SysCalRow::tantTsysFlagFromBin(EndianIStream& eis) {
2181 :
2182 0 : tantTsysFlagExists = eis.readBoolean();
2183 0 : if (tantTsysFlagExists) {
2184 :
2185 :
2186 :
2187 :
2188 :
2189 0 : tantTsysFlag = eis.readBoolean();
2190 :
2191 :
2192 :
2193 :
2194 : }
2195 :
2196 0 : }
2197 0 : void SysCalRow::tantTsysSpectrumFromBin(EndianIStream& eis) {
2198 :
2199 0 : tantTsysSpectrumExists = eis.readBoolean();
2200 0 : if (tantTsysSpectrumExists) {
2201 :
2202 :
2203 :
2204 :
2205 :
2206 :
2207 0 : tantTsysSpectrum.clear();
2208 :
2209 0 : unsigned int tantTsysSpectrumDim1 = eis.readInt();
2210 0 : unsigned int tantTsysSpectrumDim2 = eis.readInt();
2211 :
2212 0 : vector <float> tantTsysSpectrumAux1;
2213 :
2214 0 : for (unsigned int i = 0; i < tantTsysSpectrumDim1; i++) {
2215 0 : tantTsysSpectrumAux1.clear();
2216 0 : for (unsigned int j = 0; j < tantTsysSpectrumDim2 ; j++)
2217 :
2218 0 : tantTsysSpectrumAux1.push_back(eis.readFloat());
2219 :
2220 0 : tantTsysSpectrum.push_back(tantTsysSpectrumAux1);
2221 : }
2222 :
2223 :
2224 :
2225 :
2226 :
2227 :
2228 0 : }
2229 :
2230 0 : }
2231 0 : void SysCalRow::phaseDiffFlagFromBin(EndianIStream& eis) {
2232 :
2233 0 : phaseDiffFlagExists = eis.readBoolean();
2234 0 : if (phaseDiffFlagExists) {
2235 :
2236 :
2237 :
2238 :
2239 :
2240 0 : phaseDiffFlag = eis.readBoolean();
2241 :
2242 :
2243 :
2244 :
2245 : }
2246 :
2247 0 : }
2248 0 : void SysCalRow::phaseDiffSpectrumFromBin(EndianIStream& eis) {
2249 :
2250 0 : phaseDiffSpectrumExists = eis.readBoolean();
2251 0 : if (phaseDiffSpectrumExists) {
2252 :
2253 :
2254 :
2255 :
2256 :
2257 :
2258 0 : phaseDiffSpectrum.clear();
2259 :
2260 0 : unsigned int phaseDiffSpectrumDim1 = eis.readInt();
2261 0 : unsigned int phaseDiffSpectrumDim2 = eis.readInt();
2262 :
2263 0 : vector <float> phaseDiffSpectrumAux1;
2264 :
2265 0 : for (unsigned int i = 0; i < phaseDiffSpectrumDim1; i++) {
2266 0 : phaseDiffSpectrumAux1.clear();
2267 0 : for (unsigned int j = 0; j < phaseDiffSpectrumDim2 ; j++)
2268 :
2269 0 : phaseDiffSpectrumAux1.push_back(eis.readFloat());
2270 :
2271 0 : phaseDiffSpectrum.push_back(phaseDiffSpectrumAux1);
2272 : }
2273 :
2274 :
2275 :
2276 :
2277 :
2278 :
2279 0 : }
2280 :
2281 0 : }
2282 :
2283 :
2284 0 : SysCalRow* SysCalRow::fromBin(EndianIStream& eis, SysCalTable& table, const vector<string>& attributesSeq) {
2285 0 : SysCalRow* row = new SysCalRow(table);
2286 :
2287 0 : map<string, SysCalAttributeFromBin>::iterator iter ;
2288 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
2289 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
2290 0 : if (iter != row->fromBinMethods.end()) {
2291 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
2292 : }
2293 : else {
2294 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
2295 0 : if (functorP)
2296 0 : (*functorP)(eis);
2297 : else
2298 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "SysCalTable");
2299 : }
2300 :
2301 : }
2302 0 : return row;
2303 : }
2304 :
2305 : //
2306 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
2307 : // of one row.
2308 : //
2309 :
2310 : // Convert a string into an Tag
2311 0 : void SysCalRow::antennaIdFromText(const string & s) {
2312 :
2313 :
2314 0 : antennaId = ASDMValuesParser::parse<Tag>(s);
2315 :
2316 :
2317 0 : }
2318 :
2319 :
2320 : // Convert a string into an Tag
2321 0 : void SysCalRow::spectralWindowIdFromText(const string & s) {
2322 :
2323 :
2324 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
2325 :
2326 :
2327 0 : }
2328 :
2329 :
2330 : // Convert a string into an ArrayTimeInterval
2331 0 : void SysCalRow::timeIntervalFromText(const string & s) {
2332 :
2333 :
2334 0 : timeInterval = ASDMValuesParser::parse<ArrayTimeInterval>(s);
2335 :
2336 :
2337 0 : }
2338 :
2339 :
2340 : // Convert a string into an int
2341 0 : void SysCalRow::feedIdFromText(const string & s) {
2342 :
2343 :
2344 0 : feedId = ASDMValuesParser::parse<int>(s);
2345 :
2346 :
2347 0 : }
2348 :
2349 :
2350 : // Convert a string into an int
2351 0 : void SysCalRow::numReceptorFromText(const string & s) {
2352 :
2353 :
2354 0 : numReceptor = ASDMValuesParser::parse<int>(s);
2355 :
2356 :
2357 0 : }
2358 :
2359 :
2360 : // Convert a string into an int
2361 0 : void SysCalRow::numChanFromText(const string & s) {
2362 :
2363 :
2364 0 : numChan = ASDMValuesParser::parse<int>(s);
2365 :
2366 :
2367 0 : }
2368 :
2369 :
2370 :
2371 : // Convert a string into an boolean
2372 0 : void SysCalRow::tcalFlagFromText(const string & s) {
2373 0 : tcalFlagExists = true;
2374 :
2375 :
2376 0 : tcalFlag = ASDMValuesParser::parse<bool>(s);
2377 :
2378 :
2379 0 : }
2380 :
2381 :
2382 : // Convert a string into an Temperature
2383 0 : void SysCalRow::tcalSpectrumFromText(const string & s) {
2384 0 : tcalSpectrumExists = true;
2385 :
2386 :
2387 0 : tcalSpectrum = ASDMValuesParser::parse2D<Temperature>(s);
2388 :
2389 :
2390 0 : }
2391 :
2392 :
2393 : // Convert a string into an boolean
2394 0 : void SysCalRow::trxFlagFromText(const string & s) {
2395 0 : trxFlagExists = true;
2396 :
2397 :
2398 0 : trxFlag = ASDMValuesParser::parse<bool>(s);
2399 :
2400 :
2401 0 : }
2402 :
2403 :
2404 : // Convert a string into an Temperature
2405 0 : void SysCalRow::trxSpectrumFromText(const string & s) {
2406 0 : trxSpectrumExists = true;
2407 :
2408 :
2409 0 : trxSpectrum = ASDMValuesParser::parse2D<Temperature>(s);
2410 :
2411 :
2412 0 : }
2413 :
2414 :
2415 : // Convert a string into an boolean
2416 0 : void SysCalRow::tskyFlagFromText(const string & s) {
2417 0 : tskyFlagExists = true;
2418 :
2419 :
2420 0 : tskyFlag = ASDMValuesParser::parse<bool>(s);
2421 :
2422 :
2423 0 : }
2424 :
2425 :
2426 : // Convert a string into an Temperature
2427 0 : void SysCalRow::tskySpectrumFromText(const string & s) {
2428 0 : tskySpectrumExists = true;
2429 :
2430 :
2431 0 : tskySpectrum = ASDMValuesParser::parse2D<Temperature>(s);
2432 :
2433 :
2434 0 : }
2435 :
2436 :
2437 : // Convert a string into an boolean
2438 0 : void SysCalRow::tsysFlagFromText(const string & s) {
2439 0 : tsysFlagExists = true;
2440 :
2441 :
2442 0 : tsysFlag = ASDMValuesParser::parse<bool>(s);
2443 :
2444 :
2445 0 : }
2446 :
2447 :
2448 : // Convert a string into an Temperature
2449 0 : void SysCalRow::tsysSpectrumFromText(const string & s) {
2450 0 : tsysSpectrumExists = true;
2451 :
2452 :
2453 0 : tsysSpectrum = ASDMValuesParser::parse2D<Temperature>(s);
2454 :
2455 :
2456 0 : }
2457 :
2458 :
2459 : // Convert a string into an boolean
2460 0 : void SysCalRow::tantFlagFromText(const string & s) {
2461 0 : tantFlagExists = true;
2462 :
2463 :
2464 0 : tantFlag = ASDMValuesParser::parse<bool>(s);
2465 :
2466 :
2467 0 : }
2468 :
2469 :
2470 : // Convert a string into an float
2471 0 : void SysCalRow::tantSpectrumFromText(const string & s) {
2472 0 : tantSpectrumExists = true;
2473 :
2474 :
2475 0 : tantSpectrum = ASDMValuesParser::parse2D<float>(s);
2476 :
2477 :
2478 0 : }
2479 :
2480 :
2481 : // Convert a string into an boolean
2482 0 : void SysCalRow::tantTsysFlagFromText(const string & s) {
2483 0 : tantTsysFlagExists = true;
2484 :
2485 :
2486 0 : tantTsysFlag = ASDMValuesParser::parse<bool>(s);
2487 :
2488 :
2489 0 : }
2490 :
2491 :
2492 : // Convert a string into an float
2493 0 : void SysCalRow::tantTsysSpectrumFromText(const string & s) {
2494 0 : tantTsysSpectrumExists = true;
2495 :
2496 :
2497 0 : tantTsysSpectrum = ASDMValuesParser::parse2D<float>(s);
2498 :
2499 :
2500 0 : }
2501 :
2502 :
2503 : // Convert a string into an boolean
2504 0 : void SysCalRow::phaseDiffFlagFromText(const string & s) {
2505 0 : phaseDiffFlagExists = true;
2506 :
2507 :
2508 0 : phaseDiffFlag = ASDMValuesParser::parse<bool>(s);
2509 :
2510 :
2511 0 : }
2512 :
2513 :
2514 : // Convert a string into an float
2515 0 : void SysCalRow::phaseDiffSpectrumFromText(const string & s) {
2516 0 : phaseDiffSpectrumExists = true;
2517 :
2518 :
2519 0 : phaseDiffSpectrum = ASDMValuesParser::parse2D<float>(s);
2520 :
2521 :
2522 0 : }
2523 :
2524 :
2525 :
2526 0 : void SysCalRow::fromText(const std::string& attributeName, const std::string& t) {
2527 0 : map<string, SysCalAttributeFromText>::iterator iter;
2528 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
2529 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "SysCalTable");
2530 0 : (this->*(iter->second))(t);
2531 0 : }
2532 :
2533 : ////////////////////////////////////////////////
2534 : // Intrinsic Table Attributes getters/setters //
2535 : ////////////////////////////////////////////////
2536 :
2537 :
2538 :
2539 :
2540 : /**
2541 : * Get timeInterval.
2542 : * @return timeInterval as ArrayTimeInterval
2543 : */
2544 0 : ArrayTimeInterval SysCalRow::getTimeInterval() const {
2545 :
2546 0 : return timeInterval;
2547 : }
2548 :
2549 : /**
2550 : * Set timeInterval with the specified ArrayTimeInterval.
2551 : * @param timeInterval The ArrayTimeInterval value to which timeInterval is to be set.
2552 :
2553 :
2554 :
2555 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2556 :
2557 : */
2558 0 : void SysCalRow::setTimeInterval (ArrayTimeInterval timeInterval) {
2559 :
2560 :
2561 0 : if (hasBeenAdded) {
2562 :
2563 0 : throw IllegalAccessException("timeInterval", "SysCal");
2564 :
2565 : }
2566 :
2567 0 : this->timeInterval = timeInterval;
2568 :
2569 0 : }
2570 :
2571 :
2572 :
2573 :
2574 :
2575 :
2576 : /**
2577 : * Get numReceptor.
2578 : * @return numReceptor as int
2579 : */
2580 0 : int SysCalRow::getNumReceptor() const {
2581 :
2582 0 : return numReceptor;
2583 : }
2584 :
2585 : /**
2586 : * Set numReceptor with the specified int.
2587 : * @param numReceptor The int value to which numReceptor is to be set.
2588 :
2589 :
2590 :
2591 : */
2592 0 : void SysCalRow::setNumReceptor (int numReceptor) {
2593 :
2594 :
2595 0 : if (hasBeenAdded) {
2596 :
2597 : }
2598 :
2599 0 : this->numReceptor = numReceptor;
2600 :
2601 0 : }
2602 :
2603 :
2604 :
2605 :
2606 :
2607 :
2608 : /**
2609 : * Get numChan.
2610 : * @return numChan as int
2611 : */
2612 0 : int SysCalRow::getNumChan() const {
2613 :
2614 0 : return numChan;
2615 : }
2616 :
2617 : /**
2618 : * Set numChan with the specified int.
2619 : * @param numChan The int value to which numChan is to be set.
2620 :
2621 :
2622 :
2623 : */
2624 0 : void SysCalRow::setNumChan (int numChan) {
2625 :
2626 :
2627 0 : if (hasBeenAdded) {
2628 :
2629 : }
2630 :
2631 0 : this->numChan = numChan;
2632 :
2633 0 : }
2634 :
2635 :
2636 :
2637 :
2638 : /**
2639 : * The attribute tcalFlag is optional. Return true if this attribute exists.
2640 : * @return true if and only if the tcalFlag attribute exists.
2641 : */
2642 0 : bool SysCalRow::isTcalFlagExists() const {
2643 0 : return tcalFlagExists;
2644 : }
2645 :
2646 :
2647 :
2648 : /**
2649 : * Get tcalFlag, which is optional.
2650 : * @return tcalFlag as bool
2651 : * @throw IllegalAccessException If tcalFlag does not exist.
2652 : */
2653 0 : bool SysCalRow::getTcalFlag() const {
2654 0 : if (!tcalFlagExists) {
2655 0 : throw IllegalAccessException("tcalFlag", "SysCal");
2656 : }
2657 :
2658 0 : return tcalFlag;
2659 : }
2660 :
2661 : /**
2662 : * Set tcalFlag with the specified bool.
2663 : * @param tcalFlag The bool value to which tcalFlag is to be set.
2664 :
2665 :
2666 : */
2667 0 : void SysCalRow::setTcalFlag (bool tcalFlag) {
2668 :
2669 0 : this->tcalFlag = tcalFlag;
2670 :
2671 0 : tcalFlagExists = true;
2672 :
2673 0 : }
2674 :
2675 :
2676 : /**
2677 : * Mark tcalFlag, which is an optional field, as non-existent.
2678 : */
2679 0 : void SysCalRow::clearTcalFlag () {
2680 0 : tcalFlagExists = false;
2681 0 : }
2682 :
2683 :
2684 :
2685 : /**
2686 : * The attribute tcalSpectrum is optional. Return true if this attribute exists.
2687 : * @return true if and only if the tcalSpectrum attribute exists.
2688 : */
2689 0 : bool SysCalRow::isTcalSpectrumExists() const {
2690 0 : return tcalSpectrumExists;
2691 : }
2692 :
2693 :
2694 :
2695 : /**
2696 : * Get tcalSpectrum, which is optional.
2697 : * @return tcalSpectrum as std::vector<std::vector<Temperature > >
2698 : * @throw IllegalAccessException If tcalSpectrum does not exist.
2699 : */
2700 0 : std::vector<std::vector<Temperature > > SysCalRow::getTcalSpectrum() const {
2701 0 : if (!tcalSpectrumExists) {
2702 0 : throw IllegalAccessException("tcalSpectrum", "SysCal");
2703 : }
2704 :
2705 0 : return tcalSpectrum;
2706 : }
2707 :
2708 : /**
2709 : * Set tcalSpectrum with the specified std::vector<std::vector<Temperature > >.
2710 : * @param tcalSpectrum The std::vector<std::vector<Temperature > > value to which tcalSpectrum is to be set.
2711 :
2712 :
2713 : */
2714 0 : void SysCalRow::setTcalSpectrum (std::vector<std::vector<Temperature > > tcalSpectrum) {
2715 :
2716 0 : this->tcalSpectrum = tcalSpectrum;
2717 :
2718 0 : tcalSpectrumExists = true;
2719 :
2720 0 : }
2721 :
2722 :
2723 : /**
2724 : * Mark tcalSpectrum, which is an optional field, as non-existent.
2725 : */
2726 0 : void SysCalRow::clearTcalSpectrum () {
2727 0 : tcalSpectrumExists = false;
2728 0 : }
2729 :
2730 :
2731 :
2732 : /**
2733 : * The attribute trxFlag is optional. Return true if this attribute exists.
2734 : * @return true if and only if the trxFlag attribute exists.
2735 : */
2736 0 : bool SysCalRow::isTrxFlagExists() const {
2737 0 : return trxFlagExists;
2738 : }
2739 :
2740 :
2741 :
2742 : /**
2743 : * Get trxFlag, which is optional.
2744 : * @return trxFlag as bool
2745 : * @throw IllegalAccessException If trxFlag does not exist.
2746 : */
2747 0 : bool SysCalRow::getTrxFlag() const {
2748 0 : if (!trxFlagExists) {
2749 0 : throw IllegalAccessException("trxFlag", "SysCal");
2750 : }
2751 :
2752 0 : return trxFlag;
2753 : }
2754 :
2755 : /**
2756 : * Set trxFlag with the specified bool.
2757 : * @param trxFlag The bool value to which trxFlag is to be set.
2758 :
2759 :
2760 : */
2761 0 : void SysCalRow::setTrxFlag (bool trxFlag) {
2762 :
2763 0 : this->trxFlag = trxFlag;
2764 :
2765 0 : trxFlagExists = true;
2766 :
2767 0 : }
2768 :
2769 :
2770 : /**
2771 : * Mark trxFlag, which is an optional field, as non-existent.
2772 : */
2773 0 : void SysCalRow::clearTrxFlag () {
2774 0 : trxFlagExists = false;
2775 0 : }
2776 :
2777 :
2778 :
2779 : /**
2780 : * The attribute trxSpectrum is optional. Return true if this attribute exists.
2781 : * @return true if and only if the trxSpectrum attribute exists.
2782 : */
2783 0 : bool SysCalRow::isTrxSpectrumExists() const {
2784 0 : return trxSpectrumExists;
2785 : }
2786 :
2787 :
2788 :
2789 : /**
2790 : * Get trxSpectrum, which is optional.
2791 : * @return trxSpectrum as std::vector<std::vector<Temperature > >
2792 : * @throw IllegalAccessException If trxSpectrum does not exist.
2793 : */
2794 0 : std::vector<std::vector<Temperature > > SysCalRow::getTrxSpectrum() const {
2795 0 : if (!trxSpectrumExists) {
2796 0 : throw IllegalAccessException("trxSpectrum", "SysCal");
2797 : }
2798 :
2799 0 : return trxSpectrum;
2800 : }
2801 :
2802 : /**
2803 : * Set trxSpectrum with the specified std::vector<std::vector<Temperature > >.
2804 : * @param trxSpectrum The std::vector<std::vector<Temperature > > value to which trxSpectrum is to be set.
2805 :
2806 :
2807 : */
2808 0 : void SysCalRow::setTrxSpectrum (std::vector<std::vector<Temperature > > trxSpectrum) {
2809 :
2810 0 : this->trxSpectrum = trxSpectrum;
2811 :
2812 0 : trxSpectrumExists = true;
2813 :
2814 0 : }
2815 :
2816 :
2817 : /**
2818 : * Mark trxSpectrum, which is an optional field, as non-existent.
2819 : */
2820 0 : void SysCalRow::clearTrxSpectrum () {
2821 0 : trxSpectrumExists = false;
2822 0 : }
2823 :
2824 :
2825 :
2826 : /**
2827 : * The attribute tskyFlag is optional. Return true if this attribute exists.
2828 : * @return true if and only if the tskyFlag attribute exists.
2829 : */
2830 0 : bool SysCalRow::isTskyFlagExists() const {
2831 0 : return tskyFlagExists;
2832 : }
2833 :
2834 :
2835 :
2836 : /**
2837 : * Get tskyFlag, which is optional.
2838 : * @return tskyFlag as bool
2839 : * @throw IllegalAccessException If tskyFlag does not exist.
2840 : */
2841 0 : bool SysCalRow::getTskyFlag() const {
2842 0 : if (!tskyFlagExists) {
2843 0 : throw IllegalAccessException("tskyFlag", "SysCal");
2844 : }
2845 :
2846 0 : return tskyFlag;
2847 : }
2848 :
2849 : /**
2850 : * Set tskyFlag with the specified bool.
2851 : * @param tskyFlag The bool value to which tskyFlag is to be set.
2852 :
2853 :
2854 : */
2855 0 : void SysCalRow::setTskyFlag (bool tskyFlag) {
2856 :
2857 0 : this->tskyFlag = tskyFlag;
2858 :
2859 0 : tskyFlagExists = true;
2860 :
2861 0 : }
2862 :
2863 :
2864 : /**
2865 : * Mark tskyFlag, which is an optional field, as non-existent.
2866 : */
2867 0 : void SysCalRow::clearTskyFlag () {
2868 0 : tskyFlagExists = false;
2869 0 : }
2870 :
2871 :
2872 :
2873 : /**
2874 : * The attribute tskySpectrum is optional. Return true if this attribute exists.
2875 : * @return true if and only if the tskySpectrum attribute exists.
2876 : */
2877 0 : bool SysCalRow::isTskySpectrumExists() const {
2878 0 : return tskySpectrumExists;
2879 : }
2880 :
2881 :
2882 :
2883 : /**
2884 : * Get tskySpectrum, which is optional.
2885 : * @return tskySpectrum as std::vector<std::vector<Temperature > >
2886 : * @throw IllegalAccessException If tskySpectrum does not exist.
2887 : */
2888 0 : std::vector<std::vector<Temperature > > SysCalRow::getTskySpectrum() const {
2889 0 : if (!tskySpectrumExists) {
2890 0 : throw IllegalAccessException("tskySpectrum", "SysCal");
2891 : }
2892 :
2893 0 : return tskySpectrum;
2894 : }
2895 :
2896 : /**
2897 : * Set tskySpectrum with the specified std::vector<std::vector<Temperature > >.
2898 : * @param tskySpectrum The std::vector<std::vector<Temperature > > value to which tskySpectrum is to be set.
2899 :
2900 :
2901 : */
2902 0 : void SysCalRow::setTskySpectrum (std::vector<std::vector<Temperature > > tskySpectrum) {
2903 :
2904 0 : this->tskySpectrum = tskySpectrum;
2905 :
2906 0 : tskySpectrumExists = true;
2907 :
2908 0 : }
2909 :
2910 :
2911 : /**
2912 : * Mark tskySpectrum, which is an optional field, as non-existent.
2913 : */
2914 0 : void SysCalRow::clearTskySpectrum () {
2915 0 : tskySpectrumExists = false;
2916 0 : }
2917 :
2918 :
2919 :
2920 : /**
2921 : * The attribute tsysFlag is optional. Return true if this attribute exists.
2922 : * @return true if and only if the tsysFlag attribute exists.
2923 : */
2924 0 : bool SysCalRow::isTsysFlagExists() const {
2925 0 : return tsysFlagExists;
2926 : }
2927 :
2928 :
2929 :
2930 : /**
2931 : * Get tsysFlag, which is optional.
2932 : * @return tsysFlag as bool
2933 : * @throw IllegalAccessException If tsysFlag does not exist.
2934 : */
2935 0 : bool SysCalRow::getTsysFlag() const {
2936 0 : if (!tsysFlagExists) {
2937 0 : throw IllegalAccessException("tsysFlag", "SysCal");
2938 : }
2939 :
2940 0 : return tsysFlag;
2941 : }
2942 :
2943 : /**
2944 : * Set tsysFlag with the specified bool.
2945 : * @param tsysFlag The bool value to which tsysFlag is to be set.
2946 :
2947 :
2948 : */
2949 0 : void SysCalRow::setTsysFlag (bool tsysFlag) {
2950 :
2951 0 : this->tsysFlag = tsysFlag;
2952 :
2953 0 : tsysFlagExists = true;
2954 :
2955 0 : }
2956 :
2957 :
2958 : /**
2959 : * Mark tsysFlag, which is an optional field, as non-existent.
2960 : */
2961 0 : void SysCalRow::clearTsysFlag () {
2962 0 : tsysFlagExists = false;
2963 0 : }
2964 :
2965 :
2966 :
2967 : /**
2968 : * The attribute tsysSpectrum is optional. Return true if this attribute exists.
2969 : * @return true if and only if the tsysSpectrum attribute exists.
2970 : */
2971 0 : bool SysCalRow::isTsysSpectrumExists() const {
2972 0 : return tsysSpectrumExists;
2973 : }
2974 :
2975 :
2976 :
2977 : /**
2978 : * Get tsysSpectrum, which is optional.
2979 : * @return tsysSpectrum as std::vector<std::vector<Temperature > >
2980 : * @throw IllegalAccessException If tsysSpectrum does not exist.
2981 : */
2982 0 : std::vector<std::vector<Temperature > > SysCalRow::getTsysSpectrum() const {
2983 0 : if (!tsysSpectrumExists) {
2984 0 : throw IllegalAccessException("tsysSpectrum", "SysCal");
2985 : }
2986 :
2987 0 : return tsysSpectrum;
2988 : }
2989 :
2990 : /**
2991 : * Set tsysSpectrum with the specified std::vector<std::vector<Temperature > >.
2992 : * @param tsysSpectrum The std::vector<std::vector<Temperature > > value to which tsysSpectrum is to be set.
2993 :
2994 :
2995 : */
2996 0 : void SysCalRow::setTsysSpectrum (std::vector<std::vector<Temperature > > tsysSpectrum) {
2997 :
2998 0 : this->tsysSpectrum = tsysSpectrum;
2999 :
3000 0 : tsysSpectrumExists = true;
3001 :
3002 0 : }
3003 :
3004 :
3005 : /**
3006 : * Mark tsysSpectrum, which is an optional field, as non-existent.
3007 : */
3008 0 : void SysCalRow::clearTsysSpectrum () {
3009 0 : tsysSpectrumExists = false;
3010 0 : }
3011 :
3012 :
3013 :
3014 : /**
3015 : * The attribute tantFlag is optional. Return true if this attribute exists.
3016 : * @return true if and only if the tantFlag attribute exists.
3017 : */
3018 0 : bool SysCalRow::isTantFlagExists() const {
3019 0 : return tantFlagExists;
3020 : }
3021 :
3022 :
3023 :
3024 : /**
3025 : * Get tantFlag, which is optional.
3026 : * @return tantFlag as bool
3027 : * @throw IllegalAccessException If tantFlag does not exist.
3028 : */
3029 0 : bool SysCalRow::getTantFlag() const {
3030 0 : if (!tantFlagExists) {
3031 0 : throw IllegalAccessException("tantFlag", "SysCal");
3032 : }
3033 :
3034 0 : return tantFlag;
3035 : }
3036 :
3037 : /**
3038 : * Set tantFlag with the specified bool.
3039 : * @param tantFlag The bool value to which tantFlag is to be set.
3040 :
3041 :
3042 : */
3043 0 : void SysCalRow::setTantFlag (bool tantFlag) {
3044 :
3045 0 : this->tantFlag = tantFlag;
3046 :
3047 0 : tantFlagExists = true;
3048 :
3049 0 : }
3050 :
3051 :
3052 : /**
3053 : * Mark tantFlag, which is an optional field, as non-existent.
3054 : */
3055 0 : void SysCalRow::clearTantFlag () {
3056 0 : tantFlagExists = false;
3057 0 : }
3058 :
3059 :
3060 :
3061 : /**
3062 : * The attribute tantSpectrum is optional. Return true if this attribute exists.
3063 : * @return true if and only if the tantSpectrum attribute exists.
3064 : */
3065 0 : bool SysCalRow::isTantSpectrumExists() const {
3066 0 : return tantSpectrumExists;
3067 : }
3068 :
3069 :
3070 :
3071 : /**
3072 : * Get tantSpectrum, which is optional.
3073 : * @return tantSpectrum as std::vector<std::vector<float > >
3074 : * @throw IllegalAccessException If tantSpectrum does not exist.
3075 : */
3076 0 : std::vector<std::vector<float > > SysCalRow::getTantSpectrum() const {
3077 0 : if (!tantSpectrumExists) {
3078 0 : throw IllegalAccessException("tantSpectrum", "SysCal");
3079 : }
3080 :
3081 0 : return tantSpectrum;
3082 : }
3083 :
3084 : /**
3085 : * Set tantSpectrum with the specified std::vector<std::vector<float > >.
3086 : * @param tantSpectrum The std::vector<std::vector<float > > value to which tantSpectrum is to be set.
3087 :
3088 :
3089 : */
3090 0 : void SysCalRow::setTantSpectrum (std::vector<std::vector<float > > tantSpectrum) {
3091 :
3092 0 : this->tantSpectrum = tantSpectrum;
3093 :
3094 0 : tantSpectrumExists = true;
3095 :
3096 0 : }
3097 :
3098 :
3099 : /**
3100 : * Mark tantSpectrum, which is an optional field, as non-existent.
3101 : */
3102 0 : void SysCalRow::clearTantSpectrum () {
3103 0 : tantSpectrumExists = false;
3104 0 : }
3105 :
3106 :
3107 :
3108 : /**
3109 : * The attribute tantTsysFlag is optional. Return true if this attribute exists.
3110 : * @return true if and only if the tantTsysFlag attribute exists.
3111 : */
3112 0 : bool SysCalRow::isTantTsysFlagExists() const {
3113 0 : return tantTsysFlagExists;
3114 : }
3115 :
3116 :
3117 :
3118 : /**
3119 : * Get tantTsysFlag, which is optional.
3120 : * @return tantTsysFlag as bool
3121 : * @throw IllegalAccessException If tantTsysFlag does not exist.
3122 : */
3123 0 : bool SysCalRow::getTantTsysFlag() const {
3124 0 : if (!tantTsysFlagExists) {
3125 0 : throw IllegalAccessException("tantTsysFlag", "SysCal");
3126 : }
3127 :
3128 0 : return tantTsysFlag;
3129 : }
3130 :
3131 : /**
3132 : * Set tantTsysFlag with the specified bool.
3133 : * @param tantTsysFlag The bool value to which tantTsysFlag is to be set.
3134 :
3135 :
3136 : */
3137 0 : void SysCalRow::setTantTsysFlag (bool tantTsysFlag) {
3138 :
3139 0 : this->tantTsysFlag = tantTsysFlag;
3140 :
3141 0 : tantTsysFlagExists = true;
3142 :
3143 0 : }
3144 :
3145 :
3146 : /**
3147 : * Mark tantTsysFlag, which is an optional field, as non-existent.
3148 : */
3149 0 : void SysCalRow::clearTantTsysFlag () {
3150 0 : tantTsysFlagExists = false;
3151 0 : }
3152 :
3153 :
3154 :
3155 : /**
3156 : * The attribute tantTsysSpectrum is optional. Return true if this attribute exists.
3157 : * @return true if and only if the tantTsysSpectrum attribute exists.
3158 : */
3159 0 : bool SysCalRow::isTantTsysSpectrumExists() const {
3160 0 : return tantTsysSpectrumExists;
3161 : }
3162 :
3163 :
3164 :
3165 : /**
3166 : * Get tantTsysSpectrum, which is optional.
3167 : * @return tantTsysSpectrum as std::vector<std::vector<float > >
3168 : * @throw IllegalAccessException If tantTsysSpectrum does not exist.
3169 : */
3170 0 : std::vector<std::vector<float > > SysCalRow::getTantTsysSpectrum() const {
3171 0 : if (!tantTsysSpectrumExists) {
3172 0 : throw IllegalAccessException("tantTsysSpectrum", "SysCal");
3173 : }
3174 :
3175 0 : return tantTsysSpectrum;
3176 : }
3177 :
3178 : /**
3179 : * Set tantTsysSpectrum with the specified std::vector<std::vector<float > >.
3180 : * @param tantTsysSpectrum The std::vector<std::vector<float > > value to which tantTsysSpectrum is to be set.
3181 :
3182 :
3183 : */
3184 0 : void SysCalRow::setTantTsysSpectrum (std::vector<std::vector<float > > tantTsysSpectrum) {
3185 :
3186 0 : this->tantTsysSpectrum = tantTsysSpectrum;
3187 :
3188 0 : tantTsysSpectrumExists = true;
3189 :
3190 0 : }
3191 :
3192 :
3193 : /**
3194 : * Mark tantTsysSpectrum, which is an optional field, as non-existent.
3195 : */
3196 0 : void SysCalRow::clearTantTsysSpectrum () {
3197 0 : tantTsysSpectrumExists = false;
3198 0 : }
3199 :
3200 :
3201 :
3202 : /**
3203 : * The attribute phaseDiffFlag is optional. Return true if this attribute exists.
3204 : * @return true if and only if the phaseDiffFlag attribute exists.
3205 : */
3206 0 : bool SysCalRow::isPhaseDiffFlagExists() const {
3207 0 : return phaseDiffFlagExists;
3208 : }
3209 :
3210 :
3211 :
3212 : /**
3213 : * Get phaseDiffFlag, which is optional.
3214 : * @return phaseDiffFlag as bool
3215 : * @throw IllegalAccessException If phaseDiffFlag does not exist.
3216 : */
3217 0 : bool SysCalRow::getPhaseDiffFlag() const {
3218 0 : if (!phaseDiffFlagExists) {
3219 0 : throw IllegalAccessException("phaseDiffFlag", "SysCal");
3220 : }
3221 :
3222 0 : return phaseDiffFlag;
3223 : }
3224 :
3225 : /**
3226 : * Set phaseDiffFlag with the specified bool.
3227 : * @param phaseDiffFlag The bool value to which phaseDiffFlag is to be set.
3228 :
3229 :
3230 : */
3231 0 : void SysCalRow::setPhaseDiffFlag (bool phaseDiffFlag) {
3232 :
3233 0 : this->phaseDiffFlag = phaseDiffFlag;
3234 :
3235 0 : phaseDiffFlagExists = true;
3236 :
3237 0 : }
3238 :
3239 :
3240 : /**
3241 : * Mark phaseDiffFlag, which is an optional field, as non-existent.
3242 : */
3243 0 : void SysCalRow::clearPhaseDiffFlag () {
3244 0 : phaseDiffFlagExists = false;
3245 0 : }
3246 :
3247 :
3248 :
3249 : /**
3250 : * The attribute phaseDiffSpectrum is optional. Return true if this attribute exists.
3251 : * @return true if and only if the phaseDiffSpectrum attribute exists.
3252 : */
3253 0 : bool SysCalRow::isPhaseDiffSpectrumExists() const {
3254 0 : return phaseDiffSpectrumExists;
3255 : }
3256 :
3257 :
3258 :
3259 : /**
3260 : * Get phaseDiffSpectrum, which is optional.
3261 : * @return phaseDiffSpectrum as std::vector<std::vector<float > >
3262 : * @throw IllegalAccessException If phaseDiffSpectrum does not exist.
3263 : */
3264 0 : std::vector<std::vector<float > > SysCalRow::getPhaseDiffSpectrum() const {
3265 0 : if (!phaseDiffSpectrumExists) {
3266 0 : throw IllegalAccessException("phaseDiffSpectrum", "SysCal");
3267 : }
3268 :
3269 0 : return phaseDiffSpectrum;
3270 : }
3271 :
3272 : /**
3273 : * Set phaseDiffSpectrum with the specified std::vector<std::vector<float > >.
3274 : * @param phaseDiffSpectrum The std::vector<std::vector<float > > value to which phaseDiffSpectrum is to be set.
3275 :
3276 :
3277 : */
3278 0 : void SysCalRow::setPhaseDiffSpectrum (std::vector<std::vector<float > > phaseDiffSpectrum) {
3279 :
3280 0 : this->phaseDiffSpectrum = phaseDiffSpectrum;
3281 :
3282 0 : phaseDiffSpectrumExists = true;
3283 :
3284 0 : }
3285 :
3286 :
3287 : /**
3288 : * Mark phaseDiffSpectrum, which is an optional field, as non-existent.
3289 : */
3290 0 : void SysCalRow::clearPhaseDiffSpectrum () {
3291 0 : phaseDiffSpectrumExists = false;
3292 0 : }
3293 :
3294 :
3295 :
3296 : ///////////////////////////////////////////////
3297 : // Extrinsic Table Attributes getters/setters//
3298 : ///////////////////////////////////////////////
3299 :
3300 :
3301 :
3302 :
3303 : /**
3304 : * Get antennaId.
3305 : * @return antennaId as Tag
3306 : */
3307 0 : Tag SysCalRow::getAntennaId() const {
3308 :
3309 0 : return antennaId;
3310 : }
3311 :
3312 : /**
3313 : * Set antennaId with the specified Tag.
3314 : * @param antennaId The Tag value to which antennaId is to be set.
3315 :
3316 :
3317 :
3318 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3319 :
3320 : */
3321 0 : void SysCalRow::setAntennaId (Tag antennaId) {
3322 :
3323 :
3324 0 : if (hasBeenAdded) {
3325 :
3326 0 : throw IllegalAccessException("antennaId", "SysCal");
3327 :
3328 : }
3329 :
3330 0 : this->antennaId = antennaId;
3331 :
3332 0 : }
3333 :
3334 :
3335 :
3336 :
3337 :
3338 :
3339 : /**
3340 : * Get feedId.
3341 : * @return feedId as int
3342 : */
3343 0 : int SysCalRow::getFeedId() const {
3344 :
3345 0 : return feedId;
3346 : }
3347 :
3348 : /**
3349 : * Set feedId with the specified int.
3350 : * @param feedId The int value to which feedId is to be set.
3351 :
3352 :
3353 :
3354 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3355 :
3356 : */
3357 0 : void SysCalRow::setFeedId (int feedId) {
3358 :
3359 :
3360 0 : if (hasBeenAdded) {
3361 :
3362 0 : throw IllegalAccessException("feedId", "SysCal");
3363 :
3364 : }
3365 :
3366 0 : this->feedId = feedId;
3367 :
3368 0 : }
3369 :
3370 :
3371 :
3372 :
3373 :
3374 :
3375 : /**
3376 : * Get spectralWindowId.
3377 : * @return spectralWindowId as Tag
3378 : */
3379 0 : Tag SysCalRow::getSpectralWindowId() const {
3380 :
3381 0 : return spectralWindowId;
3382 : }
3383 :
3384 : /**
3385 : * Set spectralWindowId with the specified Tag.
3386 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
3387 :
3388 :
3389 :
3390 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3391 :
3392 : */
3393 0 : void SysCalRow::setSpectralWindowId (Tag spectralWindowId) {
3394 :
3395 :
3396 0 : if (hasBeenAdded) {
3397 :
3398 0 : throw IllegalAccessException("spectralWindowId", "SysCal");
3399 :
3400 : }
3401 :
3402 0 : this->spectralWindowId = spectralWindowId;
3403 :
3404 0 : }
3405 :
3406 :
3407 :
3408 :
3409 : //////////////////////////////////////
3410 : // Links Attributes getters/setters //
3411 : //////////////////////////////////////
3412 :
3413 :
3414 :
3415 :
3416 :
3417 :
3418 : /**
3419 : * Returns the pointer to the row in the Antenna table having Antenna.antennaId == antennaId
3420 : * @return a AntennaRow*
3421 : *
3422 :
3423 : */
3424 0 : AntennaRow* SysCalRow::getAntennaUsingAntennaId() {
3425 :
3426 0 : return table.getContainer().getAntenna().getRowByKey(antennaId);
3427 : }
3428 :
3429 :
3430 :
3431 :
3432 :
3433 :
3434 :
3435 :
3436 :
3437 : // ===> Slice link from a row of SysCal table to a collection of row of Feed table.
3438 :
3439 : /**
3440 : * Get the collection of row in the Feed table having their attribut feedId == this->feedId
3441 : */
3442 0 : vector <FeedRow *> SysCalRow::getFeeds() {
3443 :
3444 0 : return table.getContainer().getFeed().getRowByFeedId(feedId);
3445 :
3446 : }
3447 :
3448 :
3449 :
3450 :
3451 :
3452 :
3453 :
3454 :
3455 :
3456 : /**
3457 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.spectralWindowId == spectralWindowId
3458 : * @return a SpectralWindowRow*
3459 : *
3460 :
3461 : */
3462 0 : SpectralWindowRow* SysCalRow::getSpectralWindowUsingSpectralWindowId() {
3463 :
3464 0 : return table.getContainer().getSpectralWindow().getRowByKey(spectralWindowId);
3465 : }
3466 :
3467 :
3468 :
3469 :
3470 :
3471 : /**
3472 : * Create a SysCalRow.
3473 : * <p>
3474 : * This constructor is private because only the
3475 : * table can create rows. All rows know the table
3476 : * to which they belong.
3477 : * @param table The table to which this row belongs.
3478 : */
3479 0 : SysCalRow::SysCalRow (SysCalTable &t) : table(t) {
3480 0 : hasBeenAdded = false;
3481 :
3482 :
3483 :
3484 :
3485 :
3486 :
3487 :
3488 :
3489 :
3490 0 : tcalFlagExists = false;
3491 :
3492 :
3493 :
3494 0 : tcalSpectrumExists = false;
3495 :
3496 :
3497 :
3498 0 : trxFlagExists = false;
3499 :
3500 :
3501 :
3502 0 : trxSpectrumExists = false;
3503 :
3504 :
3505 :
3506 0 : tskyFlagExists = false;
3507 :
3508 :
3509 :
3510 0 : tskySpectrumExists = false;
3511 :
3512 :
3513 :
3514 0 : tsysFlagExists = false;
3515 :
3516 :
3517 :
3518 0 : tsysSpectrumExists = false;
3519 :
3520 :
3521 :
3522 0 : tantFlagExists = false;
3523 :
3524 :
3525 :
3526 0 : tantSpectrumExists = false;
3527 :
3528 :
3529 :
3530 0 : tantTsysFlagExists = false;
3531 :
3532 :
3533 :
3534 0 : tantTsysSpectrumExists = false;
3535 :
3536 :
3537 :
3538 0 : phaseDiffFlagExists = false;
3539 :
3540 :
3541 :
3542 0 : phaseDiffSpectrumExists = false;
3543 :
3544 :
3545 :
3546 :
3547 :
3548 :
3549 :
3550 :
3551 :
3552 :
3553 :
3554 :
3555 :
3556 :
3557 :
3558 :
3559 :
3560 :
3561 :
3562 :
3563 :
3564 :
3565 :
3566 :
3567 :
3568 :
3569 :
3570 :
3571 :
3572 :
3573 :
3574 :
3575 :
3576 :
3577 :
3578 :
3579 :
3580 :
3581 :
3582 :
3583 :
3584 :
3585 :
3586 :
3587 :
3588 :
3589 :
3590 :
3591 0 : fromBinMethods["antennaId"] = &SysCalRow::antennaIdFromBin;
3592 0 : fromBinMethods["spectralWindowId"] = &SysCalRow::spectralWindowIdFromBin;
3593 0 : fromBinMethods["timeInterval"] = &SysCalRow::timeIntervalFromBin;
3594 0 : fromBinMethods["feedId"] = &SysCalRow::feedIdFromBin;
3595 0 : fromBinMethods["numReceptor"] = &SysCalRow::numReceptorFromBin;
3596 0 : fromBinMethods["numChan"] = &SysCalRow::numChanFromBin;
3597 :
3598 :
3599 0 : fromBinMethods["tcalFlag"] = &SysCalRow::tcalFlagFromBin;
3600 0 : fromBinMethods["tcalSpectrum"] = &SysCalRow::tcalSpectrumFromBin;
3601 0 : fromBinMethods["trxFlag"] = &SysCalRow::trxFlagFromBin;
3602 0 : fromBinMethods["trxSpectrum"] = &SysCalRow::trxSpectrumFromBin;
3603 0 : fromBinMethods["tskyFlag"] = &SysCalRow::tskyFlagFromBin;
3604 0 : fromBinMethods["tskySpectrum"] = &SysCalRow::tskySpectrumFromBin;
3605 0 : fromBinMethods["tsysFlag"] = &SysCalRow::tsysFlagFromBin;
3606 0 : fromBinMethods["tsysSpectrum"] = &SysCalRow::tsysSpectrumFromBin;
3607 0 : fromBinMethods["tantFlag"] = &SysCalRow::tantFlagFromBin;
3608 0 : fromBinMethods["tantSpectrum"] = &SysCalRow::tantSpectrumFromBin;
3609 0 : fromBinMethods["tantTsysFlag"] = &SysCalRow::tantTsysFlagFromBin;
3610 0 : fromBinMethods["tantTsysSpectrum"] = &SysCalRow::tantTsysSpectrumFromBin;
3611 0 : fromBinMethods["phaseDiffFlag"] = &SysCalRow::phaseDiffFlagFromBin;
3612 0 : fromBinMethods["phaseDiffSpectrum"] = &SysCalRow::phaseDiffSpectrumFromBin;
3613 :
3614 :
3615 :
3616 :
3617 :
3618 0 : fromTextMethods["antennaId"] = &SysCalRow::antennaIdFromText;
3619 :
3620 :
3621 :
3622 0 : fromTextMethods["spectralWindowId"] = &SysCalRow::spectralWindowIdFromText;
3623 :
3624 :
3625 :
3626 0 : fromTextMethods["timeInterval"] = &SysCalRow::timeIntervalFromText;
3627 :
3628 :
3629 :
3630 0 : fromTextMethods["feedId"] = &SysCalRow::feedIdFromText;
3631 :
3632 :
3633 :
3634 0 : fromTextMethods["numReceptor"] = &SysCalRow::numReceptorFromText;
3635 :
3636 :
3637 :
3638 0 : fromTextMethods["numChan"] = &SysCalRow::numChanFromText;
3639 :
3640 :
3641 :
3642 :
3643 :
3644 0 : fromTextMethods["tcalFlag"] = &SysCalRow::tcalFlagFromText;
3645 :
3646 :
3647 :
3648 0 : fromTextMethods["tcalSpectrum"] = &SysCalRow::tcalSpectrumFromText;
3649 :
3650 :
3651 :
3652 0 : fromTextMethods["trxFlag"] = &SysCalRow::trxFlagFromText;
3653 :
3654 :
3655 :
3656 0 : fromTextMethods["trxSpectrum"] = &SysCalRow::trxSpectrumFromText;
3657 :
3658 :
3659 :
3660 0 : fromTextMethods["tskyFlag"] = &SysCalRow::tskyFlagFromText;
3661 :
3662 :
3663 :
3664 0 : fromTextMethods["tskySpectrum"] = &SysCalRow::tskySpectrumFromText;
3665 :
3666 :
3667 :
3668 0 : fromTextMethods["tsysFlag"] = &SysCalRow::tsysFlagFromText;
3669 :
3670 :
3671 :
3672 0 : fromTextMethods["tsysSpectrum"] = &SysCalRow::tsysSpectrumFromText;
3673 :
3674 :
3675 :
3676 0 : fromTextMethods["tantFlag"] = &SysCalRow::tantFlagFromText;
3677 :
3678 :
3679 :
3680 0 : fromTextMethods["tantSpectrum"] = &SysCalRow::tantSpectrumFromText;
3681 :
3682 :
3683 :
3684 0 : fromTextMethods["tantTsysFlag"] = &SysCalRow::tantTsysFlagFromText;
3685 :
3686 :
3687 :
3688 0 : fromTextMethods["tantTsysSpectrum"] = &SysCalRow::tantTsysSpectrumFromText;
3689 :
3690 :
3691 :
3692 0 : fromTextMethods["phaseDiffFlag"] = &SysCalRow::phaseDiffFlagFromText;
3693 :
3694 :
3695 :
3696 0 : fromTextMethods["phaseDiffSpectrum"] = &SysCalRow::phaseDiffSpectrumFromText;
3697 :
3698 :
3699 0 : }
3700 :
3701 0 : SysCalRow::SysCalRow (SysCalTable &t, SysCalRow *row) : table(t) {
3702 0 : hasBeenAdded = false;
3703 :
3704 0 : if (row == 0) {
3705 :
3706 :
3707 :
3708 :
3709 :
3710 :
3711 :
3712 :
3713 :
3714 0 : tcalFlagExists = false;
3715 :
3716 :
3717 :
3718 0 : tcalSpectrumExists = false;
3719 :
3720 :
3721 :
3722 0 : trxFlagExists = false;
3723 :
3724 :
3725 :
3726 0 : trxSpectrumExists = false;
3727 :
3728 :
3729 :
3730 0 : tskyFlagExists = false;
3731 :
3732 :
3733 :
3734 0 : tskySpectrumExists = false;
3735 :
3736 :
3737 :
3738 0 : tsysFlagExists = false;
3739 :
3740 :
3741 :
3742 0 : tsysSpectrumExists = false;
3743 :
3744 :
3745 :
3746 0 : tantFlagExists = false;
3747 :
3748 :
3749 :
3750 0 : tantSpectrumExists = false;
3751 :
3752 :
3753 :
3754 0 : tantTsysFlagExists = false;
3755 :
3756 :
3757 :
3758 0 : tantTsysSpectrumExists = false;
3759 :
3760 :
3761 :
3762 0 : phaseDiffFlagExists = false;
3763 :
3764 :
3765 :
3766 0 : phaseDiffSpectrumExists = false;
3767 :
3768 :
3769 :
3770 :
3771 :
3772 :
3773 :
3774 :
3775 :
3776 : }
3777 : else {
3778 :
3779 :
3780 0 : antennaId = row->antennaId;
3781 :
3782 0 : spectralWindowId = row->spectralWindowId;
3783 :
3784 0 : timeInterval = row->timeInterval;
3785 :
3786 0 : feedId = row->feedId;
3787 :
3788 :
3789 :
3790 :
3791 0 : numReceptor = row->numReceptor;
3792 :
3793 0 : numChan = row->numChan;
3794 :
3795 :
3796 :
3797 :
3798 0 : if (row->tcalFlagExists) {
3799 0 : tcalFlag = row->tcalFlag;
3800 0 : tcalFlagExists = true;
3801 : }
3802 : else
3803 0 : tcalFlagExists = false;
3804 :
3805 0 : if (row->tcalSpectrumExists) {
3806 0 : tcalSpectrum = row->tcalSpectrum;
3807 0 : tcalSpectrumExists = true;
3808 : }
3809 : else
3810 0 : tcalSpectrumExists = false;
3811 :
3812 0 : if (row->trxFlagExists) {
3813 0 : trxFlag = row->trxFlag;
3814 0 : trxFlagExists = true;
3815 : }
3816 : else
3817 0 : trxFlagExists = false;
3818 :
3819 0 : if (row->trxSpectrumExists) {
3820 0 : trxSpectrum = row->trxSpectrum;
3821 0 : trxSpectrumExists = true;
3822 : }
3823 : else
3824 0 : trxSpectrumExists = false;
3825 :
3826 0 : if (row->tskyFlagExists) {
3827 0 : tskyFlag = row->tskyFlag;
3828 0 : tskyFlagExists = true;
3829 : }
3830 : else
3831 0 : tskyFlagExists = false;
3832 :
3833 0 : if (row->tskySpectrumExists) {
3834 0 : tskySpectrum = row->tskySpectrum;
3835 0 : tskySpectrumExists = true;
3836 : }
3837 : else
3838 0 : tskySpectrumExists = false;
3839 :
3840 0 : if (row->tsysFlagExists) {
3841 0 : tsysFlag = row->tsysFlag;
3842 0 : tsysFlagExists = true;
3843 : }
3844 : else
3845 0 : tsysFlagExists = false;
3846 :
3847 0 : if (row->tsysSpectrumExists) {
3848 0 : tsysSpectrum = row->tsysSpectrum;
3849 0 : tsysSpectrumExists = true;
3850 : }
3851 : else
3852 0 : tsysSpectrumExists = false;
3853 :
3854 0 : if (row->tantFlagExists) {
3855 0 : tantFlag = row->tantFlag;
3856 0 : tantFlagExists = true;
3857 : }
3858 : else
3859 0 : tantFlagExists = false;
3860 :
3861 0 : if (row->tantSpectrumExists) {
3862 0 : tantSpectrum = row->tantSpectrum;
3863 0 : tantSpectrumExists = true;
3864 : }
3865 : else
3866 0 : tantSpectrumExists = false;
3867 :
3868 0 : if (row->tantTsysFlagExists) {
3869 0 : tantTsysFlag = row->tantTsysFlag;
3870 0 : tantTsysFlagExists = true;
3871 : }
3872 : else
3873 0 : tantTsysFlagExists = false;
3874 :
3875 0 : if (row->tantTsysSpectrumExists) {
3876 0 : tantTsysSpectrum = row->tantTsysSpectrum;
3877 0 : tantTsysSpectrumExists = true;
3878 : }
3879 : else
3880 0 : tantTsysSpectrumExists = false;
3881 :
3882 0 : if (row->phaseDiffFlagExists) {
3883 0 : phaseDiffFlag = row->phaseDiffFlag;
3884 0 : phaseDiffFlagExists = true;
3885 : }
3886 : else
3887 0 : phaseDiffFlagExists = false;
3888 :
3889 0 : if (row->phaseDiffSpectrumExists) {
3890 0 : phaseDiffSpectrum = row->phaseDiffSpectrum;
3891 0 : phaseDiffSpectrumExists = true;
3892 : }
3893 : else
3894 0 : phaseDiffSpectrumExists = false;
3895 :
3896 : }
3897 :
3898 0 : fromBinMethods["antennaId"] = &SysCalRow::antennaIdFromBin;
3899 0 : fromBinMethods["spectralWindowId"] = &SysCalRow::spectralWindowIdFromBin;
3900 0 : fromBinMethods["timeInterval"] = &SysCalRow::timeIntervalFromBin;
3901 0 : fromBinMethods["feedId"] = &SysCalRow::feedIdFromBin;
3902 0 : fromBinMethods["numReceptor"] = &SysCalRow::numReceptorFromBin;
3903 0 : fromBinMethods["numChan"] = &SysCalRow::numChanFromBin;
3904 :
3905 :
3906 0 : fromBinMethods["tcalFlag"] = &SysCalRow::tcalFlagFromBin;
3907 0 : fromBinMethods["tcalSpectrum"] = &SysCalRow::tcalSpectrumFromBin;
3908 0 : fromBinMethods["trxFlag"] = &SysCalRow::trxFlagFromBin;
3909 0 : fromBinMethods["trxSpectrum"] = &SysCalRow::trxSpectrumFromBin;
3910 0 : fromBinMethods["tskyFlag"] = &SysCalRow::tskyFlagFromBin;
3911 0 : fromBinMethods["tskySpectrum"] = &SysCalRow::tskySpectrumFromBin;
3912 0 : fromBinMethods["tsysFlag"] = &SysCalRow::tsysFlagFromBin;
3913 0 : fromBinMethods["tsysSpectrum"] = &SysCalRow::tsysSpectrumFromBin;
3914 0 : fromBinMethods["tantFlag"] = &SysCalRow::tantFlagFromBin;
3915 0 : fromBinMethods["tantSpectrum"] = &SysCalRow::tantSpectrumFromBin;
3916 0 : fromBinMethods["tantTsysFlag"] = &SysCalRow::tantTsysFlagFromBin;
3917 0 : fromBinMethods["tantTsysSpectrum"] = &SysCalRow::tantTsysSpectrumFromBin;
3918 0 : fromBinMethods["phaseDiffFlag"] = &SysCalRow::phaseDiffFlagFromBin;
3919 0 : fromBinMethods["phaseDiffSpectrum"] = &SysCalRow::phaseDiffSpectrumFromBin;
3920 :
3921 0 : }
3922 :
3923 :
3924 0 : bool SysCalRow::compareNoAutoInc(Tag antennaId, Tag spectralWindowId, ArrayTimeInterval timeInterval, int feedId, int numReceptor, int numChan) {
3925 : bool result;
3926 0 : result = true;
3927 :
3928 :
3929 :
3930 0 : result = result && (this->antennaId == antennaId);
3931 :
3932 0 : if (!result) return false;
3933 :
3934 :
3935 :
3936 :
3937 0 : result = result && (this->spectralWindowId == spectralWindowId);
3938 :
3939 0 : if (!result) return false;
3940 :
3941 :
3942 :
3943 :
3944 0 : result = result && (this->timeInterval.overlaps(timeInterval));
3945 :
3946 0 : if (!result) return false;
3947 :
3948 :
3949 :
3950 :
3951 0 : result = result && (this->feedId == feedId);
3952 :
3953 0 : if (!result) return false;
3954 :
3955 :
3956 :
3957 :
3958 0 : result = result && (this->numReceptor == numReceptor);
3959 :
3960 0 : if (!result) return false;
3961 :
3962 :
3963 :
3964 :
3965 0 : result = result && (this->numChan == numChan);
3966 :
3967 0 : if (!result) return false;
3968 :
3969 :
3970 0 : return result;
3971 : }
3972 :
3973 :
3974 :
3975 0 : bool SysCalRow::compareRequiredValue(int numReceptor, int numChan) {
3976 : bool result;
3977 0 : result = true;
3978 :
3979 :
3980 0 : if (!(this->numReceptor == numReceptor)) return false;
3981 :
3982 :
3983 :
3984 0 : if (!(this->numChan == numChan)) return false;
3985 :
3986 :
3987 0 : return result;
3988 : }
3989 :
3990 :
3991 : /**
3992 : * Return true if all required attributes of the value part are equal to their homologues
3993 : * in x and false otherwise.
3994 : *
3995 :
3996 : * @param x a pointer on the SysCalRow whose required attributes of the value part
3997 :
3998 : * will be compared with those of this.
3999 : * @return a boolean.
4000 : */
4001 0 : bool SysCalRow::equalByRequiredValue(SysCalRow* x ) {
4002 :
4003 :
4004 0 : if (this->numReceptor != x->numReceptor) return false;
4005 :
4006 0 : if (this->numChan != x->numChan) return false;
4007 :
4008 :
4009 0 : return true;
4010 : }
4011 :
4012 : /*
4013 : map<string, SysCalAttributeFromBin> SysCalRow::initFromBinMethods() {
4014 : map<string, SysCalAttributeFromBin> result;
4015 :
4016 : result["antennaId"] = &SysCalRow::antennaIdFromBin;
4017 : result["spectralWindowId"] = &SysCalRow::spectralWindowIdFromBin;
4018 : result["timeInterval"] = &SysCalRow::timeIntervalFromBin;
4019 : result["feedId"] = &SysCalRow::feedIdFromBin;
4020 : result["numReceptor"] = &SysCalRow::numReceptorFromBin;
4021 : result["numChan"] = &SysCalRow::numChanFromBin;
4022 :
4023 :
4024 : result["tcalFlag"] = &SysCalRow::tcalFlagFromBin;
4025 : result["tcalSpectrum"] = &SysCalRow::tcalSpectrumFromBin;
4026 : result["trxFlag"] = &SysCalRow::trxFlagFromBin;
4027 : result["trxSpectrum"] = &SysCalRow::trxSpectrumFromBin;
4028 : result["tskyFlag"] = &SysCalRow::tskyFlagFromBin;
4029 : result["tskySpectrum"] = &SysCalRow::tskySpectrumFromBin;
4030 : result["tsysFlag"] = &SysCalRow::tsysFlagFromBin;
4031 : result["tsysSpectrum"] = &SysCalRow::tsysSpectrumFromBin;
4032 : result["tantFlag"] = &SysCalRow::tantFlagFromBin;
4033 : result["tantSpectrum"] = &SysCalRow::tantSpectrumFromBin;
4034 : result["tantTsysFlag"] = &SysCalRow::tantTsysFlagFromBin;
4035 : result["tantTsysSpectrum"] = &SysCalRow::tantTsysSpectrumFromBin;
4036 : result["phaseDiffFlag"] = &SysCalRow::phaseDiffFlagFromBin;
4037 : result["phaseDiffSpectrum"] = &SysCalRow::phaseDiffSpectrumFromBin;
4038 :
4039 :
4040 : return result;
4041 : }
4042 : */
4043 : } // End namespace asdm
4044 :
|
