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