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 CalSeeingRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalSeeingRow.h>
39 : #include <alma/ASDM/CalSeeingTable.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::CalSeeingRow;
50 : using asdm::CalSeeingTable;
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 20 : CalSeeingRow::~CalSeeingRow() {
70 20 : }
71 :
72 : /**
73 : * Return the table to which this row belongs.
74 : */
75 0 : CalSeeingTable &CalSeeingRow::getTable() const {
76 0 : return table;
77 : }
78 :
79 0 : bool CalSeeingRow::isAdded() const {
80 0 : return hasBeenAdded;
81 : }
82 :
83 10 : void CalSeeingRow::isAdded(bool added) {
84 10 : hasBeenAdded = added;
85 10 : }
86 :
87 : #ifndef WITHOUT_ACS
88 : using asdmIDL::CalSeeingRowIDL;
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 CalSeeingRowIDL struct.
95 : */
96 : CalSeeingRowIDL *CalSeeingRow::toIDL() const {
97 : CalSeeingRowIDL *x = new CalSeeingRowIDL ();
98 :
99 : // Fill the IDL structure.
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 :
108 : x->atmPhaseCorrection = atmPhaseCorrection;
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 : x->frequencyRange.length(frequencyRange.size());
140 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
141 :
142 : x->frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
143 :
144 : }
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 : x->integrationTime = integrationTime.toIDLInterval();
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 : x->numBaseLengths = numBaseLengths;
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 : x->baselineLengths.length(baselineLengths.size());
177 : for (unsigned int i = 0; i < baselineLengths.size(); ++i) {
178 :
179 : x->baselineLengths[i] = baselineLengths.at(i).toIDLLength();
180 :
181 : }
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 :
191 : x->phaseRMS.length(phaseRMS.size());
192 : for (unsigned int i = 0; i < phaseRMS.size(); ++i) {
193 :
194 : x->phaseRMS[i] = phaseRMS.at(i).toIDLAngle();
195 :
196 : }
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 : x->seeing = seeing.toIDLAngle();
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 : x->seeingError = seeingError.toIDLAngle();
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 : x->exponentExists = exponentExists;
225 :
226 :
227 :
228 :
229 : x->exponent = exponent;
230 :
231 :
232 :
233 :
234 :
235 :
236 :
237 :
238 : x->outerScaleExists = outerScaleExists;
239 :
240 :
241 :
242 : x->outerScale = outerScale.toIDLLength();
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : x->outerScaleRMSExists = outerScaleRMSExists;
251 :
252 :
253 :
254 : x->outerScaleRMS = outerScaleRMS.toIDLAngle();
255 :
256 :
257 :
258 :
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 : x->calDataId = calDataId.toIDLTag();
269 :
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 : x->calReductionId = calReductionId.toIDLTag();
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 : return x;
292 :
293 : }
294 :
295 : void CalSeeingRow::toIDL(asdmIDL::CalSeeingRowIDL& x) const {
296 : // Set the x's fields.
297 :
298 :
299 :
300 :
301 :
302 :
303 :
304 :
305 : x.atmPhaseCorrection = atmPhaseCorrection;
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 : x.startValidTime = startValidTime.toIDLArrayTime();
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 : x.endValidTime = endValidTime.toIDLArrayTime();
327 :
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 :
336 : x.frequencyRange.length(frequencyRange.size());
337 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
338 :
339 : x.frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
340 :
341 : }
342 :
343 :
344 :
345 :
346 :
347 :
348 :
349 :
350 :
351 : x.integrationTime = integrationTime.toIDLInterval();
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 : x.numBaseLengths = numBaseLengths;
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 : x.baselineLengths.length(baselineLengths.size());
374 : for (unsigned int i = 0; i < baselineLengths.size(); ++i) {
375 :
376 : x.baselineLengths[i] = baselineLengths.at(i).toIDLLength();
377 :
378 : }
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 : x.phaseRMS.length(phaseRMS.size());
389 : for (unsigned int i = 0; i < phaseRMS.size(); ++i) {
390 :
391 : x.phaseRMS[i] = phaseRMS.at(i).toIDLAngle();
392 :
393 : }
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 : x.seeing = seeing.toIDLAngle();
404 :
405 :
406 :
407 :
408 :
409 :
410 :
411 :
412 :
413 : x.seeingError = seeingError.toIDLAngle();
414 :
415 :
416 :
417 :
418 :
419 :
420 :
421 : x.exponentExists = exponentExists;
422 :
423 :
424 :
425 :
426 : x.exponent = exponent;
427 :
428 :
429 :
430 :
431 :
432 :
433 :
434 :
435 : x.outerScaleExists = outerScaleExists;
436 :
437 :
438 :
439 : x.outerScale = outerScale.toIDLLength();
440 :
441 :
442 :
443 :
444 :
445 :
446 :
447 : x.outerScaleRMSExists = outerScaleRMSExists;
448 :
449 :
450 :
451 : x.outerScaleRMS = outerScaleRMS.toIDLAngle();
452 :
453 :
454 :
455 :
456 :
457 :
458 :
459 :
460 :
461 :
462 :
463 :
464 :
465 : x.calDataId = calDataId.toIDLTag();
466 :
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 : x.calReductionId = calReductionId.toIDLTag();
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 :
487 :
488 : }
489 : #endif
490 :
491 :
492 : #ifndef WITHOUT_ACS
493 : /**
494 : * Fill the values of this row from the IDL struct CalSeeingRowIDL.
495 : * @param x The IDL struct containing the values used to fill this row.
496 : */
497 : void CalSeeingRow::setFromIDL (CalSeeingRowIDL x){
498 : try {
499 : // Fill the values from x.
500 :
501 :
502 :
503 :
504 :
505 :
506 : setAtmPhaseCorrection(x.atmPhaseCorrection);
507 :
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 :
516 : setStartValidTime(ArrayTime (x.startValidTime));
517 :
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 :
526 : setEndValidTime(ArrayTime (x.endValidTime));
527 :
528 :
529 :
530 :
531 :
532 :
533 :
534 :
535 :
536 : frequencyRange .clear();
537 : for (unsigned int i = 0; i <x.frequencyRange.length(); ++i) {
538 :
539 : frequencyRange.push_back(Frequency (x.frequencyRange[i]));
540 :
541 : }
542 :
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 : setIntegrationTime(Interval (x.integrationTime));
552 :
553 :
554 :
555 :
556 :
557 :
558 :
559 :
560 :
561 : setNumBaseLengths(x.numBaseLengths);
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 :
570 :
571 : baselineLengths .clear();
572 : for (unsigned int i = 0; i <x.baselineLengths.length(); ++i) {
573 :
574 : baselineLengths.push_back(Length (x.baselineLengths[i]));
575 :
576 : }
577 :
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 :
586 : phaseRMS .clear();
587 : for (unsigned int i = 0; i <x.phaseRMS.length(); ++i) {
588 :
589 : phaseRMS.push_back(Angle (x.phaseRMS[i]));
590 :
591 : }
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 :
601 : setSeeing(Angle (x.seeing));
602 :
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 : setSeeingError(Angle (x.seeingError));
612 :
613 :
614 :
615 :
616 :
617 :
618 :
619 : exponentExists = x.exponentExists;
620 : if (x.exponentExists) {
621 :
622 :
623 :
624 : setExponent(x.exponent);
625 :
626 :
627 :
628 : }
629 :
630 :
631 :
632 :
633 :
634 : outerScaleExists = x.outerScaleExists;
635 : if (x.outerScaleExists) {
636 :
637 :
638 :
639 : setOuterScale(Length (x.outerScale));
640 :
641 :
642 :
643 : }
644 :
645 :
646 :
647 :
648 :
649 : outerScaleRMSExists = x.outerScaleRMSExists;
650 : if (x.outerScaleRMSExists) {
651 :
652 :
653 :
654 : setOuterScaleRMS(Angle (x.outerScaleRMS));
655 :
656 :
657 :
658 : }
659 :
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 : setCalDataId(Tag (x.calDataId));
670 :
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 : setCalReductionId(Tag (x.calReductionId));
680 :
681 :
682 :
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 :
691 : } catch (const IllegalAccessException &err) {
692 : throw ConversionException (err.getMessage(),"CalSeeing");
693 : }
694 : }
695 : #endif
696 :
697 : /**
698 : * Return this row in the form of an XML string.
699 : * @return The values of this row as an XML string.
700 : */
701 0 : string CalSeeingRow::toXML() const {
702 0 : string buf;
703 0 : buf.append("<row> \n");
704 :
705 :
706 :
707 :
708 :
709 :
710 0 : buf.append(EnumerationParser::toXML("atmPhaseCorrection", atmPhaseCorrection));
711 :
712 :
713 :
714 :
715 :
716 :
717 :
718 0 : Parser::toXML(startValidTime, "startValidTime", buf);
719 :
720 :
721 :
722 :
723 :
724 :
725 :
726 0 : Parser::toXML(endValidTime, "endValidTime", buf);
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 0 : Parser::toXML(frequencyRange, "frequencyRange", buf);
735 :
736 :
737 :
738 :
739 :
740 :
741 :
742 0 : Parser::toXML(integrationTime, "integrationTime", buf);
743 :
744 :
745 :
746 :
747 :
748 :
749 :
750 0 : Parser::toXML(numBaseLengths, "numBaseLengths", buf);
751 :
752 :
753 :
754 :
755 :
756 :
757 :
758 0 : Parser::toXML(baselineLengths, "baselineLengths", buf);
759 :
760 :
761 :
762 :
763 :
764 :
765 :
766 0 : Parser::toXML(phaseRMS, "phaseRMS", buf);
767 :
768 :
769 :
770 :
771 :
772 :
773 :
774 0 : Parser::toXML(seeing, "seeing", buf);
775 :
776 :
777 :
778 :
779 :
780 :
781 :
782 0 : Parser::toXML(seeingError, "seeingError", buf);
783 :
784 :
785 :
786 :
787 :
788 :
789 0 : if (exponentExists) {
790 :
791 :
792 0 : Parser::toXML(exponent, "exponent", buf);
793 :
794 :
795 : }
796 :
797 :
798 :
799 :
800 :
801 0 : if (outerScaleExists) {
802 :
803 :
804 0 : Parser::toXML(outerScale, "outerScale", buf);
805 :
806 :
807 : }
808 :
809 :
810 :
811 :
812 :
813 0 : if (outerScaleRMSExists) {
814 :
815 :
816 0 : Parser::toXML(outerScaleRMS, "outerScaleRMS", buf);
817 :
818 :
819 : }
820 :
821 :
822 :
823 :
824 :
825 :
826 :
827 :
828 :
829 0 : Parser::toXML(calDataId, "calDataId", buf);
830 :
831 :
832 :
833 :
834 :
835 :
836 :
837 0 : Parser::toXML(calReductionId, "calReductionId", buf);
838 :
839 :
840 :
841 :
842 :
843 :
844 :
845 :
846 :
847 :
848 :
849 0 : buf.append("</row>\n");
850 0 : return buf;
851 0 : }
852 :
853 : /**
854 : * Fill the values of this row from an XML string
855 : * that was produced by the toXML() method.
856 : * @param x The XML string being used to set the values of this row.
857 : */
858 5 : void CalSeeingRow::setFromXML (string rowDoc) {
859 5 : Parser row(rowDoc);
860 5 : string s = "";
861 : try {
862 :
863 :
864 :
865 :
866 :
867 :
868 5 : atmPhaseCorrection = EnumerationParser::getAtmPhaseCorrection("atmPhaseCorrection","CalSeeing",rowDoc);
869 :
870 :
871 :
872 :
873 :
874 :
875 :
876 :
877 5 : setStartValidTime(Parser::getArrayTime("startValidTime","CalSeeing",rowDoc));
878 :
879 :
880 :
881 :
882 :
883 :
884 :
885 5 : setEndValidTime(Parser::getArrayTime("endValidTime","CalSeeing",rowDoc));
886 :
887 :
888 :
889 :
890 :
891 :
892 :
893 :
894 5 : setFrequencyRange(Parser::get1DFrequency("frequencyRange","CalSeeing",rowDoc));
895 :
896 :
897 :
898 :
899 :
900 :
901 :
902 :
903 5 : setIntegrationTime(Parser::getInterval("integrationTime","CalSeeing",rowDoc));
904 :
905 :
906 :
907 :
908 :
909 :
910 :
911 5 : setNumBaseLengths(Parser::getInteger("numBaseLengths","CalSeeing",rowDoc));
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 :
920 5 : setBaselineLengths(Parser::get1DLength("baselineLengths","CalSeeing",rowDoc));
921 :
922 :
923 :
924 :
925 :
926 :
927 :
928 :
929 :
930 5 : setPhaseRMS(Parser::get1DAngle("phaseRMS","CalSeeing",rowDoc));
931 :
932 :
933 :
934 :
935 :
936 :
937 :
938 :
939 5 : setSeeing(Parser::getAngle("seeing","CalSeeing",rowDoc));
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 5 : setSeeingError(Parser::getAngle("seeingError","CalSeeing",rowDoc));
948 :
949 :
950 :
951 :
952 :
953 :
954 5 : if (row.isStr("<exponent>")) {
955 :
956 0 : setExponent(Parser::getFloat("exponent","CalSeeing",rowDoc));
957 :
958 : }
959 :
960 :
961 :
962 :
963 :
964 5 : if (row.isStr("<outerScale>")) {
965 :
966 0 : setOuterScale(Parser::getLength("outerScale","CalSeeing",rowDoc));
967 :
968 : }
969 :
970 :
971 :
972 :
973 :
974 5 : if (row.isStr("<outerScaleRMS>")) {
975 :
976 0 : setOuterScaleRMS(Parser::getAngle("outerScaleRMS","CalSeeing",rowDoc));
977 :
978 : }
979 :
980 :
981 :
982 :
983 :
984 :
985 :
986 :
987 :
988 5 : setCalDataId(Parser::getTag("calDataId","CalData",rowDoc));
989 :
990 :
991 :
992 :
993 :
994 :
995 :
996 5 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
997 :
998 :
999 :
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 0 : } catch (const IllegalAccessException &err) {
1008 0 : throw ConversionException (err.getMessage(),"CalSeeing");
1009 0 : }
1010 5 : }
1011 :
1012 0 : void CalSeeingRow::toBin(EndianOSStream& eoss) {
1013 :
1014 :
1015 :
1016 :
1017 :
1018 :
1019 0 : eoss.writeString(CAtmPhaseCorrection::name(atmPhaseCorrection));
1020 : /* eoss.writeInt(atmPhaseCorrection); */
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 0 : calDataId.toBin(eoss);
1029 :
1030 :
1031 :
1032 :
1033 :
1034 :
1035 0 : calReductionId.toBin(eoss);
1036 :
1037 :
1038 :
1039 :
1040 :
1041 :
1042 0 : startValidTime.toBin(eoss);
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 0 : endValidTime.toBin(eoss);
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 0 : Frequency::toBin(frequencyRange, eoss);
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 0 : integrationTime.toBin(eoss);
1064 :
1065 :
1066 :
1067 :
1068 :
1069 :
1070 :
1071 0 : eoss.writeInt(numBaseLengths);
1072 :
1073 :
1074 :
1075 :
1076 :
1077 :
1078 :
1079 0 : Length::toBin(baselineLengths, eoss);
1080 :
1081 :
1082 :
1083 :
1084 :
1085 :
1086 0 : Angle::toBin(phaseRMS, eoss);
1087 :
1088 :
1089 :
1090 :
1091 :
1092 :
1093 0 : seeing.toBin(eoss);
1094 :
1095 :
1096 :
1097 :
1098 :
1099 :
1100 0 : seeingError.toBin(eoss);
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 0 : eoss.writeBoolean(exponentExists);
1108 0 : if (exponentExists) {
1109 :
1110 :
1111 :
1112 :
1113 :
1114 0 : eoss.writeFloat(exponent);
1115 :
1116 :
1117 :
1118 :
1119 : }
1120 :
1121 0 : eoss.writeBoolean(outerScaleExists);
1122 0 : if (outerScaleExists) {
1123 :
1124 :
1125 :
1126 :
1127 0 : outerScale.toBin(eoss);
1128 :
1129 :
1130 :
1131 : }
1132 :
1133 0 : eoss.writeBoolean(outerScaleRMSExists);
1134 0 : if (outerScaleRMSExists) {
1135 :
1136 :
1137 :
1138 :
1139 0 : outerScaleRMS.toBin(eoss);
1140 :
1141 :
1142 :
1143 : }
1144 :
1145 0 : }
1146 :
1147 5 : void CalSeeingRow::atmPhaseCorrectionFromBin(EndianIStream& eis) {
1148 :
1149 :
1150 :
1151 :
1152 :
1153 5 : atmPhaseCorrection = CAtmPhaseCorrection::literal(eis.readString());
1154 :
1155 :
1156 :
1157 :
1158 5 : }
1159 5 : void CalSeeingRow::calDataIdFromBin(EndianIStream& eis) {
1160 :
1161 :
1162 :
1163 :
1164 5 : calDataId = Tag::fromBin(eis);
1165 :
1166 :
1167 :
1168 5 : }
1169 5 : void CalSeeingRow::calReductionIdFromBin(EndianIStream& eis) {
1170 :
1171 :
1172 :
1173 :
1174 5 : calReductionId = Tag::fromBin(eis);
1175 :
1176 :
1177 :
1178 5 : }
1179 5 : void CalSeeingRow::startValidTimeFromBin(EndianIStream& eis) {
1180 :
1181 :
1182 :
1183 :
1184 5 : startValidTime = ArrayTime::fromBin(eis);
1185 :
1186 :
1187 :
1188 5 : }
1189 5 : void CalSeeingRow::endValidTimeFromBin(EndianIStream& eis) {
1190 :
1191 :
1192 :
1193 :
1194 5 : endValidTime = ArrayTime::fromBin(eis);
1195 :
1196 :
1197 :
1198 5 : }
1199 5 : void CalSeeingRow::frequencyRangeFromBin(EndianIStream& eis) {
1200 :
1201 :
1202 :
1203 :
1204 :
1205 :
1206 5 : frequencyRange = Frequency::from1DBin(eis);
1207 :
1208 :
1209 :
1210 :
1211 :
1212 5 : }
1213 5 : void CalSeeingRow::integrationTimeFromBin(EndianIStream& eis) {
1214 :
1215 :
1216 :
1217 :
1218 5 : integrationTime = Interval::fromBin(eis);
1219 :
1220 :
1221 :
1222 5 : }
1223 5 : void CalSeeingRow::numBaseLengthsFromBin(EndianIStream& eis) {
1224 :
1225 :
1226 :
1227 :
1228 :
1229 5 : numBaseLengths = eis.readInt();
1230 :
1231 :
1232 :
1233 :
1234 5 : }
1235 5 : void CalSeeingRow::baselineLengthsFromBin(EndianIStream& eis) {
1236 :
1237 :
1238 :
1239 :
1240 :
1241 :
1242 5 : baselineLengths = Length::from1DBin(eis);
1243 :
1244 :
1245 :
1246 :
1247 :
1248 5 : }
1249 5 : void CalSeeingRow::phaseRMSFromBin(EndianIStream& eis) {
1250 :
1251 :
1252 :
1253 :
1254 :
1255 :
1256 5 : phaseRMS = Angle::from1DBin(eis);
1257 :
1258 :
1259 :
1260 :
1261 :
1262 5 : }
1263 5 : void CalSeeingRow::seeingFromBin(EndianIStream& eis) {
1264 :
1265 :
1266 :
1267 :
1268 5 : seeing = Angle::fromBin(eis);
1269 :
1270 :
1271 :
1272 5 : }
1273 5 : void CalSeeingRow::seeingErrorFromBin(EndianIStream& eis) {
1274 :
1275 :
1276 :
1277 :
1278 5 : seeingError = Angle::fromBin(eis);
1279 :
1280 :
1281 :
1282 5 : }
1283 :
1284 5 : void CalSeeingRow::exponentFromBin(EndianIStream& eis) {
1285 :
1286 5 : exponentExists = eis.readBoolean();
1287 5 : if (exponentExists) {
1288 :
1289 :
1290 :
1291 :
1292 :
1293 0 : exponent = eis.readFloat();
1294 :
1295 :
1296 :
1297 :
1298 : }
1299 :
1300 5 : }
1301 5 : void CalSeeingRow::outerScaleFromBin(EndianIStream& eis) {
1302 :
1303 5 : outerScaleExists = eis.readBoolean();
1304 5 : if (outerScaleExists) {
1305 :
1306 :
1307 :
1308 :
1309 0 : outerScale = Length::fromBin(eis);
1310 :
1311 :
1312 :
1313 : }
1314 :
1315 5 : }
1316 5 : void CalSeeingRow::outerScaleRMSFromBin(EndianIStream& eis) {
1317 :
1318 5 : outerScaleRMSExists = eis.readBoolean();
1319 5 : if (outerScaleRMSExists) {
1320 :
1321 :
1322 :
1323 :
1324 0 : outerScaleRMS = Angle::fromBin(eis);
1325 :
1326 :
1327 :
1328 : }
1329 :
1330 5 : }
1331 :
1332 :
1333 5 : CalSeeingRow* CalSeeingRow::fromBin(EndianIStream& eis, CalSeeingTable& table, const vector<string>& attributesSeq) {
1334 5 : CalSeeingRow* row = new CalSeeingRow(table);
1335 :
1336 5 : map<string, CalSeeingAttributeFromBin>::iterator iter ;
1337 80 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1338 75 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1339 75 : if (iter != row->fromBinMethods.end()) {
1340 75 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1341 : }
1342 : else {
1343 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1344 0 : if (functorP)
1345 0 : (*functorP)(eis);
1346 : else
1347 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalSeeingTable");
1348 : }
1349 :
1350 : }
1351 5 : return row;
1352 : }
1353 :
1354 : //
1355 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1356 : // of one row.
1357 : //
1358 :
1359 : // Convert a string into an AtmPhaseCorrection
1360 0 : void CalSeeingRow::atmPhaseCorrectionFromText(const string & s) {
1361 :
1362 :
1363 0 : atmPhaseCorrection = ASDMValuesParser::parse<AtmPhaseCorrectionMod::AtmPhaseCorrection>(s);
1364 :
1365 :
1366 0 : }
1367 :
1368 :
1369 : // Convert a string into an Tag
1370 0 : void CalSeeingRow::calDataIdFromText(const string & s) {
1371 :
1372 :
1373 0 : calDataId = ASDMValuesParser::parse<Tag>(s);
1374 :
1375 :
1376 0 : }
1377 :
1378 :
1379 : // Convert a string into an Tag
1380 0 : void CalSeeingRow::calReductionIdFromText(const string & s) {
1381 :
1382 :
1383 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
1384 :
1385 :
1386 0 : }
1387 :
1388 :
1389 : // Convert a string into an ArrayTime
1390 0 : void CalSeeingRow::startValidTimeFromText(const string & s) {
1391 :
1392 :
1393 0 : startValidTime = ASDMValuesParser::parse<ArrayTime>(s);
1394 :
1395 :
1396 0 : }
1397 :
1398 :
1399 : // Convert a string into an ArrayTime
1400 0 : void CalSeeingRow::endValidTimeFromText(const string & s) {
1401 :
1402 :
1403 0 : endValidTime = ASDMValuesParser::parse<ArrayTime>(s);
1404 :
1405 :
1406 0 : }
1407 :
1408 :
1409 : // Convert a string into an Frequency
1410 0 : void CalSeeingRow::frequencyRangeFromText(const string & s) {
1411 :
1412 :
1413 0 : frequencyRange = ASDMValuesParser::parse1D<Frequency>(s);
1414 :
1415 :
1416 0 : }
1417 :
1418 :
1419 : // Convert a string into an Interval
1420 0 : void CalSeeingRow::integrationTimeFromText(const string & s) {
1421 :
1422 :
1423 0 : integrationTime = ASDMValuesParser::parse<Interval>(s);
1424 :
1425 :
1426 0 : }
1427 :
1428 :
1429 : // Convert a string into an int
1430 0 : void CalSeeingRow::numBaseLengthsFromText(const string & s) {
1431 :
1432 :
1433 0 : numBaseLengths = ASDMValuesParser::parse<int>(s);
1434 :
1435 :
1436 0 : }
1437 :
1438 :
1439 : // Convert a string into an Length
1440 0 : void CalSeeingRow::baselineLengthsFromText(const string & s) {
1441 :
1442 :
1443 0 : baselineLengths = ASDMValuesParser::parse1D<Length>(s);
1444 :
1445 :
1446 0 : }
1447 :
1448 :
1449 : // Convert a string into an Angle
1450 0 : void CalSeeingRow::phaseRMSFromText(const string & s) {
1451 :
1452 :
1453 0 : phaseRMS = ASDMValuesParser::parse1D<Angle>(s);
1454 :
1455 :
1456 0 : }
1457 :
1458 :
1459 : // Convert a string into an Angle
1460 0 : void CalSeeingRow::seeingFromText(const string & s) {
1461 :
1462 :
1463 0 : seeing = ASDMValuesParser::parse<Angle>(s);
1464 :
1465 :
1466 0 : }
1467 :
1468 :
1469 : // Convert a string into an Angle
1470 0 : void CalSeeingRow::seeingErrorFromText(const string & s) {
1471 :
1472 :
1473 0 : seeingError = ASDMValuesParser::parse<Angle>(s);
1474 :
1475 :
1476 0 : }
1477 :
1478 :
1479 :
1480 : // Convert a string into an float
1481 0 : void CalSeeingRow::exponentFromText(const string & s) {
1482 0 : exponentExists = true;
1483 :
1484 :
1485 0 : exponent = ASDMValuesParser::parse<float>(s);
1486 :
1487 :
1488 0 : }
1489 :
1490 :
1491 : // Convert a string into an Length
1492 0 : void CalSeeingRow::outerScaleFromText(const string & s) {
1493 0 : outerScaleExists = true;
1494 :
1495 :
1496 0 : outerScale = ASDMValuesParser::parse<Length>(s);
1497 :
1498 :
1499 0 : }
1500 :
1501 :
1502 : // Convert a string into an Angle
1503 0 : void CalSeeingRow::outerScaleRMSFromText(const string & s) {
1504 0 : outerScaleRMSExists = true;
1505 :
1506 :
1507 0 : outerScaleRMS = ASDMValuesParser::parse<Angle>(s);
1508 :
1509 :
1510 0 : }
1511 :
1512 :
1513 :
1514 0 : void CalSeeingRow::fromText(const std::string& attributeName, const std::string& t) {
1515 0 : map<string, CalSeeingAttributeFromText>::iterator iter;
1516 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1517 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalSeeingTable");
1518 0 : (this->*(iter->second))(t);
1519 0 : }
1520 :
1521 : ////////////////////////////////////////////////
1522 : // Intrinsic Table Attributes getters/setters //
1523 : ////////////////////////////////////////////////
1524 :
1525 :
1526 :
1527 :
1528 : /**
1529 : * Get atmPhaseCorrection.
1530 : * @return atmPhaseCorrection as AtmPhaseCorrectionMod::AtmPhaseCorrection
1531 : */
1532 15 : AtmPhaseCorrectionMod::AtmPhaseCorrection CalSeeingRow::getAtmPhaseCorrection() const {
1533 :
1534 15 : return atmPhaseCorrection;
1535 : }
1536 :
1537 : /**
1538 : * Set atmPhaseCorrection with the specified AtmPhaseCorrectionMod::AtmPhaseCorrection.
1539 : * @param atmPhaseCorrection The AtmPhaseCorrectionMod::AtmPhaseCorrection value to which atmPhaseCorrection is to be set.
1540 :
1541 :
1542 :
1543 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1544 :
1545 : */
1546 0 : void CalSeeingRow::setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection) {
1547 :
1548 :
1549 0 : if (hasBeenAdded) {
1550 :
1551 0 : throw IllegalAccessException("atmPhaseCorrection", "CalSeeing");
1552 :
1553 : }
1554 :
1555 0 : this->atmPhaseCorrection = atmPhaseCorrection;
1556 :
1557 0 : }
1558 :
1559 :
1560 :
1561 :
1562 :
1563 :
1564 : /**
1565 : * Get startValidTime.
1566 : * @return startValidTime as ArrayTime
1567 : */
1568 10 : ArrayTime CalSeeingRow::getStartValidTime() const {
1569 :
1570 10 : return startValidTime;
1571 : }
1572 :
1573 : /**
1574 : * Set startValidTime with the specified ArrayTime.
1575 : * @param startValidTime The ArrayTime value to which startValidTime is to be set.
1576 :
1577 :
1578 :
1579 : */
1580 5 : void CalSeeingRow::setStartValidTime (ArrayTime startValidTime) {
1581 :
1582 :
1583 5 : if (hasBeenAdded) {
1584 :
1585 : }
1586 :
1587 5 : this->startValidTime = startValidTime;
1588 :
1589 5 : }
1590 :
1591 :
1592 :
1593 :
1594 :
1595 :
1596 : /**
1597 : * Get endValidTime.
1598 : * @return endValidTime as ArrayTime
1599 : */
1600 10 : ArrayTime CalSeeingRow::getEndValidTime() const {
1601 :
1602 10 : return endValidTime;
1603 : }
1604 :
1605 : /**
1606 : * Set endValidTime with the specified ArrayTime.
1607 : * @param endValidTime The ArrayTime value to which endValidTime is to be set.
1608 :
1609 :
1610 :
1611 : */
1612 5 : void CalSeeingRow::setEndValidTime (ArrayTime endValidTime) {
1613 :
1614 :
1615 5 : if (hasBeenAdded) {
1616 :
1617 : }
1618 :
1619 5 : this->endValidTime = endValidTime;
1620 :
1621 5 : }
1622 :
1623 :
1624 :
1625 :
1626 :
1627 :
1628 : /**
1629 : * Get frequencyRange.
1630 : * @return frequencyRange as std::vector<Frequency >
1631 : */
1632 10 : std::vector<Frequency > CalSeeingRow::getFrequencyRange() const {
1633 :
1634 10 : return frequencyRange;
1635 : }
1636 :
1637 : /**
1638 : * Set frequencyRange with the specified std::vector<Frequency >.
1639 : * @param frequencyRange The std::vector<Frequency > value to which frequencyRange is to be set.
1640 :
1641 :
1642 :
1643 : */
1644 5 : void CalSeeingRow::setFrequencyRange (std::vector<Frequency > frequencyRange) {
1645 :
1646 :
1647 5 : if (hasBeenAdded) {
1648 :
1649 : }
1650 :
1651 5 : this->frequencyRange = frequencyRange;
1652 :
1653 5 : }
1654 :
1655 :
1656 :
1657 :
1658 :
1659 :
1660 : /**
1661 : * Get integrationTime.
1662 : * @return integrationTime as Interval
1663 : */
1664 10 : Interval CalSeeingRow::getIntegrationTime() const {
1665 :
1666 10 : return integrationTime;
1667 : }
1668 :
1669 : /**
1670 : * Set integrationTime with the specified Interval.
1671 : * @param integrationTime The Interval value to which integrationTime is to be set.
1672 :
1673 :
1674 :
1675 : */
1676 5 : void CalSeeingRow::setIntegrationTime (Interval integrationTime) {
1677 :
1678 :
1679 5 : if (hasBeenAdded) {
1680 :
1681 : }
1682 :
1683 5 : this->integrationTime = integrationTime;
1684 :
1685 5 : }
1686 :
1687 :
1688 :
1689 :
1690 :
1691 :
1692 : /**
1693 : * Get numBaseLengths.
1694 : * @return numBaseLengths as int
1695 : */
1696 10 : int CalSeeingRow::getNumBaseLengths() const {
1697 :
1698 10 : return numBaseLengths;
1699 : }
1700 :
1701 : /**
1702 : * Set numBaseLengths with the specified int.
1703 : * @param numBaseLengths The int value to which numBaseLengths is to be set.
1704 :
1705 :
1706 :
1707 : */
1708 5 : void CalSeeingRow::setNumBaseLengths (int numBaseLengths) {
1709 :
1710 :
1711 5 : if (hasBeenAdded) {
1712 :
1713 : }
1714 :
1715 5 : this->numBaseLengths = numBaseLengths;
1716 :
1717 5 : }
1718 :
1719 :
1720 :
1721 :
1722 :
1723 :
1724 : /**
1725 : * Get baselineLengths.
1726 : * @return baselineLengths as std::vector<Length >
1727 : */
1728 10 : std::vector<Length > CalSeeingRow::getBaselineLengths() const {
1729 :
1730 10 : return baselineLengths;
1731 : }
1732 :
1733 : /**
1734 : * Set baselineLengths with the specified std::vector<Length >.
1735 : * @param baselineLengths The std::vector<Length > value to which baselineLengths is to be set.
1736 :
1737 :
1738 :
1739 : */
1740 5 : void CalSeeingRow::setBaselineLengths (std::vector<Length > baselineLengths) {
1741 :
1742 :
1743 5 : if (hasBeenAdded) {
1744 :
1745 : }
1746 :
1747 5 : this->baselineLengths = baselineLengths;
1748 :
1749 5 : }
1750 :
1751 :
1752 :
1753 :
1754 :
1755 :
1756 : /**
1757 : * Get phaseRMS.
1758 : * @return phaseRMS as std::vector<Angle >
1759 : */
1760 10 : std::vector<Angle > CalSeeingRow::getPhaseRMS() const {
1761 :
1762 10 : return phaseRMS;
1763 : }
1764 :
1765 : /**
1766 : * Set phaseRMS with the specified std::vector<Angle >.
1767 : * @param phaseRMS The std::vector<Angle > value to which phaseRMS is to be set.
1768 :
1769 :
1770 :
1771 : */
1772 5 : void CalSeeingRow::setPhaseRMS (std::vector<Angle > phaseRMS) {
1773 :
1774 :
1775 5 : if (hasBeenAdded) {
1776 :
1777 : }
1778 :
1779 5 : this->phaseRMS = phaseRMS;
1780 :
1781 5 : }
1782 :
1783 :
1784 :
1785 :
1786 :
1787 :
1788 : /**
1789 : * Get seeing.
1790 : * @return seeing as Angle
1791 : */
1792 10 : Angle CalSeeingRow::getSeeing() const {
1793 :
1794 10 : return seeing;
1795 : }
1796 :
1797 : /**
1798 : * Set seeing with the specified Angle.
1799 : * @param seeing The Angle value to which seeing is to be set.
1800 :
1801 :
1802 :
1803 : */
1804 5 : void CalSeeingRow::setSeeing (Angle seeing) {
1805 :
1806 :
1807 5 : if (hasBeenAdded) {
1808 :
1809 : }
1810 :
1811 5 : this->seeing = seeing;
1812 :
1813 5 : }
1814 :
1815 :
1816 :
1817 :
1818 :
1819 :
1820 : /**
1821 : * Get seeingError.
1822 : * @return seeingError as Angle
1823 : */
1824 10 : Angle CalSeeingRow::getSeeingError() const {
1825 :
1826 10 : return seeingError;
1827 : }
1828 :
1829 : /**
1830 : * Set seeingError with the specified Angle.
1831 : * @param seeingError The Angle value to which seeingError is to be set.
1832 :
1833 :
1834 :
1835 : */
1836 5 : void CalSeeingRow::setSeeingError (Angle seeingError) {
1837 :
1838 :
1839 5 : if (hasBeenAdded) {
1840 :
1841 : }
1842 :
1843 5 : this->seeingError = seeingError;
1844 :
1845 5 : }
1846 :
1847 :
1848 :
1849 :
1850 : /**
1851 : * The attribute exponent is optional. Return true if this attribute exists.
1852 : * @return true if and only if the exponent attribute exists.
1853 : */
1854 10 : bool CalSeeingRow::isExponentExists() const {
1855 10 : return exponentExists;
1856 : }
1857 :
1858 :
1859 :
1860 : /**
1861 : * Get exponent, which is optional.
1862 : * @return exponent as float
1863 : * @throw IllegalAccessException If exponent does not exist.
1864 : */
1865 0 : float CalSeeingRow::getExponent() const {
1866 0 : if (!exponentExists) {
1867 0 : throw IllegalAccessException("exponent", "CalSeeing");
1868 : }
1869 :
1870 0 : return exponent;
1871 : }
1872 :
1873 : /**
1874 : * Set exponent with the specified float.
1875 : * @param exponent The float value to which exponent is to be set.
1876 :
1877 :
1878 : */
1879 0 : void CalSeeingRow::setExponent (float exponent) {
1880 :
1881 0 : this->exponent = exponent;
1882 :
1883 0 : exponentExists = true;
1884 :
1885 0 : }
1886 :
1887 :
1888 : /**
1889 : * Mark exponent, which is an optional field, as non-existent.
1890 : */
1891 0 : void CalSeeingRow::clearExponent () {
1892 0 : exponentExists = false;
1893 0 : }
1894 :
1895 :
1896 :
1897 : /**
1898 : * The attribute outerScale is optional. Return true if this attribute exists.
1899 : * @return true if and only if the outerScale attribute exists.
1900 : */
1901 10 : bool CalSeeingRow::isOuterScaleExists() const {
1902 10 : return outerScaleExists;
1903 : }
1904 :
1905 :
1906 :
1907 : /**
1908 : * Get outerScale, which is optional.
1909 : * @return outerScale as Length
1910 : * @throw IllegalAccessException If outerScale does not exist.
1911 : */
1912 0 : Length CalSeeingRow::getOuterScale() const {
1913 0 : if (!outerScaleExists) {
1914 0 : throw IllegalAccessException("outerScale", "CalSeeing");
1915 : }
1916 :
1917 0 : return outerScale;
1918 : }
1919 :
1920 : /**
1921 : * Set outerScale with the specified Length.
1922 : * @param outerScale The Length value to which outerScale is to be set.
1923 :
1924 :
1925 : */
1926 0 : void CalSeeingRow::setOuterScale (Length outerScale) {
1927 :
1928 0 : this->outerScale = outerScale;
1929 :
1930 0 : outerScaleExists = true;
1931 :
1932 0 : }
1933 :
1934 :
1935 : /**
1936 : * Mark outerScale, which is an optional field, as non-existent.
1937 : */
1938 0 : void CalSeeingRow::clearOuterScale () {
1939 0 : outerScaleExists = false;
1940 0 : }
1941 :
1942 :
1943 :
1944 : /**
1945 : * The attribute outerScaleRMS is optional. Return true if this attribute exists.
1946 : * @return true if and only if the outerScaleRMS attribute exists.
1947 : */
1948 10 : bool CalSeeingRow::isOuterScaleRMSExists() const {
1949 10 : return outerScaleRMSExists;
1950 : }
1951 :
1952 :
1953 :
1954 : /**
1955 : * Get outerScaleRMS, which is optional.
1956 : * @return outerScaleRMS as Angle
1957 : * @throw IllegalAccessException If outerScaleRMS does not exist.
1958 : */
1959 0 : Angle CalSeeingRow::getOuterScaleRMS() const {
1960 0 : if (!outerScaleRMSExists) {
1961 0 : throw IllegalAccessException("outerScaleRMS", "CalSeeing");
1962 : }
1963 :
1964 0 : return outerScaleRMS;
1965 : }
1966 :
1967 : /**
1968 : * Set outerScaleRMS with the specified Angle.
1969 : * @param outerScaleRMS The Angle value to which outerScaleRMS is to be set.
1970 :
1971 :
1972 : */
1973 0 : void CalSeeingRow::setOuterScaleRMS (Angle outerScaleRMS) {
1974 :
1975 0 : this->outerScaleRMS = outerScaleRMS;
1976 :
1977 0 : outerScaleRMSExists = true;
1978 :
1979 0 : }
1980 :
1981 :
1982 : /**
1983 : * Mark outerScaleRMS, which is an optional field, as non-existent.
1984 : */
1985 0 : void CalSeeingRow::clearOuterScaleRMS () {
1986 0 : outerScaleRMSExists = false;
1987 0 : }
1988 :
1989 :
1990 :
1991 : ///////////////////////////////////////////////
1992 : // Extrinsic Table Attributes getters/setters//
1993 : ///////////////////////////////////////////////
1994 :
1995 :
1996 :
1997 :
1998 : /**
1999 : * Get calDataId.
2000 : * @return calDataId as Tag
2001 : */
2002 15 : Tag CalSeeingRow::getCalDataId() const {
2003 :
2004 15 : return calDataId;
2005 : }
2006 :
2007 : /**
2008 : * Set calDataId with the specified Tag.
2009 : * @param calDataId The Tag value to which calDataId is to be set.
2010 :
2011 :
2012 :
2013 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2014 :
2015 : */
2016 5 : void CalSeeingRow::setCalDataId (Tag calDataId) {
2017 :
2018 :
2019 5 : if (hasBeenAdded) {
2020 :
2021 0 : throw IllegalAccessException("calDataId", "CalSeeing");
2022 :
2023 : }
2024 :
2025 5 : this->calDataId = calDataId;
2026 :
2027 5 : }
2028 :
2029 :
2030 :
2031 :
2032 :
2033 :
2034 : /**
2035 : * Get calReductionId.
2036 : * @return calReductionId as Tag
2037 : */
2038 15 : Tag CalSeeingRow::getCalReductionId() const {
2039 :
2040 15 : return calReductionId;
2041 : }
2042 :
2043 : /**
2044 : * Set calReductionId with the specified Tag.
2045 : * @param calReductionId The Tag value to which calReductionId is to be set.
2046 :
2047 :
2048 :
2049 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2050 :
2051 : */
2052 5 : void CalSeeingRow::setCalReductionId (Tag calReductionId) {
2053 :
2054 :
2055 5 : if (hasBeenAdded) {
2056 :
2057 0 : throw IllegalAccessException("calReductionId", "CalSeeing");
2058 :
2059 : }
2060 :
2061 5 : this->calReductionId = calReductionId;
2062 :
2063 5 : }
2064 :
2065 :
2066 :
2067 :
2068 : //////////////////////////////////////
2069 : // Links Attributes getters/setters //
2070 : //////////////////////////////////////
2071 :
2072 :
2073 :
2074 :
2075 :
2076 :
2077 : /**
2078 : * Returns the pointer to the row in the CalData table having CalData.calDataId == calDataId
2079 : * @return a CalDataRow*
2080 : *
2081 :
2082 : */
2083 0 : CalDataRow* CalSeeingRow::getCalDataUsingCalDataId() {
2084 :
2085 0 : return table.getContainer().getCalData().getRowByKey(calDataId);
2086 : }
2087 :
2088 :
2089 :
2090 :
2091 :
2092 :
2093 :
2094 :
2095 :
2096 : /**
2097 : * Returns the pointer to the row in the CalReduction table having CalReduction.calReductionId == calReductionId
2098 : * @return a CalReductionRow*
2099 : *
2100 :
2101 : */
2102 0 : CalReductionRow* CalSeeingRow::getCalReductionUsingCalReductionId() {
2103 :
2104 0 : return table.getContainer().getCalReduction().getRowByKey(calReductionId);
2105 : }
2106 :
2107 :
2108 :
2109 :
2110 :
2111 : /**
2112 : * Create a CalSeeingRow.
2113 : * <p>
2114 : * This constructor is private because only the
2115 : * table can create rows. All rows know the table
2116 : * to which they belong.
2117 : * @param table The table to which this row belongs.
2118 : */
2119 10 : CalSeeingRow::CalSeeingRow (CalSeeingTable &t) : table(t) {
2120 10 : hasBeenAdded = false;
2121 :
2122 :
2123 :
2124 :
2125 :
2126 :
2127 :
2128 :
2129 :
2130 :
2131 :
2132 :
2133 :
2134 :
2135 :
2136 :
2137 :
2138 :
2139 :
2140 :
2141 :
2142 :
2143 :
2144 10 : exponentExists = false;
2145 :
2146 :
2147 :
2148 10 : outerScaleExists = false;
2149 :
2150 :
2151 :
2152 10 : outerScaleRMSExists = false;
2153 :
2154 :
2155 :
2156 :
2157 :
2158 :
2159 :
2160 :
2161 :
2162 :
2163 :
2164 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2165 10 : atmPhaseCorrection = CAtmPhaseCorrection::from_int(0);
2166 :
2167 :
2168 :
2169 :
2170 :
2171 :
2172 :
2173 :
2174 :
2175 :
2176 :
2177 :
2178 :
2179 :
2180 :
2181 :
2182 :
2183 :
2184 :
2185 :
2186 :
2187 :
2188 :
2189 :
2190 :
2191 :
2192 :
2193 :
2194 10 : fromBinMethods["atmPhaseCorrection"] = &CalSeeingRow::atmPhaseCorrectionFromBin;
2195 10 : fromBinMethods["calDataId"] = &CalSeeingRow::calDataIdFromBin;
2196 10 : fromBinMethods["calReductionId"] = &CalSeeingRow::calReductionIdFromBin;
2197 10 : fromBinMethods["startValidTime"] = &CalSeeingRow::startValidTimeFromBin;
2198 10 : fromBinMethods["endValidTime"] = &CalSeeingRow::endValidTimeFromBin;
2199 10 : fromBinMethods["frequencyRange"] = &CalSeeingRow::frequencyRangeFromBin;
2200 10 : fromBinMethods["integrationTime"] = &CalSeeingRow::integrationTimeFromBin;
2201 10 : fromBinMethods["numBaseLengths"] = &CalSeeingRow::numBaseLengthsFromBin;
2202 10 : fromBinMethods["baselineLengths"] = &CalSeeingRow::baselineLengthsFromBin;
2203 10 : fromBinMethods["phaseRMS"] = &CalSeeingRow::phaseRMSFromBin;
2204 10 : fromBinMethods["seeing"] = &CalSeeingRow::seeingFromBin;
2205 10 : fromBinMethods["seeingError"] = &CalSeeingRow::seeingErrorFromBin;
2206 :
2207 :
2208 10 : fromBinMethods["exponent"] = &CalSeeingRow::exponentFromBin;
2209 10 : fromBinMethods["outerScale"] = &CalSeeingRow::outerScaleFromBin;
2210 10 : fromBinMethods["outerScaleRMS"] = &CalSeeingRow::outerScaleRMSFromBin;
2211 :
2212 :
2213 :
2214 :
2215 :
2216 10 : fromTextMethods["atmPhaseCorrection"] = &CalSeeingRow::atmPhaseCorrectionFromText;
2217 :
2218 :
2219 :
2220 10 : fromTextMethods["calDataId"] = &CalSeeingRow::calDataIdFromText;
2221 :
2222 :
2223 :
2224 10 : fromTextMethods["calReductionId"] = &CalSeeingRow::calReductionIdFromText;
2225 :
2226 :
2227 :
2228 10 : fromTextMethods["startValidTime"] = &CalSeeingRow::startValidTimeFromText;
2229 :
2230 :
2231 :
2232 10 : fromTextMethods["endValidTime"] = &CalSeeingRow::endValidTimeFromText;
2233 :
2234 :
2235 :
2236 10 : fromTextMethods["frequencyRange"] = &CalSeeingRow::frequencyRangeFromText;
2237 :
2238 :
2239 :
2240 10 : fromTextMethods["integrationTime"] = &CalSeeingRow::integrationTimeFromText;
2241 :
2242 :
2243 :
2244 10 : fromTextMethods["numBaseLengths"] = &CalSeeingRow::numBaseLengthsFromText;
2245 :
2246 :
2247 :
2248 10 : fromTextMethods["baselineLengths"] = &CalSeeingRow::baselineLengthsFromText;
2249 :
2250 :
2251 :
2252 10 : fromTextMethods["phaseRMS"] = &CalSeeingRow::phaseRMSFromText;
2253 :
2254 :
2255 :
2256 10 : fromTextMethods["seeing"] = &CalSeeingRow::seeingFromText;
2257 :
2258 :
2259 :
2260 10 : fromTextMethods["seeingError"] = &CalSeeingRow::seeingErrorFromText;
2261 :
2262 :
2263 :
2264 :
2265 :
2266 10 : fromTextMethods["exponent"] = &CalSeeingRow::exponentFromText;
2267 :
2268 :
2269 :
2270 10 : fromTextMethods["outerScale"] = &CalSeeingRow::outerScaleFromText;
2271 :
2272 :
2273 :
2274 10 : fromTextMethods["outerScaleRMS"] = &CalSeeingRow::outerScaleRMSFromText;
2275 :
2276 :
2277 10 : }
2278 :
2279 0 : CalSeeingRow::CalSeeingRow (CalSeeingTable &t, CalSeeingRow *row) : table(t) {
2280 0 : hasBeenAdded = false;
2281 :
2282 0 : if (row == 0) {
2283 :
2284 :
2285 :
2286 :
2287 :
2288 :
2289 :
2290 :
2291 :
2292 :
2293 :
2294 :
2295 :
2296 :
2297 :
2298 :
2299 :
2300 :
2301 :
2302 :
2303 :
2304 :
2305 :
2306 0 : exponentExists = false;
2307 :
2308 :
2309 :
2310 0 : outerScaleExists = false;
2311 :
2312 :
2313 :
2314 0 : outerScaleRMSExists = false;
2315 :
2316 :
2317 :
2318 :
2319 :
2320 :
2321 :
2322 : }
2323 : else {
2324 :
2325 :
2326 0 : atmPhaseCorrection = row->atmPhaseCorrection;
2327 :
2328 0 : calDataId = row->calDataId;
2329 :
2330 0 : calReductionId = row->calReductionId;
2331 :
2332 :
2333 :
2334 :
2335 0 : startValidTime = row->startValidTime;
2336 :
2337 0 : endValidTime = row->endValidTime;
2338 :
2339 0 : frequencyRange = row->frequencyRange;
2340 :
2341 0 : integrationTime = row->integrationTime;
2342 :
2343 0 : numBaseLengths = row->numBaseLengths;
2344 :
2345 0 : baselineLengths = row->baselineLengths;
2346 :
2347 0 : phaseRMS = row->phaseRMS;
2348 :
2349 0 : seeing = row->seeing;
2350 :
2351 0 : seeingError = row->seeingError;
2352 :
2353 :
2354 :
2355 :
2356 0 : if (row->exponentExists) {
2357 0 : exponent = row->exponent;
2358 0 : exponentExists = true;
2359 : }
2360 : else
2361 0 : exponentExists = false;
2362 :
2363 0 : if (row->outerScaleExists) {
2364 0 : outerScale = row->outerScale;
2365 0 : outerScaleExists = true;
2366 : }
2367 : else
2368 0 : outerScaleExists = false;
2369 :
2370 0 : if (row->outerScaleRMSExists) {
2371 0 : outerScaleRMS = row->outerScaleRMS;
2372 0 : outerScaleRMSExists = true;
2373 : }
2374 : else
2375 0 : outerScaleRMSExists = false;
2376 :
2377 : }
2378 :
2379 0 : fromBinMethods["atmPhaseCorrection"] = &CalSeeingRow::atmPhaseCorrectionFromBin;
2380 0 : fromBinMethods["calDataId"] = &CalSeeingRow::calDataIdFromBin;
2381 0 : fromBinMethods["calReductionId"] = &CalSeeingRow::calReductionIdFromBin;
2382 0 : fromBinMethods["startValidTime"] = &CalSeeingRow::startValidTimeFromBin;
2383 0 : fromBinMethods["endValidTime"] = &CalSeeingRow::endValidTimeFromBin;
2384 0 : fromBinMethods["frequencyRange"] = &CalSeeingRow::frequencyRangeFromBin;
2385 0 : fromBinMethods["integrationTime"] = &CalSeeingRow::integrationTimeFromBin;
2386 0 : fromBinMethods["numBaseLengths"] = &CalSeeingRow::numBaseLengthsFromBin;
2387 0 : fromBinMethods["baselineLengths"] = &CalSeeingRow::baselineLengthsFromBin;
2388 0 : fromBinMethods["phaseRMS"] = &CalSeeingRow::phaseRMSFromBin;
2389 0 : fromBinMethods["seeing"] = &CalSeeingRow::seeingFromBin;
2390 0 : fromBinMethods["seeingError"] = &CalSeeingRow::seeingErrorFromBin;
2391 :
2392 :
2393 0 : fromBinMethods["exponent"] = &CalSeeingRow::exponentFromBin;
2394 0 : fromBinMethods["outerScale"] = &CalSeeingRow::outerScaleFromBin;
2395 0 : fromBinMethods["outerScaleRMS"] = &CalSeeingRow::outerScaleRMSFromBin;
2396 :
2397 0 : }
2398 :
2399 :
2400 0 : bool CalSeeingRow::compareNoAutoInc(AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, std::vector<Frequency > frequencyRange, Interval integrationTime, int numBaseLengths, std::vector<Length > baselineLengths, std::vector<Angle > phaseRMS, Angle seeing, Angle seeingError) {
2401 : bool result;
2402 0 : result = true;
2403 :
2404 :
2405 :
2406 0 : result = result && (this->atmPhaseCorrection == atmPhaseCorrection);
2407 :
2408 0 : if (!result) return false;
2409 :
2410 :
2411 :
2412 :
2413 0 : result = result && (this->calDataId == calDataId);
2414 :
2415 0 : if (!result) return false;
2416 :
2417 :
2418 :
2419 :
2420 0 : result = result && (this->calReductionId == calReductionId);
2421 :
2422 0 : if (!result) return false;
2423 :
2424 :
2425 :
2426 :
2427 0 : result = result && (this->startValidTime == startValidTime);
2428 :
2429 0 : if (!result) return false;
2430 :
2431 :
2432 :
2433 :
2434 0 : result = result && (this->endValidTime == endValidTime);
2435 :
2436 0 : if (!result) return false;
2437 :
2438 :
2439 :
2440 :
2441 0 : result = result && (this->frequencyRange == frequencyRange);
2442 :
2443 0 : if (!result) return false;
2444 :
2445 :
2446 :
2447 :
2448 0 : result = result && (this->integrationTime == integrationTime);
2449 :
2450 0 : if (!result) return false;
2451 :
2452 :
2453 :
2454 :
2455 0 : result = result && (this->numBaseLengths == numBaseLengths);
2456 :
2457 0 : if (!result) return false;
2458 :
2459 :
2460 :
2461 :
2462 0 : result = result && (this->baselineLengths == baselineLengths);
2463 :
2464 0 : if (!result) return false;
2465 :
2466 :
2467 :
2468 :
2469 0 : result = result && (this->phaseRMS == phaseRMS);
2470 :
2471 0 : if (!result) return false;
2472 :
2473 :
2474 :
2475 :
2476 0 : result = result && (this->seeing == seeing);
2477 :
2478 0 : if (!result) return false;
2479 :
2480 :
2481 :
2482 :
2483 0 : result = result && (this->seeingError == seeingError);
2484 :
2485 0 : if (!result) return false;
2486 :
2487 :
2488 0 : return result;
2489 : }
2490 :
2491 :
2492 :
2493 0 : bool CalSeeingRow::compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, std::vector<Frequency > frequencyRange, Interval integrationTime, int numBaseLengths, std::vector<Length > baselineLengths, std::vector<Angle > phaseRMS, Angle seeing, Angle seeingError) {
2494 : bool result;
2495 0 : result = true;
2496 :
2497 :
2498 0 : if (!(this->startValidTime == startValidTime)) return false;
2499 :
2500 :
2501 :
2502 0 : if (!(this->endValidTime == endValidTime)) return false;
2503 :
2504 :
2505 :
2506 0 : if (!(this->frequencyRange == frequencyRange)) return false;
2507 :
2508 :
2509 :
2510 0 : if (!(this->integrationTime == integrationTime)) return false;
2511 :
2512 :
2513 :
2514 0 : if (!(this->numBaseLengths == numBaseLengths)) return false;
2515 :
2516 :
2517 :
2518 0 : if (!(this->baselineLengths == baselineLengths)) return false;
2519 :
2520 :
2521 :
2522 0 : if (!(this->phaseRMS == phaseRMS)) return false;
2523 :
2524 :
2525 :
2526 0 : if (!(this->seeing == seeing)) return false;
2527 :
2528 :
2529 :
2530 0 : if (!(this->seeingError == seeingError)) return false;
2531 :
2532 :
2533 0 : return result;
2534 : }
2535 :
2536 :
2537 : /**
2538 : * Return true if all required attributes of the value part are equal to their homologues
2539 : * in x and false otherwise.
2540 : *
2541 :
2542 : * @param x a pointer on the CalSeeingRow whose required attributes of the value part
2543 :
2544 : * will be compared with those of this.
2545 : * @return a boolean.
2546 : */
2547 0 : bool CalSeeingRow::equalByRequiredValue(CalSeeingRow* x ) {
2548 :
2549 :
2550 0 : if (this->startValidTime != x->startValidTime) return false;
2551 :
2552 0 : if (this->endValidTime != x->endValidTime) return false;
2553 :
2554 0 : if (this->frequencyRange != x->frequencyRange) return false;
2555 :
2556 0 : if (this->integrationTime != x->integrationTime) return false;
2557 :
2558 0 : if (this->numBaseLengths != x->numBaseLengths) return false;
2559 :
2560 0 : if (this->baselineLengths != x->baselineLengths) return false;
2561 :
2562 0 : if (this->phaseRMS != x->phaseRMS) return false;
2563 :
2564 0 : if (this->seeing != x->seeing) return false;
2565 :
2566 0 : if (this->seeingError != x->seeingError) return false;
2567 :
2568 :
2569 0 : return true;
2570 : }
2571 :
2572 : /*
2573 : map<string, CalSeeingAttributeFromBin> CalSeeingRow::initFromBinMethods() {
2574 : map<string, CalSeeingAttributeFromBin> result;
2575 :
2576 : result["atmPhaseCorrection"] = &CalSeeingRow::atmPhaseCorrectionFromBin;
2577 : result["calDataId"] = &CalSeeingRow::calDataIdFromBin;
2578 : result["calReductionId"] = &CalSeeingRow::calReductionIdFromBin;
2579 : result["startValidTime"] = &CalSeeingRow::startValidTimeFromBin;
2580 : result["endValidTime"] = &CalSeeingRow::endValidTimeFromBin;
2581 : result["frequencyRange"] = &CalSeeingRow::frequencyRangeFromBin;
2582 : result["integrationTime"] = &CalSeeingRow::integrationTimeFromBin;
2583 : result["numBaseLengths"] = &CalSeeingRow::numBaseLengthsFromBin;
2584 : result["baselineLengths"] = &CalSeeingRow::baselineLengthsFromBin;
2585 : result["phaseRMS"] = &CalSeeingRow::phaseRMSFromBin;
2586 : result["seeing"] = &CalSeeingRow::seeingFromBin;
2587 : result["seeingError"] = &CalSeeingRow::seeingErrorFromBin;
2588 :
2589 :
2590 : result["exponent"] = &CalSeeingRow::exponentFromBin;
2591 : result["outerScale"] = &CalSeeingRow::outerScaleFromBin;
2592 : result["outerScaleRMS"] = &CalSeeingRow::outerScaleRMSFromBin;
2593 :
2594 :
2595 : return result;
2596 : }
2597 : */
2598 : } // End namespace asdm
2599 :
|
