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