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