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