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