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