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