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