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