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