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