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 WVMCalRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/WVMCalRow.h>
39 : #include <alma/ASDM/WVMCalTable.h>
40 :
41 : #include <alma/ASDM/SpectralWindowTable.h>
42 : #include <alma/ASDM/SpectralWindowRow.h>
43 :
44 : #include <alma/ASDM/AntennaTable.h>
45 : #include <alma/ASDM/AntennaRow.h>
46 :
47 : #include <alma/ASDM/AntennaTable.h>
48 : #include <alma/ASDM/AntennaRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::WVMCalRow;
53 : using asdm::WVMCalTable;
54 :
55 : using asdm::SpectralWindowTable;
56 : using asdm::SpectralWindowRow;
57 :
58 : using asdm::AntennaTable;
59 : using asdm::AntennaRow;
60 :
61 : using asdm::AntennaTable;
62 : using asdm::AntennaRow;
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 : WVMCalRow::~WVMCalRow() {
76 0 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 0 : WVMCalTable &WVMCalRow::getTable() const {
82 0 : return table;
83 : }
84 :
85 0 : bool WVMCalRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 0 : void WVMCalRow::isAdded(bool added) {
90 0 : hasBeenAdded = added;
91 0 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::WVMCalRowIDL;
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 WVMCalRowIDL struct.
101 : */
102 : WVMCalRowIDL *WVMCalRow::toIDL() const {
103 : WVMCalRowIDL *x = new WVMCalRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->timeInterval = timeInterval.toIDLArrayTimeInterval();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 : x->wvrMethod = wvrMethod;
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 : x->polyFreqLimits.length(polyFreqLimits.size());
136 : for (unsigned int i = 0; i < polyFreqLimits.size(); ++i) {
137 :
138 : x->polyFreqLimits[i] = polyFreqLimits.at(i).toIDLFrequency();
139 :
140 : }
141 :
142 :
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 : x->numInputAntenna = numInputAntenna;
152 :
153 :
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 : x->numChan = numChan;
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 : x->numPoly = numPoly;
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 : x->pathCoeff.length(pathCoeff.size());
187 : for (unsigned int i = 0; i < pathCoeff.size(); i++) {
188 : x->pathCoeff[i].length(pathCoeff.at(i).size());
189 : for (unsigned int j = 0; j < pathCoeff.at(i).size(); j++) {
190 : x->pathCoeff[i][j].length(pathCoeff.at(i).at(j).size());
191 : }
192 : }
193 :
194 : for (unsigned int i = 0; i < pathCoeff.size() ; i++)
195 : for (unsigned int j = 0; j < pathCoeff.at(i).size(); j++)
196 : for (unsigned int k = 0; k < pathCoeff.at(i).at(j).size(); k++)
197 :
198 :
199 : x->pathCoeff[i][j][k] = pathCoeff.at(i).at(j).at(k);
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 : x->refTemp.length(refTemp.size());
212 : for (unsigned int i = 0; i < refTemp.size(); i++) {
213 : x->refTemp[i].length(refTemp.at(i).size());
214 : }
215 :
216 : for (unsigned int i = 0; i < refTemp.size() ; i++)
217 : for (unsigned int j = 0; j < refTemp.at(i).size(); j++)
218 :
219 : x->refTemp[i][j]= refTemp.at(i).at(j).toIDLTemperature();
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 : x->antennaId = antennaId.toIDLTag();
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 : x->inputAntennaId.length(inputAntennaId.size());
246 : for (unsigned int i = 0; i < inputAntennaId.size(); ++i) {
247 :
248 : x->inputAntennaId[i] = inputAntennaId.at(i).toIDLTag();
249 :
250 : }
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 : x->spectralWindowId = spectralWindowId.toIDLTag();
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 :
274 : return x;
275 :
276 : }
277 :
278 : void WVMCalRow::toIDL(asdmIDL::WVMCalRowIDL& x) const {
279 : // Set the x's fields.
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 : x.timeInterval = timeInterval.toIDLArrayTimeInterval();
288 :
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 : x.wvrMethod = wvrMethod;
299 :
300 :
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 : x.polyFreqLimits.length(polyFreqLimits.size());
310 : for (unsigned int i = 0; i < polyFreqLimits.size(); ++i) {
311 :
312 : x.polyFreqLimits[i] = polyFreqLimits.at(i).toIDLFrequency();
313 :
314 : }
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 : x.numInputAntenna = numInputAntenna;
326 :
327 :
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 :
336 :
337 : x.numChan = numChan;
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 :
348 :
349 : x.numPoly = numPoly;
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 : x.pathCoeff.length(pathCoeff.size());
361 : for (unsigned int i = 0; i < pathCoeff.size(); i++) {
362 : x.pathCoeff[i].length(pathCoeff.at(i).size());
363 : for (unsigned int j = 0; j < pathCoeff.at(i).size(); j++) {
364 : x.pathCoeff[i][j].length(pathCoeff.at(i).at(j).size());
365 : }
366 : }
367 :
368 : for (unsigned int i = 0; i < pathCoeff.size() ; i++)
369 : for (unsigned int j = 0; j < pathCoeff.at(i).size(); j++)
370 : for (unsigned int k = 0; k < pathCoeff.at(i).at(j).size(); k++)
371 :
372 :
373 : x.pathCoeff[i][j][k] = pathCoeff.at(i).at(j).at(k);
374 :
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 :
385 : x.refTemp.length(refTemp.size());
386 : for (unsigned int i = 0; i < refTemp.size(); i++) {
387 : x.refTemp[i].length(refTemp.at(i).size());
388 : }
389 :
390 : for (unsigned int i = 0; i < refTemp.size() ; i++)
391 : for (unsigned int j = 0; j < refTemp.at(i).size(); j++)
392 :
393 : x.refTemp[i][j]= refTemp.at(i).at(j).toIDLTemperature();
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 : x.antennaId = antennaId.toIDLTag();
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 : x.inputAntennaId.length(inputAntennaId.size());
420 : for (unsigned int i = 0; i < inputAntennaId.size(); ++i) {
421 :
422 : x.inputAntennaId[i] = inputAntennaId.at(i).toIDLTag();
423 :
424 : }
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 :
433 :
434 : x.spectralWindowId = spectralWindowId.toIDLTag();
435 :
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 :
446 :
447 :
448 : }
449 : #endif
450 :
451 :
452 : #ifndef WITHOUT_ACS
453 : /**
454 : * Fill the values of this row from the IDL struct WVMCalRowIDL.
455 : * @param x The IDL struct containing the values used to fill this row.
456 : */
457 : void WVMCalRow::setFromIDL (WVMCalRowIDL x){
458 : try {
459 : // Fill the values from x.
460 :
461 :
462 :
463 :
464 :
465 :
466 : setTimeInterval(ArrayTimeInterval (x.timeInterval));
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 : setWvrMethod(x.wvrMethod);
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 : polyFreqLimits .clear();
487 : for (unsigned int i = 0; i <x.polyFreqLimits.length(); ++i) {
488 :
489 : polyFreqLimits.push_back(Frequency (x.polyFreqLimits[i]));
490 :
491 : }
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 : setNumInputAntenna(x.numInputAntenna);
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 : setNumChan(x.numChan);
512 :
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 : setNumPoly(x.numPoly);
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 : pathCoeff .clear();
532 : vector< vector<float> > vv_aux_pathCoeff;
533 : vector<float> v_aux_pathCoeff;
534 :
535 : for (unsigned int i = 0; i < x.pathCoeff.length(); ++i) {
536 : vv_aux_pathCoeff.clear();
537 : for (unsigned int j = 0; j < x.pathCoeff[0].length(); ++j) {
538 : v_aux_pathCoeff.clear();
539 : for (unsigned int k = 0; k < x.pathCoeff[0][0].length(); ++k) {
540 :
541 : v_aux_pathCoeff.push_back(x.pathCoeff[i][j][k]);
542 :
543 : }
544 : vv_aux_pathCoeff.push_back(v_aux_pathCoeff);
545 : }
546 : pathCoeff.push_back(vv_aux_pathCoeff);
547 : }
548 :
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 : refTemp .clear();
558 :
559 : vector<Temperature> v_aux_refTemp;
560 :
561 : for (unsigned int i = 0; i < x.refTemp.length(); ++i) {
562 : v_aux_refTemp.clear();
563 : for (unsigned int j = 0; j < x.refTemp[0].length(); ++j) {
564 :
565 : v_aux_refTemp.push_back(Temperature (x.refTemp[i][j]));
566 :
567 : }
568 : refTemp.push_back(v_aux_refTemp);
569 : }
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 :
581 :
582 : setAntennaId(Tag (x.antennaId));
583 :
584 :
585 :
586 :
587 :
588 :
589 :
590 : inputAntennaId .clear();
591 : for (unsigned int i = 0; i <x.inputAntennaId.length(); ++i) {
592 :
593 : inputAntennaId.push_back(Tag (x.inputAntennaId[i]));
594 :
595 : }
596 :
597 :
598 :
599 :
600 :
601 :
602 :
603 : setSpectralWindowId(Tag (x.spectralWindowId));
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 : } catch (const IllegalAccessException &err) {
618 : throw ConversionException (err.getMessage(),"WVMCal");
619 : }
620 : }
621 : #endif
622 :
623 : /**
624 : * Return this row in the form of an XML string.
625 : * @return The values of this row as an XML string.
626 : */
627 0 : string WVMCalRow::toXML() const {
628 0 : string buf;
629 0 : buf.append("<row> \n");
630 :
631 :
632 :
633 :
634 :
635 :
636 0 : Parser::toXML(timeInterval, "timeInterval", buf);
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 0 : buf.append(EnumerationParser::toXML("wvrMethod", wvrMethod));
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 0 : Parser::toXML(polyFreqLimits, "polyFreqLimits", buf);
653 :
654 :
655 :
656 :
657 :
658 :
659 :
660 0 : Parser::toXML(numInputAntenna, "numInputAntenna", buf);
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 0 : Parser::toXML(numChan, "numChan", buf);
669 :
670 :
671 :
672 :
673 :
674 :
675 :
676 0 : Parser::toXML(numPoly, "numPoly", buf);
677 :
678 :
679 :
680 :
681 :
682 :
683 :
684 0 : Parser::toXML(pathCoeff, "pathCoeff", buf);
685 :
686 :
687 :
688 :
689 :
690 :
691 :
692 0 : Parser::toXML(refTemp, "refTemp", buf);
693 :
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 :
703 0 : Parser::toXML(antennaId, "antennaId", buf);
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 0 : Parser::toXML(inputAntennaId, "inputAntennaId", buf);
712 :
713 :
714 :
715 :
716 :
717 :
718 :
719 0 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
720 :
721 :
722 :
723 :
724 :
725 :
726 :
727 :
728 :
729 :
730 :
731 :
732 :
733 0 : buf.append("</row>\n");
734 0 : return buf;
735 0 : }
736 :
737 : /**
738 : * Fill the values of this row from an XML string
739 : * that was produced by the toXML() method.
740 : * @param x The XML string being used to set the values of this row.
741 : */
742 0 : void WVMCalRow::setFromXML (string rowDoc) {
743 0 : Parser row(rowDoc);
744 0 : string s = "";
745 : try {
746 :
747 :
748 :
749 :
750 :
751 0 : setTimeInterval(Parser::getArrayTimeInterval("timeInterval","WVMCal",rowDoc));
752 :
753 :
754 :
755 :
756 :
757 :
758 :
759 :
760 0 : wvrMethod = EnumerationParser::getWVRMethod("wvrMethod","WVMCal",rowDoc);
761 :
762 :
763 :
764 :
765 :
766 :
767 :
768 :
769 :
770 0 : setPolyFreqLimits(Parser::get1DFrequency("polyFreqLimits","WVMCal",rowDoc));
771 :
772 :
773 :
774 :
775 :
776 :
777 :
778 :
779 0 : setNumInputAntenna(Parser::getInteger("numInputAntenna","WVMCal",rowDoc));
780 :
781 :
782 :
783 :
784 :
785 :
786 :
787 0 : setNumChan(Parser::getInteger("numChan","WVMCal",rowDoc));
788 :
789 :
790 :
791 :
792 :
793 :
794 :
795 0 : setNumPoly(Parser::getInteger("numPoly","WVMCal",rowDoc));
796 :
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 0 : setPathCoeff(Parser::get3DFloat("pathCoeff","WVMCal",rowDoc));
805 :
806 :
807 :
808 :
809 :
810 :
811 :
812 :
813 :
814 0 : setRefTemp(Parser::get2DTemperature("refTemp","WVMCal",rowDoc));
815 :
816 :
817 :
818 :
819 :
820 :
821 :
822 :
823 :
824 :
825 :
826 0 : setAntennaId(Parser::getTag("antennaId","Antenna",rowDoc));
827 :
828 :
829 :
830 :
831 :
832 :
833 0 : setInputAntennaId(Parser::get1DTag("inputAntennaId","WVMCal",rowDoc));
834 :
835 :
836 :
837 :
838 :
839 :
840 0 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
841 :
842 :
843 :
844 :
845 :
846 :
847 :
848 :
849 :
850 :
851 :
852 :
853 0 : } catch (const IllegalAccessException &err) {
854 0 : throw ConversionException (err.getMessage(),"WVMCal");
855 0 : }
856 0 : }
857 :
858 0 : void WVMCalRow::toBin(EndianOSStream& eoss) {
859 :
860 :
861 :
862 :
863 :
864 0 : antennaId.toBin(eoss);
865 :
866 :
867 :
868 :
869 :
870 :
871 0 : spectralWindowId.toBin(eoss);
872 :
873 :
874 :
875 :
876 :
877 :
878 0 : timeInterval.toBin(eoss);
879 :
880 :
881 :
882 :
883 :
884 :
885 :
886 0 : eoss.writeString(CWVRMethod::name(wvrMethod));
887 : /* eoss.writeInt(wvrMethod); */
888 :
889 :
890 :
891 :
892 :
893 :
894 :
895 0 : Frequency::toBin(polyFreqLimits, eoss);
896 :
897 :
898 :
899 :
900 :
901 :
902 :
903 0 : eoss.writeInt(numInputAntenna);
904 :
905 :
906 :
907 :
908 :
909 :
910 :
911 :
912 0 : eoss.writeInt(numChan);
913 :
914 :
915 :
916 :
917 :
918 :
919 :
920 :
921 0 : eoss.writeInt(numPoly);
922 :
923 :
924 :
925 :
926 :
927 :
928 :
929 :
930 :
931 0 : eoss.writeInt((int) pathCoeff.size());
932 0 : eoss.writeInt((int) pathCoeff.at(0).size());
933 0 : eoss.writeInt((int) pathCoeff.at(0).at(0).size());
934 0 : for (unsigned int i = 0; i < pathCoeff.size(); i++)
935 0 : for (unsigned int j = 0; j < pathCoeff.at(0).size(); j++)
936 0 : for (unsigned int k = 0; k < pathCoeff.at(0).at(0).size(); k++)
937 :
938 0 : eoss.writeFloat(pathCoeff.at(i).at(j).at(k));
939 :
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 0 : Temperature::toBin(refTemp, eoss);
948 :
949 :
950 :
951 :
952 :
953 :
954 0 : Tag::toBin(inputAntennaId, eoss);
955 :
956 :
957 :
958 :
959 :
960 :
961 0 : }
962 :
963 0 : void WVMCalRow::antennaIdFromBin(EndianIStream& eis) {
964 :
965 :
966 :
967 :
968 0 : antennaId = Tag::fromBin(eis);
969 :
970 :
971 :
972 0 : }
973 0 : void WVMCalRow::spectralWindowIdFromBin(EndianIStream& eis) {
974 :
975 :
976 :
977 :
978 0 : spectralWindowId = Tag::fromBin(eis);
979 :
980 :
981 :
982 0 : }
983 0 : void WVMCalRow::timeIntervalFromBin(EndianIStream& eis) {
984 :
985 :
986 :
987 :
988 0 : timeInterval = ArrayTimeInterval::fromBin(eis);
989 :
990 :
991 :
992 0 : }
993 0 : void WVMCalRow::wvrMethodFromBin(EndianIStream& eis) {
994 :
995 :
996 :
997 :
998 :
999 0 : wvrMethod = CWVRMethod::literal(eis.readString());
1000 :
1001 :
1002 :
1003 :
1004 0 : }
1005 0 : void WVMCalRow::polyFreqLimitsFromBin(EndianIStream& eis) {
1006 :
1007 :
1008 :
1009 :
1010 :
1011 :
1012 0 : polyFreqLimits = Frequency::from1DBin(eis);
1013 :
1014 :
1015 :
1016 :
1017 :
1018 0 : }
1019 0 : void WVMCalRow::numInputAntennaFromBin(EndianIStream& eis) {
1020 :
1021 :
1022 :
1023 :
1024 :
1025 0 : numInputAntenna = eis.readInt();
1026 :
1027 :
1028 :
1029 :
1030 0 : }
1031 0 : void WVMCalRow::numChanFromBin(EndianIStream& eis) {
1032 :
1033 :
1034 :
1035 :
1036 :
1037 0 : numChan = eis.readInt();
1038 :
1039 :
1040 :
1041 :
1042 0 : }
1043 0 : void WVMCalRow::numPolyFromBin(EndianIStream& eis) {
1044 :
1045 :
1046 :
1047 :
1048 :
1049 0 : numPoly = eis.readInt();
1050 :
1051 :
1052 :
1053 :
1054 0 : }
1055 0 : void WVMCalRow::pathCoeffFromBin(EndianIStream& eis) {
1056 :
1057 :
1058 :
1059 :
1060 :
1061 :
1062 0 : pathCoeff.clear();
1063 :
1064 0 : unsigned int pathCoeffDim1 = eis.readInt();
1065 0 : unsigned int pathCoeffDim2 = eis.readInt();
1066 0 : unsigned int pathCoeffDim3 = eis.readInt();
1067 0 : vector <vector<float> > pathCoeffAux2;
1068 0 : vector <float> pathCoeffAux1;
1069 0 : for (unsigned int i = 0; i < pathCoeffDim1; i++) {
1070 0 : pathCoeffAux2.clear();
1071 0 : for (unsigned int j = 0; j < pathCoeffDim2 ; j++) {
1072 0 : pathCoeffAux1.clear();
1073 0 : for (unsigned int k = 0; k < pathCoeffDim3; k++) {
1074 :
1075 0 : pathCoeffAux1.push_back(eis.readFloat());
1076 :
1077 : }
1078 0 : pathCoeffAux2.push_back(pathCoeffAux1);
1079 : }
1080 0 : pathCoeff.push_back(pathCoeffAux2);
1081 : }
1082 :
1083 :
1084 :
1085 :
1086 :
1087 0 : }
1088 0 : void WVMCalRow::refTempFromBin(EndianIStream& eis) {
1089 :
1090 :
1091 :
1092 :
1093 :
1094 :
1095 0 : refTemp = Temperature::from2DBin(eis);
1096 :
1097 :
1098 :
1099 :
1100 :
1101 0 : }
1102 0 : void WVMCalRow::inputAntennaIdFromBin(EndianIStream& eis) {
1103 :
1104 :
1105 :
1106 :
1107 :
1108 :
1109 0 : inputAntennaId = Tag::from1DBin(eis);
1110 :
1111 :
1112 :
1113 :
1114 :
1115 0 : }
1116 :
1117 :
1118 :
1119 0 : WVMCalRow* WVMCalRow::fromBin(EndianIStream& eis, WVMCalTable& table, const vector<string>& attributesSeq) {
1120 0 : WVMCalRow* row = new WVMCalRow(table);
1121 :
1122 0 : map<string, WVMCalAttributeFromBin>::iterator iter ;
1123 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1124 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1125 0 : if (iter != row->fromBinMethods.end()) {
1126 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1127 : }
1128 : else {
1129 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1130 0 : if (functorP)
1131 0 : (*functorP)(eis);
1132 : else
1133 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "WVMCalTable");
1134 : }
1135 :
1136 : }
1137 0 : return row;
1138 : }
1139 :
1140 : //
1141 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1142 : // of one row.
1143 : //
1144 :
1145 : // Convert a string into an Tag
1146 0 : void WVMCalRow::antennaIdFromText(const string & s) {
1147 :
1148 :
1149 0 : antennaId = ASDMValuesParser::parse<Tag>(s);
1150 :
1151 :
1152 0 : }
1153 :
1154 :
1155 : // Convert a string into an Tag
1156 0 : void WVMCalRow::spectralWindowIdFromText(const string & s) {
1157 :
1158 :
1159 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
1160 :
1161 :
1162 0 : }
1163 :
1164 :
1165 : // Convert a string into an ArrayTimeInterval
1166 0 : void WVMCalRow::timeIntervalFromText(const string & s) {
1167 :
1168 :
1169 0 : timeInterval = ASDMValuesParser::parse<ArrayTimeInterval>(s);
1170 :
1171 :
1172 0 : }
1173 :
1174 :
1175 : // Convert a string into an WVRMethod
1176 0 : void WVMCalRow::wvrMethodFromText(const string & s) {
1177 :
1178 :
1179 0 : wvrMethod = ASDMValuesParser::parse<WVRMethodMod::WVRMethod>(s);
1180 :
1181 :
1182 0 : }
1183 :
1184 :
1185 : // Convert a string into an Frequency
1186 0 : void WVMCalRow::polyFreqLimitsFromText(const string & s) {
1187 :
1188 :
1189 0 : polyFreqLimits = ASDMValuesParser::parse1D<Frequency>(s);
1190 :
1191 :
1192 0 : }
1193 :
1194 :
1195 : // Convert a string into an int
1196 0 : void WVMCalRow::numInputAntennaFromText(const string & s) {
1197 :
1198 :
1199 0 : numInputAntenna = ASDMValuesParser::parse<int>(s);
1200 :
1201 :
1202 0 : }
1203 :
1204 :
1205 : // Convert a string into an int
1206 0 : void WVMCalRow::numChanFromText(const string & s) {
1207 :
1208 :
1209 0 : numChan = ASDMValuesParser::parse<int>(s);
1210 :
1211 :
1212 0 : }
1213 :
1214 :
1215 : // Convert a string into an int
1216 0 : void WVMCalRow::numPolyFromText(const string & s) {
1217 :
1218 :
1219 0 : numPoly = ASDMValuesParser::parse<int>(s);
1220 :
1221 :
1222 0 : }
1223 :
1224 :
1225 : // Convert a string into an float
1226 0 : void WVMCalRow::pathCoeffFromText(const string & s) {
1227 :
1228 :
1229 0 : pathCoeff = ASDMValuesParser::parse3D<float>(s);
1230 :
1231 :
1232 0 : }
1233 :
1234 :
1235 : // Convert a string into an Temperature
1236 0 : void WVMCalRow::refTempFromText(const string & s) {
1237 :
1238 :
1239 0 : refTemp = ASDMValuesParser::parse2D<Temperature>(s);
1240 :
1241 :
1242 0 : }
1243 :
1244 :
1245 : // Convert a string into an Tag
1246 0 : void WVMCalRow::inputAntennaIdFromText(const string & s) {
1247 :
1248 :
1249 0 : inputAntennaId = ASDMValuesParser::parse1D<Tag>(s);
1250 :
1251 :
1252 0 : }
1253 :
1254 :
1255 :
1256 :
1257 0 : void WVMCalRow::fromText(const std::string& attributeName, const std::string& t) {
1258 0 : map<string, WVMCalAttributeFromText>::iterator iter;
1259 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1260 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "WVMCalTable");
1261 0 : (this->*(iter->second))(t);
1262 0 : }
1263 :
1264 : ////////////////////////////////////////////////
1265 : // Intrinsic Table Attributes getters/setters //
1266 : ////////////////////////////////////////////////
1267 :
1268 :
1269 :
1270 :
1271 : /**
1272 : * Get timeInterval.
1273 : * @return timeInterval as ArrayTimeInterval
1274 : */
1275 0 : ArrayTimeInterval WVMCalRow::getTimeInterval() const {
1276 :
1277 0 : return timeInterval;
1278 : }
1279 :
1280 : /**
1281 : * Set timeInterval with the specified ArrayTimeInterval.
1282 : * @param timeInterval The ArrayTimeInterval value to which timeInterval is to be set.
1283 :
1284 :
1285 :
1286 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1287 :
1288 : */
1289 0 : void WVMCalRow::setTimeInterval (ArrayTimeInterval timeInterval) {
1290 :
1291 :
1292 0 : if (hasBeenAdded) {
1293 :
1294 0 : throw IllegalAccessException("timeInterval", "WVMCal");
1295 :
1296 : }
1297 :
1298 0 : this->timeInterval = timeInterval;
1299 :
1300 0 : }
1301 :
1302 :
1303 :
1304 :
1305 :
1306 :
1307 : /**
1308 : * Get wvrMethod.
1309 : * @return wvrMethod as WVRMethodMod::WVRMethod
1310 : */
1311 0 : WVRMethodMod::WVRMethod WVMCalRow::getWvrMethod() const {
1312 :
1313 0 : return wvrMethod;
1314 : }
1315 :
1316 : /**
1317 : * Set wvrMethod with the specified WVRMethodMod::WVRMethod.
1318 : * @param wvrMethod The WVRMethodMod::WVRMethod value to which wvrMethod is to be set.
1319 :
1320 :
1321 :
1322 : */
1323 0 : void WVMCalRow::setWvrMethod (WVRMethodMod::WVRMethod wvrMethod) {
1324 :
1325 :
1326 0 : if (hasBeenAdded) {
1327 :
1328 : }
1329 :
1330 0 : this->wvrMethod = wvrMethod;
1331 :
1332 0 : }
1333 :
1334 :
1335 :
1336 :
1337 :
1338 :
1339 : /**
1340 : * Get polyFreqLimits.
1341 : * @return polyFreqLimits as std::vector<Frequency >
1342 : */
1343 0 : std::vector<Frequency > WVMCalRow::getPolyFreqLimits() const {
1344 :
1345 0 : return polyFreqLimits;
1346 : }
1347 :
1348 : /**
1349 : * Set polyFreqLimits with the specified std::vector<Frequency >.
1350 : * @param polyFreqLimits The std::vector<Frequency > value to which polyFreqLimits is to be set.
1351 :
1352 :
1353 :
1354 : */
1355 0 : void WVMCalRow::setPolyFreqLimits (std::vector<Frequency > polyFreqLimits) {
1356 :
1357 :
1358 0 : if (hasBeenAdded) {
1359 :
1360 : }
1361 :
1362 0 : this->polyFreqLimits = polyFreqLimits;
1363 :
1364 0 : }
1365 :
1366 :
1367 :
1368 :
1369 :
1370 :
1371 : /**
1372 : * Get numInputAntenna.
1373 : * @return numInputAntenna as int
1374 : */
1375 0 : int WVMCalRow::getNumInputAntenna() const {
1376 :
1377 0 : return numInputAntenna;
1378 : }
1379 :
1380 : /**
1381 : * Set numInputAntenna with the specified int.
1382 : * @param numInputAntenna The int value to which numInputAntenna is to be set.
1383 :
1384 :
1385 :
1386 : */
1387 0 : void WVMCalRow::setNumInputAntenna (int numInputAntenna) {
1388 :
1389 :
1390 0 : if (hasBeenAdded) {
1391 :
1392 : }
1393 :
1394 0 : this->numInputAntenna = numInputAntenna;
1395 :
1396 0 : }
1397 :
1398 :
1399 :
1400 :
1401 :
1402 :
1403 : /**
1404 : * Get numChan.
1405 : * @return numChan as int
1406 : */
1407 0 : int WVMCalRow::getNumChan() const {
1408 :
1409 0 : return numChan;
1410 : }
1411 :
1412 : /**
1413 : * Set numChan with the specified int.
1414 : * @param numChan The int value to which numChan is to be set.
1415 :
1416 :
1417 :
1418 : */
1419 0 : void WVMCalRow::setNumChan (int numChan) {
1420 :
1421 :
1422 0 : if (hasBeenAdded) {
1423 :
1424 : }
1425 :
1426 0 : this->numChan = numChan;
1427 :
1428 0 : }
1429 :
1430 :
1431 :
1432 :
1433 :
1434 :
1435 : /**
1436 : * Get numPoly.
1437 : * @return numPoly as int
1438 : */
1439 0 : int WVMCalRow::getNumPoly() const {
1440 :
1441 0 : return numPoly;
1442 : }
1443 :
1444 : /**
1445 : * Set numPoly with the specified int.
1446 : * @param numPoly The int value to which numPoly is to be set.
1447 :
1448 :
1449 :
1450 : */
1451 0 : void WVMCalRow::setNumPoly (int numPoly) {
1452 :
1453 :
1454 0 : if (hasBeenAdded) {
1455 :
1456 : }
1457 :
1458 0 : this->numPoly = numPoly;
1459 :
1460 0 : }
1461 :
1462 :
1463 :
1464 :
1465 :
1466 :
1467 : /**
1468 : * Get pathCoeff.
1469 : * @return pathCoeff as std::vector<std::vector<std::vector<float > > >
1470 : */
1471 0 : std::vector<std::vector<std::vector<float > > > WVMCalRow::getPathCoeff() const {
1472 :
1473 0 : return pathCoeff;
1474 : }
1475 :
1476 : /**
1477 : * Set pathCoeff with the specified std::vector<std::vector<std::vector<float > > >.
1478 : * @param pathCoeff The std::vector<std::vector<std::vector<float > > > value to which pathCoeff is to be set.
1479 :
1480 :
1481 :
1482 : */
1483 0 : void WVMCalRow::setPathCoeff (std::vector<std::vector<std::vector<float > > > pathCoeff) {
1484 :
1485 :
1486 0 : if (hasBeenAdded) {
1487 :
1488 : }
1489 :
1490 0 : this->pathCoeff = pathCoeff;
1491 :
1492 0 : }
1493 :
1494 :
1495 :
1496 :
1497 :
1498 :
1499 : /**
1500 : * Get refTemp.
1501 : * @return refTemp as std::vector<std::vector<Temperature > >
1502 : */
1503 0 : std::vector<std::vector<Temperature > > WVMCalRow::getRefTemp() const {
1504 :
1505 0 : return refTemp;
1506 : }
1507 :
1508 : /**
1509 : * Set refTemp with the specified std::vector<std::vector<Temperature > >.
1510 : * @param refTemp The std::vector<std::vector<Temperature > > value to which refTemp is to be set.
1511 :
1512 :
1513 :
1514 : */
1515 0 : void WVMCalRow::setRefTemp (std::vector<std::vector<Temperature > > refTemp) {
1516 :
1517 :
1518 0 : if (hasBeenAdded) {
1519 :
1520 : }
1521 :
1522 0 : this->refTemp = refTemp;
1523 :
1524 0 : }
1525 :
1526 :
1527 :
1528 :
1529 : ///////////////////////////////////////////////
1530 : // Extrinsic Table Attributes getters/setters//
1531 : ///////////////////////////////////////////////
1532 :
1533 :
1534 :
1535 :
1536 : /**
1537 : * Get antennaId.
1538 : * @return antennaId as Tag
1539 : */
1540 0 : Tag WVMCalRow::getAntennaId() const {
1541 :
1542 0 : return antennaId;
1543 : }
1544 :
1545 : /**
1546 : * Set antennaId with the specified Tag.
1547 : * @param antennaId The Tag value to which antennaId is to be set.
1548 :
1549 :
1550 :
1551 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1552 :
1553 : */
1554 0 : void WVMCalRow::setAntennaId (Tag antennaId) {
1555 :
1556 :
1557 0 : if (hasBeenAdded) {
1558 :
1559 0 : throw IllegalAccessException("antennaId", "WVMCal");
1560 :
1561 : }
1562 :
1563 0 : this->antennaId = antennaId;
1564 :
1565 0 : }
1566 :
1567 :
1568 :
1569 :
1570 :
1571 :
1572 : /**
1573 : * Get inputAntennaId.
1574 : * @return inputAntennaId as std::vector<Tag>
1575 : */
1576 0 : std::vector<Tag> WVMCalRow::getInputAntennaId() const {
1577 :
1578 0 : return inputAntennaId;
1579 : }
1580 :
1581 : /**
1582 : * Set inputAntennaId with the specified std::vector<Tag> .
1583 : * @param inputAntennaId The std::vector<Tag> value to which inputAntennaId is to be set.
1584 :
1585 :
1586 :
1587 : */
1588 0 : void WVMCalRow::setInputAntennaId (std::vector<Tag> inputAntennaId) {
1589 :
1590 :
1591 0 : if (hasBeenAdded) {
1592 :
1593 : }
1594 :
1595 0 : this->inputAntennaId = inputAntennaId;
1596 :
1597 0 : }
1598 :
1599 :
1600 :
1601 :
1602 :
1603 :
1604 : /**
1605 : * Get spectralWindowId.
1606 : * @return spectralWindowId as Tag
1607 : */
1608 0 : Tag WVMCalRow::getSpectralWindowId() const {
1609 :
1610 0 : return spectralWindowId;
1611 : }
1612 :
1613 : /**
1614 : * Set spectralWindowId with the specified Tag.
1615 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
1616 :
1617 :
1618 :
1619 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1620 :
1621 : */
1622 0 : void WVMCalRow::setSpectralWindowId (Tag spectralWindowId) {
1623 :
1624 :
1625 0 : if (hasBeenAdded) {
1626 :
1627 0 : throw IllegalAccessException("spectralWindowId", "WVMCal");
1628 :
1629 : }
1630 :
1631 0 : this->spectralWindowId = spectralWindowId;
1632 :
1633 0 : }
1634 :
1635 :
1636 :
1637 :
1638 : //////////////////////////////////////
1639 : // Links Attributes getters/setters //
1640 : //////////////////////////////////////
1641 :
1642 :
1643 :
1644 :
1645 :
1646 :
1647 : /**
1648 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.spectralWindowId == spectralWindowId
1649 : * @return a SpectralWindowRow*
1650 : *
1651 :
1652 : */
1653 0 : SpectralWindowRow* WVMCalRow::getSpectralWindowUsingSpectralWindowId() {
1654 :
1655 0 : return table.getContainer().getSpectralWindow().getRowByKey(spectralWindowId);
1656 : }
1657 :
1658 :
1659 :
1660 :
1661 :
1662 :
1663 :
1664 :
1665 :
1666 : /**
1667 : * Returns the pointer to the row in the Antenna table having Antenna.antennaId == antennaId
1668 : * @return a AntennaRow*
1669 : *
1670 :
1671 : */
1672 0 : AntennaRow* WVMCalRow::getAntennaUsingAntennaId() {
1673 :
1674 0 : return table.getContainer().getAntenna().getRowByKey(antennaId);
1675 : }
1676 :
1677 :
1678 :
1679 :
1680 :
1681 :
1682 : /**
1683 : * Set inputAntennaId[i] with the specified Tag.
1684 : * @param i The index in inputAntennaId where to set the Tag value.
1685 : * @param inputAntennaId The Tag value to which inputAntennaId[i] is to be set.
1686 :
1687 : * @throws IndexOutOfBoundsException
1688 : */
1689 0 : void WVMCalRow::setInputAntennaId (int i, Tag inputAntennaId) {
1690 0 : if (hasBeenAdded) {
1691 :
1692 : }
1693 0 : if ((i < 0) || (i > ((int) this->inputAntennaId.size())))
1694 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute inputAntennaId in table WVMCalTable");
1695 0 : std::vector<Tag> ::iterator iter = this->inputAntennaId.begin();
1696 0 : int j = 0;
1697 0 : while (j < i) {
1698 0 : j++; iter++;
1699 : }
1700 0 : this->inputAntennaId.insert(this->inputAntennaId.erase(iter), inputAntennaId);
1701 0 : }
1702 :
1703 :
1704 :
1705 :
1706 :
1707 : /**
1708 : * Append a Tag to inputAntennaId.
1709 : * @param id the Tag to be appended to inputAntennaId
1710 : */
1711 0 : void WVMCalRow::addInputAntennaId(Tag id){
1712 0 : inputAntennaId.push_back(id);
1713 0 : }
1714 :
1715 : /**
1716 : * Append an array of Tag to inputAntennaId.
1717 : * @param id an array of Tag to be appended to inputAntennaId
1718 : */
1719 0 : void WVMCalRow::addInputAntennaId(const std::vector<Tag> & id) {
1720 0 : for (unsigned int i=0; i < id.size(); i++)
1721 0 : inputAntennaId.push_back(id.at(i));
1722 0 : }
1723 :
1724 :
1725 : /**
1726 : * Returns the Tag stored in inputAntennaId at position i.
1727 : *
1728 : */
1729 0 : const Tag WVMCalRow::getInputAntennaId(int i) {
1730 0 : return inputAntennaId.at(i);
1731 : }
1732 :
1733 : /**
1734 : * Returns the AntennaRow linked to this row via the Tag stored in inputAntennaId
1735 : * at position i.
1736 : */
1737 0 : AntennaRow* WVMCalRow::getAntennaUsingInputAntennaId(int i) {
1738 0 : return table.getContainer().getAntenna().getRowByKey(inputAntennaId.at(i));
1739 : }
1740 :
1741 : /**
1742 : * Returns the vector of AntennaRow* linked to this row via the Tags stored in inputAntennaId
1743 : *
1744 : */
1745 0 : vector<AntennaRow *> WVMCalRow::getAntennasUsingInputAntennaId() {
1746 0 : vector<AntennaRow *> result;
1747 0 : for (unsigned int i = 0; i < inputAntennaId.size(); i++)
1748 0 : result.push_back(table.getContainer().getAntenna().getRowByKey(inputAntennaId.at(i)));
1749 :
1750 0 : return result;
1751 0 : }
1752 :
1753 :
1754 :
1755 :
1756 :
1757 : /**
1758 : * Create a WVMCalRow.
1759 : * <p>
1760 : * This constructor is private because only the
1761 : * table can create rows. All rows know the table
1762 : * to which they belong.
1763 : * @param table The table to which this row belongs.
1764 : */
1765 0 : WVMCalRow::WVMCalRow (WVMCalTable &t) : table(t) {
1766 0 : hasBeenAdded = false;
1767 :
1768 :
1769 :
1770 :
1771 :
1772 :
1773 :
1774 :
1775 :
1776 :
1777 :
1778 :
1779 :
1780 :
1781 :
1782 :
1783 :
1784 :
1785 :
1786 :
1787 :
1788 :
1789 :
1790 :
1791 :
1792 :
1793 :
1794 :
1795 :
1796 :
1797 :
1798 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
1799 0 : wvrMethod = CWVRMethod::from_int(0);
1800 :
1801 :
1802 :
1803 :
1804 :
1805 :
1806 :
1807 :
1808 :
1809 :
1810 :
1811 :
1812 :
1813 :
1814 :
1815 :
1816 0 : fromBinMethods["antennaId"] = &WVMCalRow::antennaIdFromBin;
1817 0 : fromBinMethods["spectralWindowId"] = &WVMCalRow::spectralWindowIdFromBin;
1818 0 : fromBinMethods["timeInterval"] = &WVMCalRow::timeIntervalFromBin;
1819 0 : fromBinMethods["wvrMethod"] = &WVMCalRow::wvrMethodFromBin;
1820 0 : fromBinMethods["polyFreqLimits"] = &WVMCalRow::polyFreqLimitsFromBin;
1821 0 : fromBinMethods["numInputAntenna"] = &WVMCalRow::numInputAntennaFromBin;
1822 0 : fromBinMethods["numChan"] = &WVMCalRow::numChanFromBin;
1823 0 : fromBinMethods["numPoly"] = &WVMCalRow::numPolyFromBin;
1824 0 : fromBinMethods["pathCoeff"] = &WVMCalRow::pathCoeffFromBin;
1825 0 : fromBinMethods["refTemp"] = &WVMCalRow::refTempFromBin;
1826 0 : fromBinMethods["inputAntennaId"] = &WVMCalRow::inputAntennaIdFromBin;
1827 :
1828 :
1829 :
1830 :
1831 :
1832 :
1833 :
1834 0 : fromTextMethods["antennaId"] = &WVMCalRow::antennaIdFromText;
1835 :
1836 :
1837 :
1838 0 : fromTextMethods["spectralWindowId"] = &WVMCalRow::spectralWindowIdFromText;
1839 :
1840 :
1841 :
1842 0 : fromTextMethods["timeInterval"] = &WVMCalRow::timeIntervalFromText;
1843 :
1844 :
1845 :
1846 0 : fromTextMethods["wvrMethod"] = &WVMCalRow::wvrMethodFromText;
1847 :
1848 :
1849 :
1850 0 : fromTextMethods["polyFreqLimits"] = &WVMCalRow::polyFreqLimitsFromText;
1851 :
1852 :
1853 :
1854 0 : fromTextMethods["numInputAntenna"] = &WVMCalRow::numInputAntennaFromText;
1855 :
1856 :
1857 :
1858 0 : fromTextMethods["numChan"] = &WVMCalRow::numChanFromText;
1859 :
1860 :
1861 :
1862 0 : fromTextMethods["numPoly"] = &WVMCalRow::numPolyFromText;
1863 :
1864 :
1865 :
1866 0 : fromTextMethods["pathCoeff"] = &WVMCalRow::pathCoeffFromText;
1867 :
1868 :
1869 :
1870 0 : fromTextMethods["refTemp"] = &WVMCalRow::refTempFromText;
1871 :
1872 :
1873 :
1874 0 : fromTextMethods["inputAntennaId"] = &WVMCalRow::inputAntennaIdFromText;
1875 :
1876 :
1877 :
1878 :
1879 0 : }
1880 :
1881 0 : WVMCalRow::WVMCalRow (WVMCalTable &t, WVMCalRow *row) : table(t) {
1882 0 : hasBeenAdded = false;
1883 :
1884 0 : if (row == 0) {
1885 :
1886 :
1887 :
1888 :
1889 :
1890 :
1891 :
1892 :
1893 :
1894 :
1895 :
1896 :
1897 :
1898 :
1899 :
1900 :
1901 :
1902 :
1903 :
1904 :
1905 :
1906 :
1907 :
1908 :
1909 :
1910 : }
1911 : else {
1912 :
1913 :
1914 0 : antennaId = row->antennaId;
1915 :
1916 0 : spectralWindowId = row->spectralWindowId;
1917 :
1918 0 : timeInterval = row->timeInterval;
1919 :
1920 :
1921 :
1922 :
1923 0 : wvrMethod = row->wvrMethod;
1924 :
1925 0 : polyFreqLimits = row->polyFreqLimits;
1926 :
1927 0 : numInputAntenna = row->numInputAntenna;
1928 :
1929 0 : numChan = row->numChan;
1930 :
1931 0 : numPoly = row->numPoly;
1932 :
1933 0 : pathCoeff = row->pathCoeff;
1934 :
1935 0 : refTemp = row->refTemp;
1936 :
1937 0 : inputAntennaId = row->inputAntennaId;
1938 :
1939 :
1940 :
1941 :
1942 : }
1943 :
1944 0 : fromBinMethods["antennaId"] = &WVMCalRow::antennaIdFromBin;
1945 0 : fromBinMethods["spectralWindowId"] = &WVMCalRow::spectralWindowIdFromBin;
1946 0 : fromBinMethods["timeInterval"] = &WVMCalRow::timeIntervalFromBin;
1947 0 : fromBinMethods["wvrMethod"] = &WVMCalRow::wvrMethodFromBin;
1948 0 : fromBinMethods["polyFreqLimits"] = &WVMCalRow::polyFreqLimitsFromBin;
1949 0 : fromBinMethods["numInputAntenna"] = &WVMCalRow::numInputAntennaFromBin;
1950 0 : fromBinMethods["numChan"] = &WVMCalRow::numChanFromBin;
1951 0 : fromBinMethods["numPoly"] = &WVMCalRow::numPolyFromBin;
1952 0 : fromBinMethods["pathCoeff"] = &WVMCalRow::pathCoeffFromBin;
1953 0 : fromBinMethods["refTemp"] = &WVMCalRow::refTempFromBin;
1954 0 : fromBinMethods["inputAntennaId"] = &WVMCalRow::inputAntennaIdFromBin;
1955 :
1956 :
1957 :
1958 0 : }
1959 :
1960 :
1961 0 : bool WVMCalRow::compareNoAutoInc(Tag antennaId, Tag spectralWindowId, ArrayTimeInterval timeInterval, WVRMethodMod::WVRMethod wvrMethod, std::vector<Frequency > polyFreqLimits, int numInputAntenna, int numChan, int numPoly, std::vector<std::vector<std::vector<float > > > pathCoeff, std::vector<std::vector<Temperature > > refTemp, std::vector<Tag> inputAntennaId) {
1962 : bool result;
1963 0 : result = true;
1964 :
1965 :
1966 :
1967 0 : result = result && (this->antennaId == antennaId);
1968 :
1969 0 : if (!result) return false;
1970 :
1971 :
1972 :
1973 :
1974 0 : result = result && (this->spectralWindowId == spectralWindowId);
1975 :
1976 0 : if (!result) return false;
1977 :
1978 :
1979 :
1980 :
1981 0 : result = result && (this->timeInterval.overlaps(timeInterval));
1982 :
1983 0 : if (!result) return false;
1984 :
1985 :
1986 :
1987 :
1988 0 : result = result && (this->wvrMethod == wvrMethod);
1989 :
1990 0 : if (!result) return false;
1991 :
1992 :
1993 :
1994 :
1995 0 : result = result && (this->polyFreqLimits == polyFreqLimits);
1996 :
1997 0 : if (!result) return false;
1998 :
1999 :
2000 :
2001 :
2002 0 : result = result && (this->numInputAntenna == numInputAntenna);
2003 :
2004 0 : if (!result) return false;
2005 :
2006 :
2007 :
2008 :
2009 0 : result = result && (this->numChan == numChan);
2010 :
2011 0 : if (!result) return false;
2012 :
2013 :
2014 :
2015 :
2016 0 : result = result && (this->numPoly == numPoly);
2017 :
2018 0 : if (!result) return false;
2019 :
2020 :
2021 :
2022 :
2023 0 : result = result && (this->pathCoeff == pathCoeff);
2024 :
2025 0 : if (!result) return false;
2026 :
2027 :
2028 :
2029 :
2030 0 : result = result && (this->refTemp == refTemp);
2031 :
2032 0 : if (!result) return false;
2033 :
2034 :
2035 :
2036 :
2037 0 : result = result && (this->inputAntennaId == inputAntennaId);
2038 :
2039 0 : if (!result) return false;
2040 :
2041 :
2042 0 : return result;
2043 : }
2044 :
2045 :
2046 :
2047 0 : bool WVMCalRow::compareRequiredValue(WVRMethodMod::WVRMethod wvrMethod, std::vector<Frequency > polyFreqLimits, int numInputAntenna, int numChan, int numPoly, std::vector<std::vector<std::vector<float > > > pathCoeff, std::vector<std::vector<Temperature > > refTemp, std::vector<Tag> inputAntennaId) {
2048 : bool result;
2049 0 : result = true;
2050 :
2051 :
2052 0 : if (!(this->wvrMethod == wvrMethod)) return false;
2053 :
2054 :
2055 :
2056 0 : if (!(this->polyFreqLimits == polyFreqLimits)) return false;
2057 :
2058 :
2059 :
2060 0 : if (!(this->numInputAntenna == numInputAntenna)) return false;
2061 :
2062 :
2063 :
2064 0 : if (!(this->numChan == numChan)) return false;
2065 :
2066 :
2067 :
2068 0 : if (!(this->numPoly == numPoly)) return false;
2069 :
2070 :
2071 :
2072 0 : if (!(this->pathCoeff == pathCoeff)) return false;
2073 :
2074 :
2075 :
2076 0 : if (!(this->refTemp == refTemp)) return false;
2077 :
2078 :
2079 :
2080 0 : if (!(this->inputAntennaId == inputAntennaId)) return false;
2081 :
2082 :
2083 0 : return result;
2084 : }
2085 :
2086 :
2087 : /**
2088 : * Return true if all required attributes of the value part are equal to their homologues
2089 : * in x and false otherwise.
2090 : *
2091 :
2092 : * @param x a pointer on the WVMCalRow whose required attributes of the value part
2093 :
2094 : * will be compared with those of this.
2095 : * @return a boolean.
2096 : */
2097 0 : bool WVMCalRow::equalByRequiredValue(WVMCalRow* x ) {
2098 :
2099 :
2100 0 : if (this->wvrMethod != x->wvrMethod) return false;
2101 :
2102 0 : if (this->polyFreqLimits != x->polyFreqLimits) return false;
2103 :
2104 0 : if (this->numInputAntenna != x->numInputAntenna) return false;
2105 :
2106 0 : if (this->numChan != x->numChan) return false;
2107 :
2108 0 : if (this->numPoly != x->numPoly) return false;
2109 :
2110 0 : if (this->pathCoeff != x->pathCoeff) return false;
2111 :
2112 0 : if (this->refTemp != x->refTemp) return false;
2113 :
2114 0 : if (this->inputAntennaId != x->inputAntennaId) return false;
2115 :
2116 :
2117 0 : return true;
2118 : }
2119 :
2120 : /*
2121 : map<string, WVMCalAttributeFromBin> WVMCalRow::initFromBinMethods() {
2122 : map<string, WVMCalAttributeFromBin> result;
2123 :
2124 : result["antennaId"] = &WVMCalRow::antennaIdFromBin;
2125 : result["spectralWindowId"] = &WVMCalRow::spectralWindowIdFromBin;
2126 : result["timeInterval"] = &WVMCalRow::timeIntervalFromBin;
2127 : result["wvrMethod"] = &WVMCalRow::wvrMethodFromBin;
2128 : result["polyFreqLimits"] = &WVMCalRow::polyFreqLimitsFromBin;
2129 : result["numInputAntenna"] = &WVMCalRow::numInputAntennaFromBin;
2130 : result["numChan"] = &WVMCalRow::numChanFromBin;
2131 : result["numPoly"] = &WVMCalRow::numPolyFromBin;
2132 : result["pathCoeff"] = &WVMCalRow::pathCoeffFromBin;
2133 : result["refTemp"] = &WVMCalRow::refTempFromBin;
2134 : result["inputAntennaId"] = &WVMCalRow::inputAntennaIdFromBin;
2135 :
2136 :
2137 :
2138 :
2139 : return result;
2140 : }
2141 : */
2142 : } // End namespace asdm
2143 :
|
