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