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 CalAtmosphereRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalAtmosphereRow.h>
39 : #include <alma/ASDM/CalAtmosphereTable.h>
40 :
41 : #include <alma/ASDM/CalReductionTable.h>
42 : #include <alma/ASDM/CalReductionRow.h>
43 :
44 : #include <alma/ASDM/CalDataTable.h>
45 : #include <alma/ASDM/CalDataRow.h>
46 :
47 :
48 : using asdm::ASDM;
49 : using asdm::CalAtmosphereRow;
50 : using asdm::CalAtmosphereTable;
51 :
52 : using asdm::CalReductionTable;
53 : using asdm::CalReductionRow;
54 :
55 : using asdm::CalDataTable;
56 : using asdm::CalDataRow;
57 :
58 :
59 : #include <alma/ASDM/Parser.h>
60 :
61 : #include <alma/ASDM/EnumerationParser.h>
62 : #include <alma/ASDM/ASDMValuesParser.h>
63 :
64 : #include <alma/ASDM/InvalidArgumentException.h>
65 :
66 : using namespace std;
67 :
68 : namespace asdm {
69 0 : CalAtmosphereRow::~CalAtmosphereRow() {
70 0 : }
71 :
72 : /**
73 : * Return the table to which this row belongs.
74 : */
75 0 : CalAtmosphereTable &CalAtmosphereRow::getTable() const {
76 0 : return table;
77 : }
78 :
79 0 : bool CalAtmosphereRow::isAdded() const {
80 0 : return hasBeenAdded;
81 : }
82 :
83 0 : void CalAtmosphereRow::isAdded(bool added) {
84 0 : hasBeenAdded = added;
85 0 : }
86 :
87 : #ifndef WITHOUT_ACS
88 : using asdmIDL::CalAtmosphereRowIDL;
89 : #endif
90 :
91 : #ifndef WITHOUT_ACS
92 : /**
93 : * Return this row in the form of an IDL struct.
94 : * @return The values of this row as a CalAtmosphereRowIDL struct.
95 : */
96 : CalAtmosphereRowIDL *CalAtmosphereRow::toIDL() const {
97 : CalAtmosphereRowIDL *x = new CalAtmosphereRowIDL ();
98 :
99 : // Fill the IDL structure.
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 :
108 : x->receiverBand = receiverBand;
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 :
120 : x->antennaName = CORBA::string_dup(antennaName.c_str());
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 : x->basebandName = basebandName;
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 : x->startValidTime = startValidTime.toIDLArrayTime();
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 : x->endValidTime = endValidTime.toIDLArrayTime();
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 : x->numFreq = numFreq;
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 : x->numLoad = numLoad;
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 : x->numReceptor = numReceptor;
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 : x->forwardEffSpectrum.length(forwardEffSpectrum.size());
200 : for (unsigned int i = 0; i < forwardEffSpectrum.size(); i++) {
201 : x->forwardEffSpectrum[i].length(forwardEffSpectrum.at(i).size());
202 : }
203 :
204 : for (unsigned int i = 0; i < forwardEffSpectrum.size() ; i++)
205 : for (unsigned int j = 0; j < forwardEffSpectrum.at(i).size(); j++)
206 :
207 :
208 : x->forwardEffSpectrum[i][j] = forwardEffSpectrum.at(i).at(j);
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 : x->frequencyRange.length(frequencyRange.size());
222 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
223 :
224 : x->frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
225 :
226 : }
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 : x->groundPressure = groundPressure.toIDLPressure();
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 : x->groundRelHumidity = groundRelHumidity.toIDLHumidity();
247 :
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 : x->frequencySpectrum.length(frequencySpectrum.size());
257 : for (unsigned int i = 0; i < frequencySpectrum.size(); ++i) {
258 :
259 : x->frequencySpectrum[i] = frequencySpectrum.at(i).toIDLFrequency();
260 :
261 : }
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 : x->groundTemperature = groundTemperature.toIDLTemperature();
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 :
281 : x->polarizationTypes.length(polarizationTypes.size());
282 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
283 :
284 :
285 : x->polarizationTypes[i] = polarizationTypes.at(i);
286 :
287 :
288 : }
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 : x->powerSkySpectrum.length(powerSkySpectrum.size());
299 : for (unsigned int i = 0; i < powerSkySpectrum.size(); i++) {
300 : x->powerSkySpectrum[i].length(powerSkySpectrum.at(i).size());
301 : }
302 :
303 : for (unsigned int i = 0; i < powerSkySpectrum.size() ; i++)
304 : for (unsigned int j = 0; j < powerSkySpectrum.at(i).size(); j++)
305 :
306 :
307 : x->powerSkySpectrum[i][j] = powerSkySpectrum.at(i).at(j);
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 :
318 :
319 :
320 : x->powerLoadSpectrum.length(powerLoadSpectrum.size());
321 : for (unsigned int i = 0; i < powerLoadSpectrum.size(); i++) {
322 : x->powerLoadSpectrum[i].length(powerLoadSpectrum.at(i).size());
323 : for (unsigned int j = 0; j < powerLoadSpectrum.at(i).size(); j++) {
324 : x->powerLoadSpectrum[i][j].length(powerLoadSpectrum.at(i).at(j).size());
325 : }
326 : }
327 :
328 : for (unsigned int i = 0; i < powerLoadSpectrum.size() ; i++)
329 : for (unsigned int j = 0; j < powerLoadSpectrum.at(i).size(); j++)
330 : for (unsigned int k = 0; k < powerLoadSpectrum.at(i).at(j).size(); k++)
331 :
332 :
333 : x->powerLoadSpectrum[i][j][k] = powerLoadSpectrum.at(i).at(j).at(k);
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 : x->syscalType = syscalType;
347 :
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 : x->tAtmSpectrum.length(tAtmSpectrum.size());
358 : for (unsigned int i = 0; i < tAtmSpectrum.size(); i++) {
359 : x->tAtmSpectrum[i].length(tAtmSpectrum.at(i).size());
360 : }
361 :
362 : for (unsigned int i = 0; i < tAtmSpectrum.size() ; i++)
363 : for (unsigned int j = 0; j < tAtmSpectrum.at(i).size(); j++)
364 :
365 : x->tAtmSpectrum[i][j]= tAtmSpectrum.at(i).at(j).toIDLTemperature();
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 :
374 :
375 :
376 :
377 : x->tRecSpectrum.length(tRecSpectrum.size());
378 : for (unsigned int i = 0; i < tRecSpectrum.size(); i++) {
379 : x->tRecSpectrum[i].length(tRecSpectrum.at(i).size());
380 : }
381 :
382 : for (unsigned int i = 0; i < tRecSpectrum.size() ; i++)
383 : for (unsigned int j = 0; j < tRecSpectrum.at(i).size(); j++)
384 :
385 : x->tRecSpectrum[i][j]= tRecSpectrum.at(i).at(j).toIDLTemperature();
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 :
394 :
395 :
396 :
397 : x->tSysSpectrum.length(tSysSpectrum.size());
398 : for (unsigned int i = 0; i < tSysSpectrum.size(); i++) {
399 : x->tSysSpectrum[i].length(tSysSpectrum.at(i).size());
400 : }
401 :
402 : for (unsigned int i = 0; i < tSysSpectrum.size() ; i++)
403 : for (unsigned int j = 0; j < tSysSpectrum.at(i).size(); j++)
404 :
405 : x->tSysSpectrum[i][j]= tSysSpectrum.at(i).at(j).toIDLTemperature();
406 :
407 :
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 : x->tauSpectrum.length(tauSpectrum.size());
418 : for (unsigned int i = 0; i < tauSpectrum.size(); i++) {
419 : x->tauSpectrum[i].length(tauSpectrum.at(i).size());
420 : }
421 :
422 : for (unsigned int i = 0; i < tauSpectrum.size() ; i++)
423 : for (unsigned int j = 0; j < tauSpectrum.at(i).size(); j++)
424 :
425 :
426 : x->tauSpectrum[i][j] = tauSpectrum.at(i).at(j);
427 :
428 :
429 :
430 :
431 :
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 : x->tAtm.length(tAtm.size());
440 : for (unsigned int i = 0; i < tAtm.size(); ++i) {
441 :
442 : x->tAtm[i] = tAtm.at(i).toIDLTemperature();
443 :
444 : }
445 :
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 : x->tRec.length(tRec.size());
455 : for (unsigned int i = 0; i < tRec.size(); ++i) {
456 :
457 : x->tRec[i] = tRec.at(i).toIDLTemperature();
458 :
459 : }
460 :
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 : x->tSys.length(tSys.size());
470 : for (unsigned int i = 0; i < tSys.size(); ++i) {
471 :
472 : x->tSys[i] = tSys.at(i).toIDLTemperature();
473 :
474 : }
475 :
476 :
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 : x->tau.length(tau.size());
485 : for (unsigned int i = 0; i < tau.size(); ++i) {
486 :
487 :
488 : x->tau[i] = tau.at(i);
489 :
490 :
491 : }
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 : x->water.length(water.size());
502 : for (unsigned int i = 0; i < water.size(); ++i) {
503 :
504 : x->water[i] = water.at(i).toIDLLength();
505 :
506 : }
507 :
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 :
516 : x->waterError.length(waterError.size());
517 : for (unsigned int i = 0; i < waterError.size(); ++i) {
518 :
519 : x->waterError[i] = waterError.at(i).toIDLLength();
520 :
521 : }
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 : x->alphaSpectrumExists = alphaSpectrumExists;
530 :
531 :
532 :
533 : x->alphaSpectrum.length(alphaSpectrum.size());
534 : for (unsigned int i = 0; i < alphaSpectrum.size(); i++) {
535 : x->alphaSpectrum[i].length(alphaSpectrum.at(i).size());
536 : }
537 :
538 : for (unsigned int i = 0; i < alphaSpectrum.size() ; i++)
539 : for (unsigned int j = 0; j < alphaSpectrum.at(i).size(); j++)
540 :
541 :
542 : x->alphaSpectrum[i][j] = alphaSpectrum.at(i).at(j);
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 :
552 :
553 : x->forwardEfficiencyExists = forwardEfficiencyExists;
554 :
555 :
556 :
557 : x->forwardEfficiency.length(forwardEfficiency.size());
558 : for (unsigned int i = 0; i < forwardEfficiency.size(); ++i) {
559 :
560 :
561 : x->forwardEfficiency[i] = forwardEfficiency.at(i);
562 :
563 :
564 : }
565 :
566 :
567 :
568 :
569 :
570 :
571 :
572 : x->forwardEfficiencyErrorExists = forwardEfficiencyErrorExists;
573 :
574 :
575 :
576 : x->forwardEfficiencyError.length(forwardEfficiencyError.size());
577 : for (unsigned int i = 0; i < forwardEfficiencyError.size(); ++i) {
578 :
579 :
580 : x->forwardEfficiencyError[i] = forwardEfficiencyError.at(i);
581 :
582 :
583 : }
584 :
585 :
586 :
587 :
588 :
589 :
590 :
591 : x->sbGainExists = sbGainExists;
592 :
593 :
594 :
595 : x->sbGain.length(sbGain.size());
596 : for (unsigned int i = 0; i < sbGain.size(); ++i) {
597 :
598 :
599 : x->sbGain[i] = sbGain.at(i);
600 :
601 :
602 : }
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 : x->sbGainErrorExists = sbGainErrorExists;
611 :
612 :
613 :
614 : x->sbGainError.length(sbGainError.size());
615 : for (unsigned int i = 0; i < sbGainError.size(); ++i) {
616 :
617 :
618 : x->sbGainError[i] = sbGainError.at(i);
619 :
620 :
621 : }
622 :
623 :
624 :
625 :
626 :
627 :
628 :
629 : x->sbGainSpectrumExists = sbGainSpectrumExists;
630 :
631 :
632 :
633 : x->sbGainSpectrum.length(sbGainSpectrum.size());
634 : for (unsigned int i = 0; i < sbGainSpectrum.size(); i++) {
635 : x->sbGainSpectrum[i].length(sbGainSpectrum.at(i).size());
636 : }
637 :
638 : for (unsigned int i = 0; i < sbGainSpectrum.size() ; i++)
639 : for (unsigned int j = 0; j < sbGainSpectrum.at(i).size(); j++)
640 :
641 :
642 : x->sbGainSpectrum[i][j] = sbGainSpectrum.at(i).at(j);
643 :
644 :
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 : x->calDataId = calDataId.toIDLTag();
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 : x->calReductionId = calReductionId.toIDLTag();
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 :
680 :
681 :
682 : return x;
683 :
684 : }
685 :
686 : void CalAtmosphereRow::toIDL(asdmIDL::CalAtmosphereRowIDL& x) const {
687 : // Set the x's fields.
688 :
689 :
690 :
691 :
692 :
693 :
694 :
695 :
696 : x.receiverBand = receiverBand;
697 :
698 :
699 :
700 :
701 :
702 :
703 :
704 :
705 :
706 :
707 :
708 : x.antennaName = CORBA::string_dup(antennaName.c_str());
709 :
710 :
711 :
712 :
713 :
714 :
715 :
716 :
717 :
718 :
719 :
720 : x.basebandName = basebandName;
721 :
722 :
723 :
724 :
725 :
726 :
727 :
728 :
729 :
730 :
731 : x.startValidTime = startValidTime.toIDLArrayTime();
732 :
733 :
734 :
735 :
736 :
737 :
738 :
739 :
740 :
741 : x.endValidTime = endValidTime.toIDLArrayTime();
742 :
743 :
744 :
745 :
746 :
747 :
748 :
749 :
750 :
751 :
752 : x.numFreq = numFreq;
753 :
754 :
755 :
756 :
757 :
758 :
759 :
760 :
761 :
762 :
763 :
764 : x.numLoad = numLoad;
765 :
766 :
767 :
768 :
769 :
770 :
771 :
772 :
773 :
774 :
775 :
776 : x.numReceptor = numReceptor;
777 :
778 :
779 :
780 :
781 :
782 :
783 :
784 :
785 :
786 :
787 : x.forwardEffSpectrum.length(forwardEffSpectrum.size());
788 : for (unsigned int i = 0; i < forwardEffSpectrum.size(); i++) {
789 : x.forwardEffSpectrum[i].length(forwardEffSpectrum.at(i).size());
790 : }
791 :
792 : for (unsigned int i = 0; i < forwardEffSpectrum.size() ; i++)
793 : for (unsigned int j = 0; j < forwardEffSpectrum.at(i).size(); j++)
794 :
795 :
796 : x.forwardEffSpectrum[i][j] = forwardEffSpectrum.at(i).at(j);
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 :
807 :
808 :
809 : x.frequencyRange.length(frequencyRange.size());
810 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
811 :
812 : x.frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
813 :
814 : }
815 :
816 :
817 :
818 :
819 :
820 :
821 :
822 :
823 :
824 : x.groundPressure = groundPressure.toIDLPressure();
825 :
826 :
827 :
828 :
829 :
830 :
831 :
832 :
833 :
834 : x.groundRelHumidity = groundRelHumidity.toIDLHumidity();
835 :
836 :
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 : x.frequencySpectrum.length(frequencySpectrum.size());
845 : for (unsigned int i = 0; i < frequencySpectrum.size(); ++i) {
846 :
847 : x.frequencySpectrum[i] = frequencySpectrum.at(i).toIDLFrequency();
848 :
849 : }
850 :
851 :
852 :
853 :
854 :
855 :
856 :
857 :
858 :
859 : x.groundTemperature = groundTemperature.toIDLTemperature();
860 :
861 :
862 :
863 :
864 :
865 :
866 :
867 :
868 :
869 : x.polarizationTypes.length(polarizationTypes.size());
870 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
871 :
872 :
873 : x.polarizationTypes[i] = polarizationTypes.at(i);
874 :
875 :
876 : }
877 :
878 :
879 :
880 :
881 :
882 :
883 :
884 :
885 :
886 : x.powerSkySpectrum.length(powerSkySpectrum.size());
887 : for (unsigned int i = 0; i < powerSkySpectrum.size(); i++) {
888 : x.powerSkySpectrum[i].length(powerSkySpectrum.at(i).size());
889 : }
890 :
891 : for (unsigned int i = 0; i < powerSkySpectrum.size() ; i++)
892 : for (unsigned int j = 0; j < powerSkySpectrum.at(i).size(); j++)
893 :
894 :
895 : x.powerSkySpectrum[i][j] = powerSkySpectrum.at(i).at(j);
896 :
897 :
898 :
899 :
900 :
901 :
902 :
903 :
904 :
905 :
906 :
907 :
908 : x.powerLoadSpectrum.length(powerLoadSpectrum.size());
909 : for (unsigned int i = 0; i < powerLoadSpectrum.size(); i++) {
910 : x.powerLoadSpectrum[i].length(powerLoadSpectrum.at(i).size());
911 : for (unsigned int j = 0; j < powerLoadSpectrum.at(i).size(); j++) {
912 : x.powerLoadSpectrum[i][j].length(powerLoadSpectrum.at(i).at(j).size());
913 : }
914 : }
915 :
916 : for (unsigned int i = 0; i < powerLoadSpectrum.size() ; i++)
917 : for (unsigned int j = 0; j < powerLoadSpectrum.at(i).size(); j++)
918 : for (unsigned int k = 0; k < powerLoadSpectrum.at(i).at(j).size(); k++)
919 :
920 :
921 : x.powerLoadSpectrum[i][j][k] = powerLoadSpectrum.at(i).at(j).at(k);
922 :
923 :
924 :
925 :
926 :
927 :
928 :
929 :
930 :
931 :
932 :
933 :
934 : x.syscalType = syscalType;
935 :
936 :
937 :
938 :
939 :
940 :
941 :
942 :
943 :
944 :
945 : x.tAtmSpectrum.length(tAtmSpectrum.size());
946 : for (unsigned int i = 0; i < tAtmSpectrum.size(); i++) {
947 : x.tAtmSpectrum[i].length(tAtmSpectrum.at(i).size());
948 : }
949 :
950 : for (unsigned int i = 0; i < tAtmSpectrum.size() ; i++)
951 : for (unsigned int j = 0; j < tAtmSpectrum.at(i).size(); j++)
952 :
953 : x.tAtmSpectrum[i][j]= tAtmSpectrum.at(i).at(j).toIDLTemperature();
954 :
955 :
956 :
957 :
958 :
959 :
960 :
961 :
962 :
963 :
964 :
965 : x.tRecSpectrum.length(tRecSpectrum.size());
966 : for (unsigned int i = 0; i < tRecSpectrum.size(); i++) {
967 : x.tRecSpectrum[i].length(tRecSpectrum.at(i).size());
968 : }
969 :
970 : for (unsigned int i = 0; i < tRecSpectrum.size() ; i++)
971 : for (unsigned int j = 0; j < tRecSpectrum.at(i).size(); j++)
972 :
973 : x.tRecSpectrum[i][j]= tRecSpectrum.at(i).at(j).toIDLTemperature();
974 :
975 :
976 :
977 :
978 :
979 :
980 :
981 :
982 :
983 :
984 :
985 : x.tSysSpectrum.length(tSysSpectrum.size());
986 : for (unsigned int i = 0; i < tSysSpectrum.size(); i++) {
987 : x.tSysSpectrum[i].length(tSysSpectrum.at(i).size());
988 : }
989 :
990 : for (unsigned int i = 0; i < tSysSpectrum.size() ; i++)
991 : for (unsigned int j = 0; j < tSysSpectrum.at(i).size(); j++)
992 :
993 : x.tSysSpectrum[i][j]= tSysSpectrum.at(i).at(j).toIDLTemperature();
994 :
995 :
996 :
997 :
998 :
999 :
1000 :
1001 :
1002 :
1003 :
1004 :
1005 : x.tauSpectrum.length(tauSpectrum.size());
1006 : for (unsigned int i = 0; i < tauSpectrum.size(); i++) {
1007 : x.tauSpectrum[i].length(tauSpectrum.at(i).size());
1008 : }
1009 :
1010 : for (unsigned int i = 0; i < tauSpectrum.size() ; i++)
1011 : for (unsigned int j = 0; j < tauSpectrum.at(i).size(); j++)
1012 :
1013 :
1014 : x.tauSpectrum[i][j] = tauSpectrum.at(i).at(j);
1015 :
1016 :
1017 :
1018 :
1019 :
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 : x.tAtm.length(tAtm.size());
1028 : for (unsigned int i = 0; i < tAtm.size(); ++i) {
1029 :
1030 : x.tAtm[i] = tAtm.at(i).toIDLTemperature();
1031 :
1032 : }
1033 :
1034 :
1035 :
1036 :
1037 :
1038 :
1039 :
1040 :
1041 :
1042 : x.tRec.length(tRec.size());
1043 : for (unsigned int i = 0; i < tRec.size(); ++i) {
1044 :
1045 : x.tRec[i] = tRec.at(i).toIDLTemperature();
1046 :
1047 : }
1048 :
1049 :
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 :
1057 : x.tSys.length(tSys.size());
1058 : for (unsigned int i = 0; i < tSys.size(); ++i) {
1059 :
1060 : x.tSys[i] = tSys.at(i).toIDLTemperature();
1061 :
1062 : }
1063 :
1064 :
1065 :
1066 :
1067 :
1068 :
1069 :
1070 :
1071 :
1072 : x.tau.length(tau.size());
1073 : for (unsigned int i = 0; i < tau.size(); ++i) {
1074 :
1075 :
1076 : x.tau[i] = tau.at(i);
1077 :
1078 :
1079 : }
1080 :
1081 :
1082 :
1083 :
1084 :
1085 :
1086 :
1087 :
1088 :
1089 : x.water.length(water.size());
1090 : for (unsigned int i = 0; i < water.size(); ++i) {
1091 :
1092 : x.water[i] = water.at(i).toIDLLength();
1093 :
1094 : }
1095 :
1096 :
1097 :
1098 :
1099 :
1100 :
1101 :
1102 :
1103 :
1104 : x.waterError.length(waterError.size());
1105 : for (unsigned int i = 0; i < waterError.size(); ++i) {
1106 :
1107 : x.waterError[i] = waterError.at(i).toIDLLength();
1108 :
1109 : }
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 :
1117 : x.alphaSpectrumExists = alphaSpectrumExists;
1118 :
1119 :
1120 :
1121 : x.alphaSpectrum.length(alphaSpectrum.size());
1122 : for (unsigned int i = 0; i < alphaSpectrum.size(); i++) {
1123 : x.alphaSpectrum[i].length(alphaSpectrum.at(i).size());
1124 : }
1125 :
1126 : for (unsigned int i = 0; i < alphaSpectrum.size() ; i++)
1127 : for (unsigned int j = 0; j < alphaSpectrum.at(i).size(); j++)
1128 :
1129 :
1130 : x.alphaSpectrum[i][j] = alphaSpectrum.at(i).at(j);
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 :
1140 :
1141 : x.forwardEfficiencyExists = forwardEfficiencyExists;
1142 :
1143 :
1144 :
1145 : x.forwardEfficiency.length(forwardEfficiency.size());
1146 : for (unsigned int i = 0; i < forwardEfficiency.size(); ++i) {
1147 :
1148 :
1149 : x.forwardEfficiency[i] = forwardEfficiency.at(i);
1150 :
1151 :
1152 : }
1153 :
1154 :
1155 :
1156 :
1157 :
1158 :
1159 :
1160 : x.forwardEfficiencyErrorExists = forwardEfficiencyErrorExists;
1161 :
1162 :
1163 :
1164 : x.forwardEfficiencyError.length(forwardEfficiencyError.size());
1165 : for (unsigned int i = 0; i < forwardEfficiencyError.size(); ++i) {
1166 :
1167 :
1168 : x.forwardEfficiencyError[i] = forwardEfficiencyError.at(i);
1169 :
1170 :
1171 : }
1172 :
1173 :
1174 :
1175 :
1176 :
1177 :
1178 :
1179 : x.sbGainExists = sbGainExists;
1180 :
1181 :
1182 :
1183 : x.sbGain.length(sbGain.size());
1184 : for (unsigned int i = 0; i < sbGain.size(); ++i) {
1185 :
1186 :
1187 : x.sbGain[i] = sbGain.at(i);
1188 :
1189 :
1190 : }
1191 :
1192 :
1193 :
1194 :
1195 :
1196 :
1197 :
1198 : x.sbGainErrorExists = sbGainErrorExists;
1199 :
1200 :
1201 :
1202 : x.sbGainError.length(sbGainError.size());
1203 : for (unsigned int i = 0; i < sbGainError.size(); ++i) {
1204 :
1205 :
1206 : x.sbGainError[i] = sbGainError.at(i);
1207 :
1208 :
1209 : }
1210 :
1211 :
1212 :
1213 :
1214 :
1215 :
1216 :
1217 : x.sbGainSpectrumExists = sbGainSpectrumExists;
1218 :
1219 :
1220 :
1221 : x.sbGainSpectrum.length(sbGainSpectrum.size());
1222 : for (unsigned int i = 0; i < sbGainSpectrum.size(); i++) {
1223 : x.sbGainSpectrum[i].length(sbGainSpectrum.at(i).size());
1224 : }
1225 :
1226 : for (unsigned int i = 0; i < sbGainSpectrum.size() ; i++)
1227 : for (unsigned int j = 0; j < sbGainSpectrum.at(i).size(); j++)
1228 :
1229 :
1230 : x.sbGainSpectrum[i][j] = sbGainSpectrum.at(i).at(j);
1231 :
1232 :
1233 :
1234 :
1235 :
1236 :
1237 :
1238 :
1239 :
1240 :
1241 :
1242 :
1243 :
1244 :
1245 :
1246 :
1247 : x.calDataId = calDataId.toIDLTag();
1248 :
1249 :
1250 :
1251 :
1252 :
1253 :
1254 :
1255 :
1256 :
1257 :
1258 : x.calReductionId = calReductionId.toIDLTag();
1259 :
1260 :
1261 :
1262 :
1263 :
1264 :
1265 :
1266 :
1267 :
1268 :
1269 :
1270 : }
1271 : #endif
1272 :
1273 :
1274 : #ifndef WITHOUT_ACS
1275 : /**
1276 : * Fill the values of this row from the IDL struct CalAtmosphereRowIDL.
1277 : * @param x The IDL struct containing the values used to fill this row.
1278 : */
1279 : void CalAtmosphereRow::setFromIDL (CalAtmosphereRowIDL x){
1280 : try {
1281 : // Fill the values from x.
1282 :
1283 :
1284 :
1285 :
1286 :
1287 :
1288 : setReceiverBand(x.receiverBand);
1289 :
1290 :
1291 :
1292 :
1293 :
1294 :
1295 :
1296 :
1297 :
1298 : setAntennaName(string (x.antennaName));
1299 :
1300 :
1301 :
1302 :
1303 :
1304 :
1305 :
1306 :
1307 :
1308 : setBasebandName(x.basebandName);
1309 :
1310 :
1311 :
1312 :
1313 :
1314 :
1315 :
1316 :
1317 :
1318 : setStartValidTime(ArrayTime (x.startValidTime));
1319 :
1320 :
1321 :
1322 :
1323 :
1324 :
1325 :
1326 :
1327 :
1328 : setEndValidTime(ArrayTime (x.endValidTime));
1329 :
1330 :
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 :
1338 : setNumFreq(x.numFreq);
1339 :
1340 :
1341 :
1342 :
1343 :
1344 :
1345 :
1346 :
1347 :
1348 : setNumLoad(x.numLoad);
1349 :
1350 :
1351 :
1352 :
1353 :
1354 :
1355 :
1356 :
1357 :
1358 : setNumReceptor(x.numReceptor);
1359 :
1360 :
1361 :
1362 :
1363 :
1364 :
1365 :
1366 :
1367 :
1368 : forwardEffSpectrum .clear();
1369 :
1370 : vector<float> v_aux_forwardEffSpectrum;
1371 :
1372 : for (unsigned int i = 0; i < x.forwardEffSpectrum.length(); ++i) {
1373 : v_aux_forwardEffSpectrum.clear();
1374 : for (unsigned int j = 0; j < x.forwardEffSpectrum[0].length(); ++j) {
1375 :
1376 : v_aux_forwardEffSpectrum.push_back(x.forwardEffSpectrum[i][j]);
1377 :
1378 : }
1379 : forwardEffSpectrum.push_back(v_aux_forwardEffSpectrum);
1380 : }
1381 :
1382 :
1383 :
1384 :
1385 :
1386 :
1387 :
1388 :
1389 :
1390 : frequencyRange .clear();
1391 : for (unsigned int i = 0; i <x.frequencyRange.length(); ++i) {
1392 :
1393 : frequencyRange.push_back(Frequency (x.frequencyRange[i]));
1394 :
1395 : }
1396 :
1397 :
1398 :
1399 :
1400 :
1401 :
1402 :
1403 :
1404 :
1405 : setGroundPressure(Pressure (x.groundPressure));
1406 :
1407 :
1408 :
1409 :
1410 :
1411 :
1412 :
1413 :
1414 :
1415 : setGroundRelHumidity(Humidity (x.groundRelHumidity));
1416 :
1417 :
1418 :
1419 :
1420 :
1421 :
1422 :
1423 :
1424 :
1425 : frequencySpectrum .clear();
1426 : for (unsigned int i = 0; i <x.frequencySpectrum.length(); ++i) {
1427 :
1428 : frequencySpectrum.push_back(Frequency (x.frequencySpectrum[i]));
1429 :
1430 : }
1431 :
1432 :
1433 :
1434 :
1435 :
1436 :
1437 :
1438 :
1439 :
1440 : setGroundTemperature(Temperature (x.groundTemperature));
1441 :
1442 :
1443 :
1444 :
1445 :
1446 :
1447 :
1448 :
1449 :
1450 : polarizationTypes .clear();
1451 : for (unsigned int i = 0; i <x.polarizationTypes.length(); ++i) {
1452 :
1453 : polarizationTypes.push_back(x.polarizationTypes[i]);
1454 :
1455 : }
1456 :
1457 :
1458 :
1459 :
1460 :
1461 :
1462 :
1463 :
1464 :
1465 : powerSkySpectrum .clear();
1466 :
1467 : vector<float> v_aux_powerSkySpectrum;
1468 :
1469 : for (unsigned int i = 0; i < x.powerSkySpectrum.length(); ++i) {
1470 : v_aux_powerSkySpectrum.clear();
1471 : for (unsigned int j = 0; j < x.powerSkySpectrum[0].length(); ++j) {
1472 :
1473 : v_aux_powerSkySpectrum.push_back(x.powerSkySpectrum[i][j]);
1474 :
1475 : }
1476 : powerSkySpectrum.push_back(v_aux_powerSkySpectrum);
1477 : }
1478 :
1479 :
1480 :
1481 :
1482 :
1483 :
1484 :
1485 :
1486 :
1487 : powerLoadSpectrum .clear();
1488 : vector< vector<float> > vv_aux_powerLoadSpectrum;
1489 : vector<float> v_aux_powerLoadSpectrum;
1490 :
1491 : for (unsigned int i = 0; i < x.powerLoadSpectrum.length(); ++i) {
1492 : vv_aux_powerLoadSpectrum.clear();
1493 : for (unsigned int j = 0; j < x.powerLoadSpectrum[0].length(); ++j) {
1494 : v_aux_powerLoadSpectrum.clear();
1495 : for (unsigned int k = 0; k < x.powerLoadSpectrum[0][0].length(); ++k) {
1496 :
1497 : v_aux_powerLoadSpectrum.push_back(x.powerLoadSpectrum[i][j][k]);
1498 :
1499 : }
1500 : vv_aux_powerLoadSpectrum.push_back(v_aux_powerLoadSpectrum);
1501 : }
1502 : powerLoadSpectrum.push_back(vv_aux_powerLoadSpectrum);
1503 : }
1504 :
1505 :
1506 :
1507 :
1508 :
1509 :
1510 :
1511 :
1512 :
1513 : setSyscalType(x.syscalType);
1514 :
1515 :
1516 :
1517 :
1518 :
1519 :
1520 :
1521 :
1522 :
1523 : tAtmSpectrum .clear();
1524 :
1525 : vector<Temperature> v_aux_tAtmSpectrum;
1526 :
1527 : for (unsigned int i = 0; i < x.tAtmSpectrum.length(); ++i) {
1528 : v_aux_tAtmSpectrum.clear();
1529 : for (unsigned int j = 0; j < x.tAtmSpectrum[0].length(); ++j) {
1530 :
1531 : v_aux_tAtmSpectrum.push_back(Temperature (x.tAtmSpectrum[i][j]));
1532 :
1533 : }
1534 : tAtmSpectrum.push_back(v_aux_tAtmSpectrum);
1535 : }
1536 :
1537 :
1538 :
1539 :
1540 :
1541 :
1542 :
1543 :
1544 :
1545 : tRecSpectrum .clear();
1546 :
1547 : vector<Temperature> v_aux_tRecSpectrum;
1548 :
1549 : for (unsigned int i = 0; i < x.tRecSpectrum.length(); ++i) {
1550 : v_aux_tRecSpectrum.clear();
1551 : for (unsigned int j = 0; j < x.tRecSpectrum[0].length(); ++j) {
1552 :
1553 : v_aux_tRecSpectrum.push_back(Temperature (x.tRecSpectrum[i][j]));
1554 :
1555 : }
1556 : tRecSpectrum.push_back(v_aux_tRecSpectrum);
1557 : }
1558 :
1559 :
1560 :
1561 :
1562 :
1563 :
1564 :
1565 :
1566 :
1567 : tSysSpectrum .clear();
1568 :
1569 : vector<Temperature> v_aux_tSysSpectrum;
1570 :
1571 : for (unsigned int i = 0; i < x.tSysSpectrum.length(); ++i) {
1572 : v_aux_tSysSpectrum.clear();
1573 : for (unsigned int j = 0; j < x.tSysSpectrum[0].length(); ++j) {
1574 :
1575 : v_aux_tSysSpectrum.push_back(Temperature (x.tSysSpectrum[i][j]));
1576 :
1577 : }
1578 : tSysSpectrum.push_back(v_aux_tSysSpectrum);
1579 : }
1580 :
1581 :
1582 :
1583 :
1584 :
1585 :
1586 :
1587 :
1588 :
1589 : tauSpectrum .clear();
1590 :
1591 : vector<float> v_aux_tauSpectrum;
1592 :
1593 : for (unsigned int i = 0; i < x.tauSpectrum.length(); ++i) {
1594 : v_aux_tauSpectrum.clear();
1595 : for (unsigned int j = 0; j < x.tauSpectrum[0].length(); ++j) {
1596 :
1597 : v_aux_tauSpectrum.push_back(x.tauSpectrum[i][j]);
1598 :
1599 : }
1600 : tauSpectrum.push_back(v_aux_tauSpectrum);
1601 : }
1602 :
1603 :
1604 :
1605 :
1606 :
1607 :
1608 :
1609 :
1610 :
1611 : tAtm .clear();
1612 : for (unsigned int i = 0; i <x.tAtm.length(); ++i) {
1613 :
1614 : tAtm.push_back(Temperature (x.tAtm[i]));
1615 :
1616 : }
1617 :
1618 :
1619 :
1620 :
1621 :
1622 :
1623 :
1624 :
1625 :
1626 : tRec .clear();
1627 : for (unsigned int i = 0; i <x.tRec.length(); ++i) {
1628 :
1629 : tRec.push_back(Temperature (x.tRec[i]));
1630 :
1631 : }
1632 :
1633 :
1634 :
1635 :
1636 :
1637 :
1638 :
1639 :
1640 :
1641 : tSys .clear();
1642 : for (unsigned int i = 0; i <x.tSys.length(); ++i) {
1643 :
1644 : tSys.push_back(Temperature (x.tSys[i]));
1645 :
1646 : }
1647 :
1648 :
1649 :
1650 :
1651 :
1652 :
1653 :
1654 :
1655 :
1656 : tau .clear();
1657 : for (unsigned int i = 0; i <x.tau.length(); ++i) {
1658 :
1659 : tau.push_back(x.tau[i]);
1660 :
1661 : }
1662 :
1663 :
1664 :
1665 :
1666 :
1667 :
1668 :
1669 :
1670 :
1671 : water .clear();
1672 : for (unsigned int i = 0; i <x.water.length(); ++i) {
1673 :
1674 : water.push_back(Length (x.water[i]));
1675 :
1676 : }
1677 :
1678 :
1679 :
1680 :
1681 :
1682 :
1683 :
1684 :
1685 :
1686 : waterError .clear();
1687 : for (unsigned int i = 0; i <x.waterError.length(); ++i) {
1688 :
1689 : waterError.push_back(Length (x.waterError[i]));
1690 :
1691 : }
1692 :
1693 :
1694 :
1695 :
1696 :
1697 :
1698 :
1699 : alphaSpectrumExists = x.alphaSpectrumExists;
1700 : if (x.alphaSpectrumExists) {
1701 :
1702 :
1703 :
1704 : alphaSpectrum .clear();
1705 :
1706 : vector<float> v_aux_alphaSpectrum;
1707 :
1708 : for (unsigned int i = 0; i < x.alphaSpectrum.length(); ++i) {
1709 : v_aux_alphaSpectrum.clear();
1710 : for (unsigned int j = 0; j < x.alphaSpectrum[0].length(); ++j) {
1711 :
1712 : v_aux_alphaSpectrum.push_back(x.alphaSpectrum[i][j]);
1713 :
1714 : }
1715 : alphaSpectrum.push_back(v_aux_alphaSpectrum);
1716 : }
1717 :
1718 :
1719 :
1720 : }
1721 :
1722 :
1723 :
1724 :
1725 :
1726 : forwardEfficiencyExists = x.forwardEfficiencyExists;
1727 : if (x.forwardEfficiencyExists) {
1728 :
1729 :
1730 :
1731 : forwardEfficiency .clear();
1732 : for (unsigned int i = 0; i <x.forwardEfficiency.length(); ++i) {
1733 :
1734 : forwardEfficiency.push_back(x.forwardEfficiency[i]);
1735 :
1736 : }
1737 :
1738 :
1739 :
1740 : }
1741 :
1742 :
1743 :
1744 :
1745 :
1746 : forwardEfficiencyErrorExists = x.forwardEfficiencyErrorExists;
1747 : if (x.forwardEfficiencyErrorExists) {
1748 :
1749 :
1750 :
1751 : forwardEfficiencyError .clear();
1752 : for (unsigned int i = 0; i <x.forwardEfficiencyError.length(); ++i) {
1753 :
1754 : forwardEfficiencyError.push_back(x.forwardEfficiencyError[i]);
1755 :
1756 : }
1757 :
1758 :
1759 :
1760 : }
1761 :
1762 :
1763 :
1764 :
1765 :
1766 : sbGainExists = x.sbGainExists;
1767 : if (x.sbGainExists) {
1768 :
1769 :
1770 :
1771 : sbGain .clear();
1772 : for (unsigned int i = 0; i <x.sbGain.length(); ++i) {
1773 :
1774 : sbGain.push_back(x.sbGain[i]);
1775 :
1776 : }
1777 :
1778 :
1779 :
1780 : }
1781 :
1782 :
1783 :
1784 :
1785 :
1786 : sbGainErrorExists = x.sbGainErrorExists;
1787 : if (x.sbGainErrorExists) {
1788 :
1789 :
1790 :
1791 : sbGainError .clear();
1792 : for (unsigned int i = 0; i <x.sbGainError.length(); ++i) {
1793 :
1794 : sbGainError.push_back(x.sbGainError[i]);
1795 :
1796 : }
1797 :
1798 :
1799 :
1800 : }
1801 :
1802 :
1803 :
1804 :
1805 :
1806 : sbGainSpectrumExists = x.sbGainSpectrumExists;
1807 : if (x.sbGainSpectrumExists) {
1808 :
1809 :
1810 :
1811 : sbGainSpectrum .clear();
1812 :
1813 : vector<float> v_aux_sbGainSpectrum;
1814 :
1815 : for (unsigned int i = 0; i < x.sbGainSpectrum.length(); ++i) {
1816 : v_aux_sbGainSpectrum.clear();
1817 : for (unsigned int j = 0; j < x.sbGainSpectrum[0].length(); ++j) {
1818 :
1819 : v_aux_sbGainSpectrum.push_back(x.sbGainSpectrum[i][j]);
1820 :
1821 : }
1822 : sbGainSpectrum.push_back(v_aux_sbGainSpectrum);
1823 : }
1824 :
1825 :
1826 :
1827 : }
1828 :
1829 :
1830 :
1831 :
1832 :
1833 :
1834 :
1835 :
1836 :
1837 :
1838 : setCalDataId(Tag (x.calDataId));
1839 :
1840 :
1841 :
1842 :
1843 :
1844 :
1845 :
1846 :
1847 :
1848 : setCalReductionId(Tag (x.calReductionId));
1849 :
1850 :
1851 :
1852 :
1853 :
1854 :
1855 :
1856 :
1857 :
1858 :
1859 :
1860 : } catch (const IllegalAccessException &err) {
1861 : throw ConversionException (err.getMessage(),"CalAtmosphere");
1862 : }
1863 : }
1864 : #endif
1865 :
1866 : /**
1867 : * Return this row in the form of an XML string.
1868 : * @return The values of this row as an XML string.
1869 : */
1870 0 : string CalAtmosphereRow::toXML() const {
1871 0 : string buf;
1872 0 : buf.append("<row> \n");
1873 :
1874 :
1875 :
1876 :
1877 :
1878 :
1879 0 : buf.append(EnumerationParser::toXML("receiverBand", receiverBand));
1880 :
1881 :
1882 :
1883 :
1884 :
1885 :
1886 :
1887 0 : Parser::toXML(antennaName, "antennaName", buf);
1888 :
1889 :
1890 :
1891 :
1892 :
1893 :
1894 :
1895 0 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
1896 :
1897 :
1898 :
1899 :
1900 :
1901 :
1902 :
1903 0 : Parser::toXML(startValidTime, "startValidTime", buf);
1904 :
1905 :
1906 :
1907 :
1908 :
1909 :
1910 :
1911 0 : Parser::toXML(endValidTime, "endValidTime", buf);
1912 :
1913 :
1914 :
1915 :
1916 :
1917 :
1918 :
1919 0 : Parser::toXML(numFreq, "numFreq", buf);
1920 :
1921 :
1922 :
1923 :
1924 :
1925 :
1926 :
1927 0 : Parser::toXML(numLoad, "numLoad", buf);
1928 :
1929 :
1930 :
1931 :
1932 :
1933 :
1934 :
1935 0 : Parser::toXML(numReceptor, "numReceptor", buf);
1936 :
1937 :
1938 :
1939 :
1940 :
1941 :
1942 :
1943 0 : Parser::toXML(forwardEffSpectrum, "forwardEffSpectrum", buf);
1944 :
1945 :
1946 :
1947 :
1948 :
1949 :
1950 :
1951 0 : Parser::toXML(frequencyRange, "frequencyRange", buf);
1952 :
1953 :
1954 :
1955 :
1956 :
1957 :
1958 :
1959 0 : Parser::toXML(groundPressure, "groundPressure", buf);
1960 :
1961 :
1962 :
1963 :
1964 :
1965 :
1966 :
1967 0 : Parser::toXML(groundRelHumidity, "groundRelHumidity", buf);
1968 :
1969 :
1970 :
1971 :
1972 :
1973 :
1974 :
1975 0 : Parser::toXML(frequencySpectrum, "frequencySpectrum", buf);
1976 :
1977 :
1978 :
1979 :
1980 :
1981 :
1982 :
1983 0 : Parser::toXML(groundTemperature, "groundTemperature", buf);
1984 :
1985 :
1986 :
1987 :
1988 :
1989 :
1990 :
1991 0 : buf.append(EnumerationParser::toXML("polarizationTypes", polarizationTypes));
1992 :
1993 :
1994 :
1995 :
1996 :
1997 :
1998 :
1999 0 : Parser::toXML(powerSkySpectrum, "powerSkySpectrum", buf);
2000 :
2001 :
2002 :
2003 :
2004 :
2005 :
2006 :
2007 0 : Parser::toXML(powerLoadSpectrum, "powerLoadSpectrum", buf);
2008 :
2009 :
2010 :
2011 :
2012 :
2013 :
2014 :
2015 0 : buf.append(EnumerationParser::toXML("syscalType", syscalType));
2016 :
2017 :
2018 :
2019 :
2020 :
2021 :
2022 :
2023 0 : Parser::toXML(tAtmSpectrum, "tAtmSpectrum", buf);
2024 :
2025 :
2026 :
2027 :
2028 :
2029 :
2030 :
2031 0 : Parser::toXML(tRecSpectrum, "tRecSpectrum", buf);
2032 :
2033 :
2034 :
2035 :
2036 :
2037 :
2038 :
2039 0 : Parser::toXML(tSysSpectrum, "tSysSpectrum", buf);
2040 :
2041 :
2042 :
2043 :
2044 :
2045 :
2046 :
2047 0 : Parser::toXML(tauSpectrum, "tauSpectrum", buf);
2048 :
2049 :
2050 :
2051 :
2052 :
2053 :
2054 :
2055 0 : Parser::toXML(tAtm, "tAtm", buf);
2056 :
2057 :
2058 :
2059 :
2060 :
2061 :
2062 :
2063 0 : Parser::toXML(tRec, "tRec", buf);
2064 :
2065 :
2066 :
2067 :
2068 :
2069 :
2070 :
2071 0 : Parser::toXML(tSys, "tSys", buf);
2072 :
2073 :
2074 :
2075 :
2076 :
2077 :
2078 :
2079 0 : Parser::toXML(tau, "tau", buf);
2080 :
2081 :
2082 :
2083 :
2084 :
2085 :
2086 :
2087 0 : Parser::toXML(water, "water", buf);
2088 :
2089 :
2090 :
2091 :
2092 :
2093 :
2094 :
2095 0 : Parser::toXML(waterError, "waterError", buf);
2096 :
2097 :
2098 :
2099 :
2100 :
2101 :
2102 0 : if (alphaSpectrumExists) {
2103 :
2104 :
2105 0 : Parser::toXML(alphaSpectrum, "alphaSpectrum", buf);
2106 :
2107 :
2108 : }
2109 :
2110 :
2111 :
2112 :
2113 :
2114 0 : if (forwardEfficiencyExists) {
2115 :
2116 :
2117 0 : Parser::toXML(forwardEfficiency, "forwardEfficiency", buf);
2118 :
2119 :
2120 : }
2121 :
2122 :
2123 :
2124 :
2125 :
2126 0 : if (forwardEfficiencyErrorExists) {
2127 :
2128 :
2129 0 : Parser::toXML(forwardEfficiencyError, "forwardEfficiencyError", buf);
2130 :
2131 :
2132 : }
2133 :
2134 :
2135 :
2136 :
2137 :
2138 0 : if (sbGainExists) {
2139 :
2140 :
2141 0 : Parser::toXML(sbGain, "sbGain", buf);
2142 :
2143 :
2144 : }
2145 :
2146 :
2147 :
2148 :
2149 :
2150 0 : if (sbGainErrorExists) {
2151 :
2152 :
2153 0 : Parser::toXML(sbGainError, "sbGainError", buf);
2154 :
2155 :
2156 : }
2157 :
2158 :
2159 :
2160 :
2161 :
2162 0 : if (sbGainSpectrumExists) {
2163 :
2164 :
2165 0 : Parser::toXML(sbGainSpectrum, "sbGainSpectrum", buf);
2166 :
2167 :
2168 : }
2169 :
2170 :
2171 :
2172 :
2173 :
2174 :
2175 :
2176 :
2177 :
2178 0 : Parser::toXML(calDataId, "calDataId", buf);
2179 :
2180 :
2181 :
2182 :
2183 :
2184 :
2185 :
2186 0 : Parser::toXML(calReductionId, "calReductionId", buf);
2187 :
2188 :
2189 :
2190 :
2191 :
2192 :
2193 :
2194 :
2195 :
2196 :
2197 :
2198 0 : buf.append("</row>\n");
2199 0 : return buf;
2200 : }
2201 :
2202 : /**
2203 : * Fill the values of this row from an XML string
2204 : * that was produced by the toXML() method.
2205 : * @param x The XML string being used to set the values of this row.
2206 : */
2207 0 : void CalAtmosphereRow::setFromXML (string rowDoc) {
2208 0 : Parser row(rowDoc);
2209 0 : string s = "";
2210 : try {
2211 :
2212 :
2213 :
2214 :
2215 :
2216 :
2217 0 : receiverBand = EnumerationParser::getReceiverBand("receiverBand","CalAtmosphere",rowDoc);
2218 :
2219 :
2220 :
2221 :
2222 :
2223 :
2224 :
2225 :
2226 0 : setAntennaName(Parser::getString("antennaName","CalAtmosphere",rowDoc));
2227 :
2228 :
2229 :
2230 :
2231 :
2232 :
2233 :
2234 :
2235 0 : basebandName = EnumerationParser::getBasebandName("basebandName","CalAtmosphere",rowDoc);
2236 :
2237 :
2238 :
2239 :
2240 :
2241 :
2242 :
2243 :
2244 0 : setStartValidTime(Parser::getArrayTime("startValidTime","CalAtmosphere",rowDoc));
2245 :
2246 :
2247 :
2248 :
2249 :
2250 :
2251 :
2252 0 : setEndValidTime(Parser::getArrayTime("endValidTime","CalAtmosphere",rowDoc));
2253 :
2254 :
2255 :
2256 :
2257 :
2258 :
2259 :
2260 0 : setNumFreq(Parser::getInteger("numFreq","CalAtmosphere",rowDoc));
2261 :
2262 :
2263 :
2264 :
2265 :
2266 :
2267 :
2268 0 : setNumLoad(Parser::getInteger("numLoad","CalAtmosphere",rowDoc));
2269 :
2270 :
2271 :
2272 :
2273 :
2274 :
2275 :
2276 0 : setNumReceptor(Parser::getInteger("numReceptor","CalAtmosphere",rowDoc));
2277 :
2278 :
2279 :
2280 :
2281 :
2282 :
2283 :
2284 :
2285 0 : setForwardEffSpectrum(Parser::get2DFloat("forwardEffSpectrum","CalAtmosphere",rowDoc));
2286 :
2287 :
2288 :
2289 :
2290 :
2291 :
2292 :
2293 :
2294 :
2295 0 : setFrequencyRange(Parser::get1DFrequency("frequencyRange","CalAtmosphere",rowDoc));
2296 :
2297 :
2298 :
2299 :
2300 :
2301 :
2302 :
2303 :
2304 0 : setGroundPressure(Parser::getPressure("groundPressure","CalAtmosphere",rowDoc));
2305 :
2306 :
2307 :
2308 :
2309 :
2310 :
2311 :
2312 0 : setGroundRelHumidity(Parser::getHumidity("groundRelHumidity","CalAtmosphere",rowDoc));
2313 :
2314 :
2315 :
2316 :
2317 :
2318 :
2319 :
2320 :
2321 0 : setFrequencySpectrum(Parser::get1DFrequency("frequencySpectrum","CalAtmosphere",rowDoc));
2322 :
2323 :
2324 :
2325 :
2326 :
2327 :
2328 :
2329 :
2330 0 : setGroundTemperature(Parser::getTemperature("groundTemperature","CalAtmosphere",rowDoc));
2331 :
2332 :
2333 :
2334 :
2335 :
2336 :
2337 :
2338 :
2339 0 : polarizationTypes = EnumerationParser::getPolarizationType1D("polarizationTypes","CalAtmosphere",rowDoc);
2340 :
2341 :
2342 :
2343 :
2344 :
2345 :
2346 :
2347 :
2348 :
2349 0 : setPowerSkySpectrum(Parser::get2DFloat("powerSkySpectrum","CalAtmosphere",rowDoc));
2350 :
2351 :
2352 :
2353 :
2354 :
2355 :
2356 :
2357 :
2358 :
2359 0 : setPowerLoadSpectrum(Parser::get3DFloat("powerLoadSpectrum","CalAtmosphere",rowDoc));
2360 :
2361 :
2362 :
2363 :
2364 :
2365 :
2366 :
2367 :
2368 :
2369 0 : syscalType = EnumerationParser::getSyscalMethod("syscalType","CalAtmosphere",rowDoc);
2370 :
2371 :
2372 :
2373 :
2374 :
2375 :
2376 :
2377 :
2378 :
2379 0 : setTAtmSpectrum(Parser::get2DTemperature("tAtmSpectrum","CalAtmosphere",rowDoc));
2380 :
2381 :
2382 :
2383 :
2384 :
2385 :
2386 :
2387 :
2388 :
2389 0 : setTRecSpectrum(Parser::get2DTemperature("tRecSpectrum","CalAtmosphere",rowDoc));
2390 :
2391 :
2392 :
2393 :
2394 :
2395 :
2396 :
2397 :
2398 :
2399 0 : setTSysSpectrum(Parser::get2DTemperature("tSysSpectrum","CalAtmosphere",rowDoc));
2400 :
2401 :
2402 :
2403 :
2404 :
2405 :
2406 :
2407 :
2408 :
2409 0 : setTauSpectrum(Parser::get2DFloat("tauSpectrum","CalAtmosphere",rowDoc));
2410 :
2411 :
2412 :
2413 :
2414 :
2415 :
2416 :
2417 :
2418 :
2419 0 : setTAtm(Parser::get1DTemperature("tAtm","CalAtmosphere",rowDoc));
2420 :
2421 :
2422 :
2423 :
2424 :
2425 :
2426 :
2427 :
2428 :
2429 0 : setTRec(Parser::get1DTemperature("tRec","CalAtmosphere",rowDoc));
2430 :
2431 :
2432 :
2433 :
2434 :
2435 :
2436 :
2437 :
2438 :
2439 0 : setTSys(Parser::get1DTemperature("tSys","CalAtmosphere",rowDoc));
2440 :
2441 :
2442 :
2443 :
2444 :
2445 :
2446 :
2447 :
2448 :
2449 0 : setTau(Parser::get1DFloat("tau","CalAtmosphere",rowDoc));
2450 :
2451 :
2452 :
2453 :
2454 :
2455 :
2456 :
2457 :
2458 :
2459 0 : setWater(Parser::get1DLength("water","CalAtmosphere",rowDoc));
2460 :
2461 :
2462 :
2463 :
2464 :
2465 :
2466 :
2467 :
2468 :
2469 0 : setWaterError(Parser::get1DLength("waterError","CalAtmosphere",rowDoc));
2470 :
2471 :
2472 :
2473 :
2474 :
2475 :
2476 :
2477 0 : if (row.isStr("<alphaSpectrum>")) {
2478 :
2479 :
2480 0 : setAlphaSpectrum(Parser::get2DFloat("alphaSpectrum","CalAtmosphere",rowDoc));
2481 :
2482 :
2483 : }
2484 :
2485 :
2486 :
2487 :
2488 :
2489 0 : if (row.isStr("<forwardEfficiency>")) {
2490 :
2491 :
2492 0 : setForwardEfficiency(Parser::get1DFloat("forwardEfficiency","CalAtmosphere",rowDoc));
2493 :
2494 :
2495 : }
2496 :
2497 :
2498 :
2499 :
2500 :
2501 0 : if (row.isStr("<forwardEfficiencyError>")) {
2502 :
2503 :
2504 0 : setForwardEfficiencyError(Parser::get1DDouble("forwardEfficiencyError","CalAtmosphere",rowDoc));
2505 :
2506 :
2507 : }
2508 :
2509 :
2510 :
2511 :
2512 :
2513 0 : if (row.isStr("<sbGain>")) {
2514 :
2515 :
2516 0 : setSbGain(Parser::get1DFloat("sbGain","CalAtmosphere",rowDoc));
2517 :
2518 :
2519 : }
2520 :
2521 :
2522 :
2523 :
2524 :
2525 0 : if (row.isStr("<sbGainError>")) {
2526 :
2527 :
2528 0 : setSbGainError(Parser::get1DFloat("sbGainError","CalAtmosphere",rowDoc));
2529 :
2530 :
2531 : }
2532 :
2533 :
2534 :
2535 :
2536 :
2537 0 : if (row.isStr("<sbGainSpectrum>")) {
2538 :
2539 :
2540 0 : setSbGainSpectrum(Parser::get2DFloat("sbGainSpectrum","CalAtmosphere",rowDoc));
2541 :
2542 :
2543 : }
2544 :
2545 :
2546 :
2547 :
2548 :
2549 :
2550 :
2551 :
2552 :
2553 0 : setCalDataId(Parser::getTag("calDataId","CalData",rowDoc));
2554 :
2555 :
2556 :
2557 :
2558 :
2559 :
2560 :
2561 0 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
2562 :
2563 :
2564 :
2565 :
2566 :
2567 :
2568 :
2569 :
2570 :
2571 :
2572 0 : } catch (const IllegalAccessException &err) {
2573 0 : throw ConversionException (err.getMessage(),"CalAtmosphere");
2574 : }
2575 0 : }
2576 :
2577 0 : void CalAtmosphereRow::toBin(EndianOSStream& eoss) {
2578 :
2579 :
2580 :
2581 :
2582 :
2583 :
2584 0 : eoss.writeString(antennaName);
2585 :
2586 :
2587 :
2588 :
2589 :
2590 :
2591 :
2592 :
2593 0 : eoss.writeString(CReceiverBand::name(receiverBand));
2594 : /* eoss.writeInt(receiverBand); */
2595 :
2596 :
2597 :
2598 :
2599 :
2600 :
2601 :
2602 :
2603 0 : eoss.writeString(CBasebandName::name(basebandName));
2604 : /* eoss.writeInt(basebandName); */
2605 :
2606 :
2607 :
2608 :
2609 :
2610 :
2611 :
2612 0 : calDataId.toBin(eoss);
2613 :
2614 :
2615 :
2616 :
2617 :
2618 :
2619 0 : calReductionId.toBin(eoss);
2620 :
2621 :
2622 :
2623 :
2624 :
2625 :
2626 0 : startValidTime.toBin(eoss);
2627 :
2628 :
2629 :
2630 :
2631 :
2632 :
2633 0 : endValidTime.toBin(eoss);
2634 :
2635 :
2636 :
2637 :
2638 :
2639 :
2640 :
2641 0 : eoss.writeInt(numFreq);
2642 :
2643 :
2644 :
2645 :
2646 :
2647 :
2648 :
2649 :
2650 0 : eoss.writeInt(numLoad);
2651 :
2652 :
2653 :
2654 :
2655 :
2656 :
2657 :
2658 :
2659 0 : eoss.writeInt(numReceptor);
2660 :
2661 :
2662 :
2663 :
2664 :
2665 :
2666 :
2667 :
2668 :
2669 0 : eoss.writeInt((int) forwardEffSpectrum.size());
2670 0 : eoss.writeInt((int) forwardEffSpectrum.at(0).size());
2671 0 : for (unsigned int i = 0; i < forwardEffSpectrum.size(); i++)
2672 0 : for (unsigned int j = 0; j < forwardEffSpectrum.at(0).size(); j++)
2673 :
2674 0 : eoss.writeFloat(forwardEffSpectrum.at(i).at(j));
2675 :
2676 :
2677 :
2678 :
2679 :
2680 :
2681 :
2682 :
2683 :
2684 0 : Frequency::toBin(frequencyRange, eoss);
2685 :
2686 :
2687 :
2688 :
2689 :
2690 :
2691 0 : groundPressure.toBin(eoss);
2692 :
2693 :
2694 :
2695 :
2696 :
2697 :
2698 0 : groundRelHumidity.toBin(eoss);
2699 :
2700 :
2701 :
2702 :
2703 :
2704 :
2705 0 : Frequency::toBin(frequencySpectrum, eoss);
2706 :
2707 :
2708 :
2709 :
2710 :
2711 :
2712 0 : groundTemperature.toBin(eoss);
2713 :
2714 :
2715 :
2716 :
2717 :
2718 :
2719 :
2720 :
2721 0 : eoss.writeInt((int) polarizationTypes.size());
2722 0 : for (unsigned int i = 0; i < polarizationTypes.size(); i++)
2723 :
2724 0 : eoss.writeString(CPolarizationType::name(polarizationTypes.at(i)));
2725 : /* eoss.writeInt(polarizationTypes.at(i)); */
2726 :
2727 :
2728 :
2729 :
2730 :
2731 :
2732 :
2733 :
2734 :
2735 :
2736 :
2737 0 : eoss.writeInt((int) powerSkySpectrum.size());
2738 0 : eoss.writeInt((int) powerSkySpectrum.at(0).size());
2739 0 : for (unsigned int i = 0; i < powerSkySpectrum.size(); i++)
2740 0 : for (unsigned int j = 0; j < powerSkySpectrum.at(0).size(); j++)
2741 :
2742 0 : eoss.writeFloat(powerSkySpectrum.at(i).at(j));
2743 :
2744 :
2745 :
2746 :
2747 :
2748 :
2749 :
2750 :
2751 :
2752 :
2753 :
2754 0 : eoss.writeInt((int) powerLoadSpectrum.size());
2755 0 : eoss.writeInt((int) powerLoadSpectrum.at(0).size());
2756 0 : eoss.writeInt((int) powerLoadSpectrum.at(0).at(0).size());
2757 0 : for (unsigned int i = 0; i < powerLoadSpectrum.size(); i++)
2758 0 : for (unsigned int j = 0; j < powerLoadSpectrum.at(0).size(); j++)
2759 0 : for (unsigned int k = 0; k < powerLoadSpectrum.at(0).at(0).size(); k++)
2760 :
2761 0 : eoss.writeFloat(powerLoadSpectrum.at(i).at(j).at(k));
2762 :
2763 :
2764 :
2765 :
2766 :
2767 :
2768 :
2769 :
2770 :
2771 0 : eoss.writeString(CSyscalMethod::name(syscalType));
2772 : /* eoss.writeInt(syscalType); */
2773 :
2774 :
2775 :
2776 :
2777 :
2778 :
2779 :
2780 0 : Temperature::toBin(tAtmSpectrum, eoss);
2781 :
2782 :
2783 :
2784 :
2785 :
2786 :
2787 0 : Temperature::toBin(tRecSpectrum, eoss);
2788 :
2789 :
2790 :
2791 :
2792 :
2793 :
2794 0 : Temperature::toBin(tSysSpectrum, eoss);
2795 :
2796 :
2797 :
2798 :
2799 :
2800 :
2801 :
2802 :
2803 0 : eoss.writeInt((int) tauSpectrum.size());
2804 0 : eoss.writeInt((int) tauSpectrum.at(0).size());
2805 0 : for (unsigned int i = 0; i < tauSpectrum.size(); i++)
2806 0 : for (unsigned int j = 0; j < tauSpectrum.at(0).size(); j++)
2807 :
2808 0 : eoss.writeFloat(tauSpectrum.at(i).at(j));
2809 :
2810 :
2811 :
2812 :
2813 :
2814 :
2815 :
2816 :
2817 :
2818 0 : Temperature::toBin(tAtm, eoss);
2819 :
2820 :
2821 :
2822 :
2823 :
2824 :
2825 0 : Temperature::toBin(tRec, eoss);
2826 :
2827 :
2828 :
2829 :
2830 :
2831 :
2832 0 : Temperature::toBin(tSys, eoss);
2833 :
2834 :
2835 :
2836 :
2837 :
2838 :
2839 :
2840 :
2841 0 : eoss.writeInt((int) tau.size());
2842 0 : for (unsigned int i = 0; i < tau.size(); i++)
2843 :
2844 0 : eoss.writeFloat(tau.at(i));
2845 :
2846 :
2847 :
2848 :
2849 :
2850 :
2851 :
2852 :
2853 :
2854 0 : Length::toBin(water, eoss);
2855 :
2856 :
2857 :
2858 :
2859 :
2860 :
2861 0 : Length::toBin(waterError, eoss);
2862 :
2863 :
2864 :
2865 :
2866 :
2867 :
2868 0 : eoss.writeBoolean(alphaSpectrumExists);
2869 0 : if (alphaSpectrumExists) {
2870 :
2871 :
2872 :
2873 :
2874 :
2875 :
2876 0 : eoss.writeInt((int) alphaSpectrum.size());
2877 0 : eoss.writeInt((int) alphaSpectrum.at(0).size());
2878 0 : for (unsigned int i = 0; i < alphaSpectrum.size(); i++)
2879 0 : for (unsigned int j = 0; j < alphaSpectrum.at(0).size(); j++)
2880 :
2881 0 : eoss.writeFloat(alphaSpectrum.at(i).at(j));
2882 :
2883 :
2884 :
2885 :
2886 :
2887 :
2888 : }
2889 :
2890 0 : eoss.writeBoolean(forwardEfficiencyExists);
2891 0 : if (forwardEfficiencyExists) {
2892 :
2893 :
2894 :
2895 :
2896 :
2897 :
2898 0 : eoss.writeInt((int) forwardEfficiency.size());
2899 0 : for (unsigned int i = 0; i < forwardEfficiency.size(); i++)
2900 :
2901 0 : eoss.writeFloat(forwardEfficiency.at(i));
2902 :
2903 :
2904 :
2905 :
2906 :
2907 :
2908 : }
2909 :
2910 0 : eoss.writeBoolean(forwardEfficiencyErrorExists);
2911 0 : if (forwardEfficiencyErrorExists) {
2912 :
2913 :
2914 :
2915 :
2916 :
2917 :
2918 0 : eoss.writeInt((int) forwardEfficiencyError.size());
2919 0 : for (unsigned int i = 0; i < forwardEfficiencyError.size(); i++)
2920 :
2921 0 : eoss.writeDouble(forwardEfficiencyError.at(i));
2922 :
2923 :
2924 :
2925 :
2926 :
2927 :
2928 : }
2929 :
2930 0 : eoss.writeBoolean(sbGainExists);
2931 0 : if (sbGainExists) {
2932 :
2933 :
2934 :
2935 :
2936 :
2937 :
2938 0 : eoss.writeInt((int) sbGain.size());
2939 0 : for (unsigned int i = 0; i < sbGain.size(); i++)
2940 :
2941 0 : eoss.writeFloat(sbGain.at(i));
2942 :
2943 :
2944 :
2945 :
2946 :
2947 :
2948 : }
2949 :
2950 0 : eoss.writeBoolean(sbGainErrorExists);
2951 0 : if (sbGainErrorExists) {
2952 :
2953 :
2954 :
2955 :
2956 :
2957 :
2958 0 : eoss.writeInt((int) sbGainError.size());
2959 0 : for (unsigned int i = 0; i < sbGainError.size(); i++)
2960 :
2961 0 : eoss.writeFloat(sbGainError.at(i));
2962 :
2963 :
2964 :
2965 :
2966 :
2967 :
2968 : }
2969 :
2970 0 : eoss.writeBoolean(sbGainSpectrumExists);
2971 0 : if (sbGainSpectrumExists) {
2972 :
2973 :
2974 :
2975 :
2976 :
2977 :
2978 0 : eoss.writeInt((int) sbGainSpectrum.size());
2979 0 : eoss.writeInt((int) sbGainSpectrum.at(0).size());
2980 0 : for (unsigned int i = 0; i < sbGainSpectrum.size(); i++)
2981 0 : for (unsigned int j = 0; j < sbGainSpectrum.at(0).size(); j++)
2982 :
2983 0 : eoss.writeFloat(sbGainSpectrum.at(i).at(j));
2984 :
2985 :
2986 :
2987 :
2988 :
2989 :
2990 : }
2991 :
2992 0 : }
2993 :
2994 0 : void CalAtmosphereRow::antennaNameFromBin(EndianIStream& eis) {
2995 :
2996 :
2997 :
2998 :
2999 :
3000 0 : antennaName = eis.readString();
3001 :
3002 :
3003 :
3004 :
3005 0 : }
3006 0 : void CalAtmosphereRow::receiverBandFromBin(EndianIStream& eis) {
3007 :
3008 :
3009 :
3010 :
3011 :
3012 0 : receiverBand = CReceiverBand::literal(eis.readString());
3013 :
3014 :
3015 :
3016 :
3017 0 : }
3018 0 : void CalAtmosphereRow::basebandNameFromBin(EndianIStream& eis) {
3019 :
3020 :
3021 :
3022 :
3023 :
3024 0 : basebandName = CBasebandName::literal(eis.readString());
3025 :
3026 :
3027 :
3028 :
3029 0 : }
3030 0 : void CalAtmosphereRow::calDataIdFromBin(EndianIStream& eis) {
3031 :
3032 :
3033 :
3034 :
3035 0 : calDataId = Tag::fromBin(eis);
3036 :
3037 :
3038 :
3039 0 : }
3040 0 : void CalAtmosphereRow::calReductionIdFromBin(EndianIStream& eis) {
3041 :
3042 :
3043 :
3044 :
3045 0 : calReductionId = Tag::fromBin(eis);
3046 :
3047 :
3048 :
3049 0 : }
3050 0 : void CalAtmosphereRow::startValidTimeFromBin(EndianIStream& eis) {
3051 :
3052 :
3053 :
3054 :
3055 0 : startValidTime = ArrayTime::fromBin(eis);
3056 :
3057 :
3058 :
3059 0 : }
3060 0 : void CalAtmosphereRow::endValidTimeFromBin(EndianIStream& eis) {
3061 :
3062 :
3063 :
3064 :
3065 0 : endValidTime = ArrayTime::fromBin(eis);
3066 :
3067 :
3068 :
3069 0 : }
3070 0 : void CalAtmosphereRow::numFreqFromBin(EndianIStream& eis) {
3071 :
3072 :
3073 :
3074 :
3075 :
3076 0 : numFreq = eis.readInt();
3077 :
3078 :
3079 :
3080 :
3081 0 : }
3082 0 : void CalAtmosphereRow::numLoadFromBin(EndianIStream& eis) {
3083 :
3084 :
3085 :
3086 :
3087 :
3088 0 : numLoad = eis.readInt();
3089 :
3090 :
3091 :
3092 :
3093 0 : }
3094 0 : void CalAtmosphereRow::numReceptorFromBin(EndianIStream& eis) {
3095 :
3096 :
3097 :
3098 :
3099 :
3100 0 : numReceptor = eis.readInt();
3101 :
3102 :
3103 :
3104 :
3105 0 : }
3106 0 : void CalAtmosphereRow::forwardEffSpectrumFromBin(EndianIStream& eis) {
3107 :
3108 :
3109 :
3110 :
3111 :
3112 :
3113 0 : forwardEffSpectrum.clear();
3114 :
3115 0 : unsigned int forwardEffSpectrumDim1 = eis.readInt();
3116 0 : unsigned int forwardEffSpectrumDim2 = eis.readInt();
3117 :
3118 0 : vector <float> forwardEffSpectrumAux1;
3119 :
3120 0 : for (unsigned int i = 0; i < forwardEffSpectrumDim1; i++) {
3121 0 : forwardEffSpectrumAux1.clear();
3122 0 : for (unsigned int j = 0; j < forwardEffSpectrumDim2 ; j++)
3123 :
3124 0 : forwardEffSpectrumAux1.push_back(eis.readFloat());
3125 :
3126 0 : forwardEffSpectrum.push_back(forwardEffSpectrumAux1);
3127 : }
3128 :
3129 :
3130 :
3131 :
3132 :
3133 :
3134 0 : }
3135 0 : void CalAtmosphereRow::frequencyRangeFromBin(EndianIStream& eis) {
3136 :
3137 :
3138 :
3139 :
3140 :
3141 :
3142 0 : frequencyRange = Frequency::from1DBin(eis);
3143 :
3144 :
3145 :
3146 :
3147 :
3148 0 : }
3149 0 : void CalAtmosphereRow::groundPressureFromBin(EndianIStream& eis) {
3150 :
3151 :
3152 :
3153 :
3154 0 : groundPressure = Pressure::fromBin(eis);
3155 :
3156 :
3157 :
3158 0 : }
3159 0 : void CalAtmosphereRow::groundRelHumidityFromBin(EndianIStream& eis) {
3160 :
3161 :
3162 :
3163 :
3164 0 : groundRelHumidity = Humidity::fromBin(eis);
3165 :
3166 :
3167 :
3168 0 : }
3169 0 : void CalAtmosphereRow::frequencySpectrumFromBin(EndianIStream& eis) {
3170 :
3171 :
3172 :
3173 :
3174 :
3175 :
3176 0 : frequencySpectrum = Frequency::from1DBin(eis);
3177 :
3178 :
3179 :
3180 :
3181 :
3182 0 : }
3183 0 : void CalAtmosphereRow::groundTemperatureFromBin(EndianIStream& eis) {
3184 :
3185 :
3186 :
3187 :
3188 0 : groundTemperature = Temperature::fromBin(eis);
3189 :
3190 :
3191 :
3192 0 : }
3193 0 : void CalAtmosphereRow::polarizationTypesFromBin(EndianIStream& eis) {
3194 :
3195 :
3196 :
3197 :
3198 :
3199 :
3200 0 : polarizationTypes.clear();
3201 :
3202 0 : unsigned int polarizationTypesDim1 = eis.readInt();
3203 0 : for (unsigned int i = 0 ; i < polarizationTypesDim1; i++)
3204 :
3205 0 : polarizationTypes.push_back(CPolarizationType::literal(eis.readString()));
3206 :
3207 :
3208 :
3209 :
3210 :
3211 :
3212 0 : }
3213 0 : void CalAtmosphereRow::powerSkySpectrumFromBin(EndianIStream& eis) {
3214 :
3215 :
3216 :
3217 :
3218 :
3219 :
3220 0 : powerSkySpectrum.clear();
3221 :
3222 0 : unsigned int powerSkySpectrumDim1 = eis.readInt();
3223 0 : unsigned int powerSkySpectrumDim2 = eis.readInt();
3224 :
3225 0 : vector <float> powerSkySpectrumAux1;
3226 :
3227 0 : for (unsigned int i = 0; i < powerSkySpectrumDim1; i++) {
3228 0 : powerSkySpectrumAux1.clear();
3229 0 : for (unsigned int j = 0; j < powerSkySpectrumDim2 ; j++)
3230 :
3231 0 : powerSkySpectrumAux1.push_back(eis.readFloat());
3232 :
3233 0 : powerSkySpectrum.push_back(powerSkySpectrumAux1);
3234 : }
3235 :
3236 :
3237 :
3238 :
3239 :
3240 :
3241 0 : }
3242 0 : void CalAtmosphereRow::powerLoadSpectrumFromBin(EndianIStream& eis) {
3243 :
3244 :
3245 :
3246 :
3247 :
3248 :
3249 0 : powerLoadSpectrum.clear();
3250 :
3251 0 : unsigned int powerLoadSpectrumDim1 = eis.readInt();
3252 0 : unsigned int powerLoadSpectrumDim2 = eis.readInt();
3253 0 : unsigned int powerLoadSpectrumDim3 = eis.readInt();
3254 0 : vector <vector<float> > powerLoadSpectrumAux2;
3255 0 : vector <float> powerLoadSpectrumAux1;
3256 0 : for (unsigned int i = 0; i < powerLoadSpectrumDim1; i++) {
3257 0 : powerLoadSpectrumAux2.clear();
3258 0 : for (unsigned int j = 0; j < powerLoadSpectrumDim2 ; j++) {
3259 0 : powerLoadSpectrumAux1.clear();
3260 0 : for (unsigned int k = 0; k < powerLoadSpectrumDim3; k++) {
3261 :
3262 0 : powerLoadSpectrumAux1.push_back(eis.readFloat());
3263 :
3264 : }
3265 0 : powerLoadSpectrumAux2.push_back(powerLoadSpectrumAux1);
3266 : }
3267 0 : powerLoadSpectrum.push_back(powerLoadSpectrumAux2);
3268 : }
3269 :
3270 :
3271 :
3272 :
3273 :
3274 0 : }
3275 0 : void CalAtmosphereRow::syscalTypeFromBin(EndianIStream& eis) {
3276 :
3277 :
3278 :
3279 :
3280 :
3281 0 : syscalType = CSyscalMethod::literal(eis.readString());
3282 :
3283 :
3284 :
3285 :
3286 0 : }
3287 0 : void CalAtmosphereRow::tAtmSpectrumFromBin(EndianIStream& eis) {
3288 :
3289 :
3290 :
3291 :
3292 :
3293 :
3294 0 : tAtmSpectrum = Temperature::from2DBin(eis);
3295 :
3296 :
3297 :
3298 :
3299 :
3300 0 : }
3301 0 : void CalAtmosphereRow::tRecSpectrumFromBin(EndianIStream& eis) {
3302 :
3303 :
3304 :
3305 :
3306 :
3307 :
3308 0 : tRecSpectrum = Temperature::from2DBin(eis);
3309 :
3310 :
3311 :
3312 :
3313 :
3314 0 : }
3315 0 : void CalAtmosphereRow::tSysSpectrumFromBin(EndianIStream& eis) {
3316 :
3317 :
3318 :
3319 :
3320 :
3321 :
3322 0 : tSysSpectrum = Temperature::from2DBin(eis);
3323 :
3324 :
3325 :
3326 :
3327 :
3328 0 : }
3329 0 : void CalAtmosphereRow::tauSpectrumFromBin(EndianIStream& eis) {
3330 :
3331 :
3332 :
3333 :
3334 :
3335 :
3336 0 : tauSpectrum.clear();
3337 :
3338 0 : unsigned int tauSpectrumDim1 = eis.readInt();
3339 0 : unsigned int tauSpectrumDim2 = eis.readInt();
3340 :
3341 0 : vector <float> tauSpectrumAux1;
3342 :
3343 0 : for (unsigned int i = 0; i < tauSpectrumDim1; i++) {
3344 0 : tauSpectrumAux1.clear();
3345 0 : for (unsigned int j = 0; j < tauSpectrumDim2 ; j++)
3346 :
3347 0 : tauSpectrumAux1.push_back(eis.readFloat());
3348 :
3349 0 : tauSpectrum.push_back(tauSpectrumAux1);
3350 : }
3351 :
3352 :
3353 :
3354 :
3355 :
3356 :
3357 0 : }
3358 0 : void CalAtmosphereRow::tAtmFromBin(EndianIStream& eis) {
3359 :
3360 :
3361 :
3362 :
3363 :
3364 :
3365 0 : tAtm = Temperature::from1DBin(eis);
3366 :
3367 :
3368 :
3369 :
3370 :
3371 0 : }
3372 0 : void CalAtmosphereRow::tRecFromBin(EndianIStream& eis) {
3373 :
3374 :
3375 :
3376 :
3377 :
3378 :
3379 0 : tRec = Temperature::from1DBin(eis);
3380 :
3381 :
3382 :
3383 :
3384 :
3385 0 : }
3386 0 : void CalAtmosphereRow::tSysFromBin(EndianIStream& eis) {
3387 :
3388 :
3389 :
3390 :
3391 :
3392 :
3393 0 : tSys = Temperature::from1DBin(eis);
3394 :
3395 :
3396 :
3397 :
3398 :
3399 0 : }
3400 0 : void CalAtmosphereRow::tauFromBin(EndianIStream& eis) {
3401 :
3402 :
3403 :
3404 :
3405 :
3406 :
3407 0 : tau.clear();
3408 :
3409 0 : unsigned int tauDim1 = eis.readInt();
3410 0 : for (unsigned int i = 0 ; i < tauDim1; i++)
3411 :
3412 0 : tau.push_back(eis.readFloat());
3413 :
3414 :
3415 :
3416 :
3417 :
3418 :
3419 0 : }
3420 0 : void CalAtmosphereRow::waterFromBin(EndianIStream& eis) {
3421 :
3422 :
3423 :
3424 :
3425 :
3426 :
3427 0 : water = Length::from1DBin(eis);
3428 :
3429 :
3430 :
3431 :
3432 :
3433 0 : }
3434 0 : void CalAtmosphereRow::waterErrorFromBin(EndianIStream& eis) {
3435 :
3436 :
3437 :
3438 :
3439 :
3440 :
3441 0 : waterError = Length::from1DBin(eis);
3442 :
3443 :
3444 :
3445 :
3446 :
3447 0 : }
3448 :
3449 0 : void CalAtmosphereRow::alphaSpectrumFromBin(EndianIStream& eis) {
3450 :
3451 0 : alphaSpectrumExists = eis.readBoolean();
3452 0 : if (alphaSpectrumExists) {
3453 :
3454 :
3455 :
3456 :
3457 :
3458 :
3459 0 : alphaSpectrum.clear();
3460 :
3461 0 : unsigned int alphaSpectrumDim1 = eis.readInt();
3462 0 : unsigned int alphaSpectrumDim2 = eis.readInt();
3463 :
3464 0 : vector <float> alphaSpectrumAux1;
3465 :
3466 0 : for (unsigned int i = 0; i < alphaSpectrumDim1; i++) {
3467 0 : alphaSpectrumAux1.clear();
3468 0 : for (unsigned int j = 0; j < alphaSpectrumDim2 ; j++)
3469 :
3470 0 : alphaSpectrumAux1.push_back(eis.readFloat());
3471 :
3472 0 : alphaSpectrum.push_back(alphaSpectrumAux1);
3473 : }
3474 :
3475 :
3476 :
3477 :
3478 :
3479 :
3480 : }
3481 :
3482 0 : }
3483 0 : void CalAtmosphereRow::forwardEfficiencyFromBin(EndianIStream& eis) {
3484 :
3485 0 : forwardEfficiencyExists = eis.readBoolean();
3486 0 : if (forwardEfficiencyExists) {
3487 :
3488 :
3489 :
3490 :
3491 :
3492 :
3493 0 : forwardEfficiency.clear();
3494 :
3495 0 : unsigned int forwardEfficiencyDim1 = eis.readInt();
3496 0 : for (unsigned int i = 0 ; i < forwardEfficiencyDim1; i++)
3497 :
3498 0 : forwardEfficiency.push_back(eis.readFloat());
3499 :
3500 :
3501 :
3502 :
3503 :
3504 :
3505 : }
3506 :
3507 0 : }
3508 0 : void CalAtmosphereRow::forwardEfficiencyErrorFromBin(EndianIStream& eis) {
3509 :
3510 0 : forwardEfficiencyErrorExists = eis.readBoolean();
3511 0 : if (forwardEfficiencyErrorExists) {
3512 :
3513 :
3514 :
3515 :
3516 :
3517 :
3518 0 : forwardEfficiencyError.clear();
3519 :
3520 0 : unsigned int forwardEfficiencyErrorDim1 = eis.readInt();
3521 0 : for (unsigned int i = 0 ; i < forwardEfficiencyErrorDim1; i++)
3522 :
3523 0 : forwardEfficiencyError.push_back(eis.readDouble());
3524 :
3525 :
3526 :
3527 :
3528 :
3529 :
3530 : }
3531 :
3532 0 : }
3533 0 : void CalAtmosphereRow::sbGainFromBin(EndianIStream& eis) {
3534 :
3535 0 : sbGainExists = eis.readBoolean();
3536 0 : if (sbGainExists) {
3537 :
3538 :
3539 :
3540 :
3541 :
3542 :
3543 0 : sbGain.clear();
3544 :
3545 0 : unsigned int sbGainDim1 = eis.readInt();
3546 0 : for (unsigned int i = 0 ; i < sbGainDim1; i++)
3547 :
3548 0 : sbGain.push_back(eis.readFloat());
3549 :
3550 :
3551 :
3552 :
3553 :
3554 :
3555 : }
3556 :
3557 0 : }
3558 0 : void CalAtmosphereRow::sbGainErrorFromBin(EndianIStream& eis) {
3559 :
3560 0 : sbGainErrorExists = eis.readBoolean();
3561 0 : if (sbGainErrorExists) {
3562 :
3563 :
3564 :
3565 :
3566 :
3567 :
3568 0 : sbGainError.clear();
3569 :
3570 0 : unsigned int sbGainErrorDim1 = eis.readInt();
3571 0 : for (unsigned int i = 0 ; i < sbGainErrorDim1; i++)
3572 :
3573 0 : sbGainError.push_back(eis.readFloat());
3574 :
3575 :
3576 :
3577 :
3578 :
3579 :
3580 : }
3581 :
3582 0 : }
3583 0 : void CalAtmosphereRow::sbGainSpectrumFromBin(EndianIStream& eis) {
3584 :
3585 0 : sbGainSpectrumExists = eis.readBoolean();
3586 0 : if (sbGainSpectrumExists) {
3587 :
3588 :
3589 :
3590 :
3591 :
3592 :
3593 0 : sbGainSpectrum.clear();
3594 :
3595 0 : unsigned int sbGainSpectrumDim1 = eis.readInt();
3596 0 : unsigned int sbGainSpectrumDim2 = eis.readInt();
3597 :
3598 0 : vector <float> sbGainSpectrumAux1;
3599 :
3600 0 : for (unsigned int i = 0; i < sbGainSpectrumDim1; i++) {
3601 0 : sbGainSpectrumAux1.clear();
3602 0 : for (unsigned int j = 0; j < sbGainSpectrumDim2 ; j++)
3603 :
3604 0 : sbGainSpectrumAux1.push_back(eis.readFloat());
3605 :
3606 0 : sbGainSpectrum.push_back(sbGainSpectrumAux1);
3607 : }
3608 :
3609 :
3610 :
3611 :
3612 :
3613 :
3614 : }
3615 :
3616 0 : }
3617 :
3618 :
3619 0 : CalAtmosphereRow* CalAtmosphereRow::fromBin(EndianIStream& eis, CalAtmosphereTable& table, const vector<string>& attributesSeq) {
3620 0 : CalAtmosphereRow* row = new CalAtmosphereRow(table);
3621 :
3622 0 : map<string, CalAtmosphereAttributeFromBin>::iterator iter ;
3623 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
3624 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
3625 0 : if (iter != row->fromBinMethods.end()) {
3626 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
3627 : }
3628 : else {
3629 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
3630 0 : if (functorP)
3631 0 : (*functorP)(eis);
3632 : else
3633 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalAtmosphereTable");
3634 : }
3635 :
3636 : }
3637 0 : return row;
3638 : }
3639 :
3640 : //
3641 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
3642 : // of one row.
3643 : //
3644 :
3645 : // Convert a string into an String
3646 0 : void CalAtmosphereRow::antennaNameFromText(const string & s) {
3647 :
3648 :
3649 0 : antennaName = ASDMValuesParser::parse<string>(s);
3650 :
3651 :
3652 0 : }
3653 :
3654 :
3655 : // Convert a string into an ReceiverBand
3656 0 : void CalAtmosphereRow::receiverBandFromText(const string & s) {
3657 :
3658 :
3659 0 : receiverBand = ASDMValuesParser::parse<ReceiverBandMod::ReceiverBand>(s);
3660 :
3661 :
3662 0 : }
3663 :
3664 :
3665 : // Convert a string into an BasebandName
3666 0 : void CalAtmosphereRow::basebandNameFromText(const string & s) {
3667 :
3668 :
3669 0 : basebandName = ASDMValuesParser::parse<BasebandNameMod::BasebandName>(s);
3670 :
3671 :
3672 0 : }
3673 :
3674 :
3675 : // Convert a string into an Tag
3676 0 : void CalAtmosphereRow::calDataIdFromText(const string & s) {
3677 :
3678 :
3679 0 : calDataId = ASDMValuesParser::parse<Tag>(s);
3680 :
3681 :
3682 0 : }
3683 :
3684 :
3685 : // Convert a string into an Tag
3686 0 : void CalAtmosphereRow::calReductionIdFromText(const string & s) {
3687 :
3688 :
3689 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
3690 :
3691 :
3692 0 : }
3693 :
3694 :
3695 : // Convert a string into an ArrayTime
3696 0 : void CalAtmosphereRow::startValidTimeFromText(const string & s) {
3697 :
3698 :
3699 0 : startValidTime = ASDMValuesParser::parse<ArrayTime>(s);
3700 :
3701 :
3702 0 : }
3703 :
3704 :
3705 : // Convert a string into an ArrayTime
3706 0 : void CalAtmosphereRow::endValidTimeFromText(const string & s) {
3707 :
3708 :
3709 0 : endValidTime = ASDMValuesParser::parse<ArrayTime>(s);
3710 :
3711 :
3712 0 : }
3713 :
3714 :
3715 : // Convert a string into an int
3716 0 : void CalAtmosphereRow::numFreqFromText(const string & s) {
3717 :
3718 :
3719 0 : numFreq = ASDMValuesParser::parse<int>(s);
3720 :
3721 :
3722 0 : }
3723 :
3724 :
3725 : // Convert a string into an int
3726 0 : void CalAtmosphereRow::numLoadFromText(const string & s) {
3727 :
3728 :
3729 0 : numLoad = ASDMValuesParser::parse<int>(s);
3730 :
3731 :
3732 0 : }
3733 :
3734 :
3735 : // Convert a string into an int
3736 0 : void CalAtmosphereRow::numReceptorFromText(const string & s) {
3737 :
3738 :
3739 0 : numReceptor = ASDMValuesParser::parse<int>(s);
3740 :
3741 :
3742 0 : }
3743 :
3744 :
3745 : // Convert a string into an float
3746 0 : void CalAtmosphereRow::forwardEffSpectrumFromText(const string & s) {
3747 :
3748 :
3749 0 : forwardEffSpectrum = ASDMValuesParser::parse2D<float>(s);
3750 :
3751 :
3752 0 : }
3753 :
3754 :
3755 : // Convert a string into an Frequency
3756 0 : void CalAtmosphereRow::frequencyRangeFromText(const string & s) {
3757 :
3758 :
3759 0 : frequencyRange = ASDMValuesParser::parse1D<Frequency>(s);
3760 :
3761 :
3762 0 : }
3763 :
3764 :
3765 : // Convert a string into an Pressure
3766 0 : void CalAtmosphereRow::groundPressureFromText(const string & s) {
3767 :
3768 :
3769 0 : groundPressure = ASDMValuesParser::parse<Pressure>(s);
3770 :
3771 :
3772 0 : }
3773 :
3774 :
3775 : // Convert a string into an Humidity
3776 0 : void CalAtmosphereRow::groundRelHumidityFromText(const string & s) {
3777 :
3778 :
3779 0 : groundRelHumidity = ASDMValuesParser::parse<Humidity>(s);
3780 :
3781 :
3782 0 : }
3783 :
3784 :
3785 : // Convert a string into an Frequency
3786 0 : void CalAtmosphereRow::frequencySpectrumFromText(const string & s) {
3787 :
3788 :
3789 0 : frequencySpectrum = ASDMValuesParser::parse1D<Frequency>(s);
3790 :
3791 :
3792 0 : }
3793 :
3794 :
3795 : // Convert a string into an Temperature
3796 0 : void CalAtmosphereRow::groundTemperatureFromText(const string & s) {
3797 :
3798 :
3799 0 : groundTemperature = ASDMValuesParser::parse<Temperature>(s);
3800 :
3801 :
3802 0 : }
3803 :
3804 :
3805 : // Convert a string into an PolarizationType
3806 0 : void CalAtmosphereRow::polarizationTypesFromText(const string & s) {
3807 :
3808 :
3809 0 : polarizationTypes = ASDMValuesParser::parse1D<PolarizationTypeMod::PolarizationType>(s);
3810 :
3811 :
3812 0 : }
3813 :
3814 :
3815 : // Convert a string into an float
3816 0 : void CalAtmosphereRow::powerSkySpectrumFromText(const string & s) {
3817 :
3818 :
3819 0 : powerSkySpectrum = ASDMValuesParser::parse2D<float>(s);
3820 :
3821 :
3822 0 : }
3823 :
3824 :
3825 : // Convert a string into an float
3826 0 : void CalAtmosphereRow::powerLoadSpectrumFromText(const string & s) {
3827 :
3828 :
3829 0 : powerLoadSpectrum = ASDMValuesParser::parse3D<float>(s);
3830 :
3831 :
3832 0 : }
3833 :
3834 :
3835 : // Convert a string into an SyscalMethod
3836 0 : void CalAtmosphereRow::syscalTypeFromText(const string & s) {
3837 :
3838 :
3839 0 : syscalType = ASDMValuesParser::parse<SyscalMethodMod::SyscalMethod>(s);
3840 :
3841 :
3842 0 : }
3843 :
3844 :
3845 : // Convert a string into an Temperature
3846 0 : void CalAtmosphereRow::tAtmSpectrumFromText(const string & s) {
3847 :
3848 :
3849 0 : tAtmSpectrum = ASDMValuesParser::parse2D<Temperature>(s);
3850 :
3851 :
3852 0 : }
3853 :
3854 :
3855 : // Convert a string into an Temperature
3856 0 : void CalAtmosphereRow::tRecSpectrumFromText(const string & s) {
3857 :
3858 :
3859 0 : tRecSpectrum = ASDMValuesParser::parse2D<Temperature>(s);
3860 :
3861 :
3862 0 : }
3863 :
3864 :
3865 : // Convert a string into an Temperature
3866 0 : void CalAtmosphereRow::tSysSpectrumFromText(const string & s) {
3867 :
3868 :
3869 0 : tSysSpectrum = ASDMValuesParser::parse2D<Temperature>(s);
3870 :
3871 :
3872 0 : }
3873 :
3874 :
3875 : // Convert a string into an float
3876 0 : void CalAtmosphereRow::tauSpectrumFromText(const string & s) {
3877 :
3878 :
3879 0 : tauSpectrum = ASDMValuesParser::parse2D<float>(s);
3880 :
3881 :
3882 0 : }
3883 :
3884 :
3885 : // Convert a string into an Temperature
3886 0 : void CalAtmosphereRow::tAtmFromText(const string & s) {
3887 :
3888 :
3889 0 : tAtm = ASDMValuesParser::parse1D<Temperature>(s);
3890 :
3891 :
3892 0 : }
3893 :
3894 :
3895 : // Convert a string into an Temperature
3896 0 : void CalAtmosphereRow::tRecFromText(const string & s) {
3897 :
3898 :
3899 0 : tRec = ASDMValuesParser::parse1D<Temperature>(s);
3900 :
3901 :
3902 0 : }
3903 :
3904 :
3905 : // Convert a string into an Temperature
3906 0 : void CalAtmosphereRow::tSysFromText(const string & s) {
3907 :
3908 :
3909 0 : tSys = ASDMValuesParser::parse1D<Temperature>(s);
3910 :
3911 :
3912 0 : }
3913 :
3914 :
3915 : // Convert a string into an float
3916 0 : void CalAtmosphereRow::tauFromText(const string & s) {
3917 :
3918 :
3919 0 : tau = ASDMValuesParser::parse1D<float>(s);
3920 :
3921 :
3922 0 : }
3923 :
3924 :
3925 : // Convert a string into an Length
3926 0 : void CalAtmosphereRow::waterFromText(const string & s) {
3927 :
3928 :
3929 0 : water = ASDMValuesParser::parse1D<Length>(s);
3930 :
3931 :
3932 0 : }
3933 :
3934 :
3935 : // Convert a string into an Length
3936 0 : void CalAtmosphereRow::waterErrorFromText(const string & s) {
3937 :
3938 :
3939 0 : waterError = ASDMValuesParser::parse1D<Length>(s);
3940 :
3941 :
3942 0 : }
3943 :
3944 :
3945 :
3946 : // Convert a string into an float
3947 0 : void CalAtmosphereRow::alphaSpectrumFromText(const string & s) {
3948 0 : alphaSpectrumExists = true;
3949 :
3950 :
3951 0 : alphaSpectrum = ASDMValuesParser::parse2D<float>(s);
3952 :
3953 :
3954 0 : }
3955 :
3956 :
3957 : // Convert a string into an float
3958 0 : void CalAtmosphereRow::forwardEfficiencyFromText(const string & s) {
3959 0 : forwardEfficiencyExists = true;
3960 :
3961 :
3962 0 : forwardEfficiency = ASDMValuesParser::parse1D<float>(s);
3963 :
3964 :
3965 0 : }
3966 :
3967 :
3968 : // Convert a string into an double
3969 0 : void CalAtmosphereRow::forwardEfficiencyErrorFromText(const string & s) {
3970 0 : forwardEfficiencyErrorExists = true;
3971 :
3972 :
3973 0 : forwardEfficiencyError = ASDMValuesParser::parse1D<double>(s);
3974 :
3975 :
3976 0 : }
3977 :
3978 :
3979 : // Convert a string into an float
3980 0 : void CalAtmosphereRow::sbGainFromText(const string & s) {
3981 0 : sbGainExists = true;
3982 :
3983 :
3984 0 : sbGain = ASDMValuesParser::parse1D<float>(s);
3985 :
3986 :
3987 0 : }
3988 :
3989 :
3990 : // Convert a string into an float
3991 0 : void CalAtmosphereRow::sbGainErrorFromText(const string & s) {
3992 0 : sbGainErrorExists = true;
3993 :
3994 :
3995 0 : sbGainError = ASDMValuesParser::parse1D<float>(s);
3996 :
3997 :
3998 0 : }
3999 :
4000 :
4001 : // Convert a string into an float
4002 0 : void CalAtmosphereRow::sbGainSpectrumFromText(const string & s) {
4003 0 : sbGainSpectrumExists = true;
4004 :
4005 :
4006 0 : sbGainSpectrum = ASDMValuesParser::parse2D<float>(s);
4007 :
4008 :
4009 0 : }
4010 :
4011 :
4012 :
4013 0 : void CalAtmosphereRow::fromText(const std::string& attributeName, const std::string& t) {
4014 0 : map<string, CalAtmosphereAttributeFromText>::iterator iter;
4015 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
4016 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalAtmosphereTable");
4017 0 : (this->*(iter->second))(t);
4018 0 : }
4019 :
4020 : ////////////////////////////////////////////////
4021 : // Intrinsic Table Attributes getters/setters //
4022 : ////////////////////////////////////////////////
4023 :
4024 :
4025 :
4026 :
4027 : /**
4028 : * Get receiverBand.
4029 : * @return receiverBand as ReceiverBandMod::ReceiverBand
4030 : */
4031 0 : ReceiverBandMod::ReceiverBand CalAtmosphereRow::getReceiverBand() const {
4032 :
4033 0 : return receiverBand;
4034 : }
4035 :
4036 : /**
4037 : * Set receiverBand with the specified ReceiverBandMod::ReceiverBand.
4038 : * @param receiverBand The ReceiverBandMod::ReceiverBand value to which receiverBand is to be set.
4039 :
4040 :
4041 :
4042 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4043 :
4044 : */
4045 0 : void CalAtmosphereRow::setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand) {
4046 :
4047 :
4048 0 : if (hasBeenAdded) {
4049 :
4050 0 : throw IllegalAccessException("receiverBand", "CalAtmosphere");
4051 :
4052 : }
4053 :
4054 0 : this->receiverBand = receiverBand;
4055 :
4056 0 : }
4057 :
4058 :
4059 :
4060 :
4061 :
4062 :
4063 : /**
4064 : * Get antennaName.
4065 : * @return antennaName as std::string
4066 : */
4067 0 : std::string CalAtmosphereRow::getAntennaName() const {
4068 :
4069 0 : return antennaName;
4070 : }
4071 :
4072 : /**
4073 : * Set antennaName with the specified std::string.
4074 : * @param antennaName The std::string value to which antennaName is to be set.
4075 :
4076 :
4077 :
4078 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4079 :
4080 : */
4081 0 : void CalAtmosphereRow::setAntennaName (std::string antennaName) {
4082 :
4083 :
4084 0 : if (hasBeenAdded) {
4085 :
4086 0 : throw IllegalAccessException("antennaName", "CalAtmosphere");
4087 :
4088 : }
4089 :
4090 0 : this->antennaName = antennaName;
4091 :
4092 0 : }
4093 :
4094 :
4095 :
4096 :
4097 :
4098 :
4099 : /**
4100 : * Get basebandName.
4101 : * @return basebandName as BasebandNameMod::BasebandName
4102 : */
4103 0 : BasebandNameMod::BasebandName CalAtmosphereRow::getBasebandName() const {
4104 :
4105 0 : return basebandName;
4106 : }
4107 :
4108 : /**
4109 : * Set basebandName with the specified BasebandNameMod::BasebandName.
4110 : * @param basebandName The BasebandNameMod::BasebandName value to which basebandName is to be set.
4111 :
4112 :
4113 :
4114 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4115 :
4116 : */
4117 0 : void CalAtmosphereRow::setBasebandName (BasebandNameMod::BasebandName basebandName) {
4118 :
4119 :
4120 0 : if (hasBeenAdded) {
4121 :
4122 0 : throw IllegalAccessException("basebandName", "CalAtmosphere");
4123 :
4124 : }
4125 :
4126 0 : this->basebandName = basebandName;
4127 :
4128 0 : }
4129 :
4130 :
4131 :
4132 :
4133 :
4134 :
4135 : /**
4136 : * Get startValidTime.
4137 : * @return startValidTime as ArrayTime
4138 : */
4139 0 : ArrayTime CalAtmosphereRow::getStartValidTime() const {
4140 :
4141 0 : return startValidTime;
4142 : }
4143 :
4144 : /**
4145 : * Set startValidTime with the specified ArrayTime.
4146 : * @param startValidTime The ArrayTime value to which startValidTime is to be set.
4147 :
4148 :
4149 :
4150 : */
4151 0 : void CalAtmosphereRow::setStartValidTime (ArrayTime startValidTime) {
4152 :
4153 :
4154 0 : if (hasBeenAdded) {
4155 :
4156 : }
4157 :
4158 0 : this->startValidTime = startValidTime;
4159 :
4160 0 : }
4161 :
4162 :
4163 :
4164 :
4165 :
4166 :
4167 : /**
4168 : * Get endValidTime.
4169 : * @return endValidTime as ArrayTime
4170 : */
4171 0 : ArrayTime CalAtmosphereRow::getEndValidTime() const {
4172 :
4173 0 : return endValidTime;
4174 : }
4175 :
4176 : /**
4177 : * Set endValidTime with the specified ArrayTime.
4178 : * @param endValidTime The ArrayTime value to which endValidTime is to be set.
4179 :
4180 :
4181 :
4182 : */
4183 0 : void CalAtmosphereRow::setEndValidTime (ArrayTime endValidTime) {
4184 :
4185 :
4186 0 : if (hasBeenAdded) {
4187 :
4188 : }
4189 :
4190 0 : this->endValidTime = endValidTime;
4191 :
4192 0 : }
4193 :
4194 :
4195 :
4196 :
4197 :
4198 :
4199 : /**
4200 : * Get numFreq.
4201 : * @return numFreq as int
4202 : */
4203 0 : int CalAtmosphereRow::getNumFreq() const {
4204 :
4205 0 : return numFreq;
4206 : }
4207 :
4208 : /**
4209 : * Set numFreq with the specified int.
4210 : * @param numFreq The int value to which numFreq is to be set.
4211 :
4212 :
4213 :
4214 : */
4215 0 : void CalAtmosphereRow::setNumFreq (int numFreq) {
4216 :
4217 :
4218 0 : if (hasBeenAdded) {
4219 :
4220 : }
4221 :
4222 0 : this->numFreq = numFreq;
4223 :
4224 0 : }
4225 :
4226 :
4227 :
4228 :
4229 :
4230 :
4231 : /**
4232 : * Get numLoad.
4233 : * @return numLoad as int
4234 : */
4235 0 : int CalAtmosphereRow::getNumLoad() const {
4236 :
4237 0 : return numLoad;
4238 : }
4239 :
4240 : /**
4241 : * Set numLoad with the specified int.
4242 : * @param numLoad The int value to which numLoad is to be set.
4243 :
4244 :
4245 :
4246 : */
4247 0 : void CalAtmosphereRow::setNumLoad (int numLoad) {
4248 :
4249 :
4250 0 : if (hasBeenAdded) {
4251 :
4252 : }
4253 :
4254 0 : this->numLoad = numLoad;
4255 :
4256 0 : }
4257 :
4258 :
4259 :
4260 :
4261 :
4262 :
4263 : /**
4264 : * Get numReceptor.
4265 : * @return numReceptor as int
4266 : */
4267 0 : int CalAtmosphereRow::getNumReceptor() const {
4268 :
4269 0 : return numReceptor;
4270 : }
4271 :
4272 : /**
4273 : * Set numReceptor with the specified int.
4274 : * @param numReceptor The int value to which numReceptor is to be set.
4275 :
4276 :
4277 :
4278 : */
4279 0 : void CalAtmosphereRow::setNumReceptor (int numReceptor) {
4280 :
4281 :
4282 0 : if (hasBeenAdded) {
4283 :
4284 : }
4285 :
4286 0 : this->numReceptor = numReceptor;
4287 :
4288 0 : }
4289 :
4290 :
4291 :
4292 :
4293 :
4294 :
4295 : /**
4296 : * Get forwardEffSpectrum.
4297 : * @return forwardEffSpectrum as std::vector<std::vector<float > >
4298 : */
4299 0 : std::vector<std::vector<float > > CalAtmosphereRow::getForwardEffSpectrum() const {
4300 :
4301 0 : return forwardEffSpectrum;
4302 : }
4303 :
4304 : /**
4305 : * Set forwardEffSpectrum with the specified std::vector<std::vector<float > >.
4306 : * @param forwardEffSpectrum The std::vector<std::vector<float > > value to which forwardEffSpectrum is to be set.
4307 :
4308 :
4309 :
4310 : */
4311 0 : void CalAtmosphereRow::setForwardEffSpectrum (std::vector<std::vector<float > > forwardEffSpectrum) {
4312 :
4313 :
4314 0 : if (hasBeenAdded) {
4315 :
4316 : }
4317 :
4318 0 : this->forwardEffSpectrum = forwardEffSpectrum;
4319 :
4320 0 : }
4321 :
4322 :
4323 :
4324 :
4325 :
4326 :
4327 : /**
4328 : * Get frequencyRange.
4329 : * @return frequencyRange as std::vector<Frequency >
4330 : */
4331 0 : std::vector<Frequency > CalAtmosphereRow::getFrequencyRange() const {
4332 :
4333 0 : return frequencyRange;
4334 : }
4335 :
4336 : /**
4337 : * Set frequencyRange with the specified std::vector<Frequency >.
4338 : * @param frequencyRange The std::vector<Frequency > value to which frequencyRange is to be set.
4339 :
4340 :
4341 :
4342 : */
4343 0 : void CalAtmosphereRow::setFrequencyRange (std::vector<Frequency > frequencyRange) {
4344 :
4345 :
4346 0 : if (hasBeenAdded) {
4347 :
4348 : }
4349 :
4350 0 : this->frequencyRange = frequencyRange;
4351 :
4352 0 : }
4353 :
4354 :
4355 :
4356 :
4357 :
4358 :
4359 : /**
4360 : * Get groundPressure.
4361 : * @return groundPressure as Pressure
4362 : */
4363 0 : Pressure CalAtmosphereRow::getGroundPressure() const {
4364 :
4365 0 : return groundPressure;
4366 : }
4367 :
4368 : /**
4369 : * Set groundPressure with the specified Pressure.
4370 : * @param groundPressure The Pressure value to which groundPressure is to be set.
4371 :
4372 :
4373 :
4374 : */
4375 0 : void CalAtmosphereRow::setGroundPressure (Pressure groundPressure) {
4376 :
4377 :
4378 0 : if (hasBeenAdded) {
4379 :
4380 : }
4381 :
4382 0 : this->groundPressure = groundPressure;
4383 :
4384 0 : }
4385 :
4386 :
4387 :
4388 :
4389 :
4390 :
4391 : /**
4392 : * Get groundRelHumidity.
4393 : * @return groundRelHumidity as Humidity
4394 : */
4395 0 : Humidity CalAtmosphereRow::getGroundRelHumidity() const {
4396 :
4397 0 : return groundRelHumidity;
4398 : }
4399 :
4400 : /**
4401 : * Set groundRelHumidity with the specified Humidity.
4402 : * @param groundRelHumidity The Humidity value to which groundRelHumidity is to be set.
4403 :
4404 :
4405 :
4406 : */
4407 0 : void CalAtmosphereRow::setGroundRelHumidity (Humidity groundRelHumidity) {
4408 :
4409 :
4410 0 : if (hasBeenAdded) {
4411 :
4412 : }
4413 :
4414 0 : this->groundRelHumidity = groundRelHumidity;
4415 :
4416 0 : }
4417 :
4418 :
4419 :
4420 :
4421 :
4422 :
4423 : /**
4424 : * Get frequencySpectrum.
4425 : * @return frequencySpectrum as std::vector<Frequency >
4426 : */
4427 0 : std::vector<Frequency > CalAtmosphereRow::getFrequencySpectrum() const {
4428 :
4429 0 : return frequencySpectrum;
4430 : }
4431 :
4432 : /**
4433 : * Set frequencySpectrum with the specified std::vector<Frequency >.
4434 : * @param frequencySpectrum The std::vector<Frequency > value to which frequencySpectrum is to be set.
4435 :
4436 :
4437 :
4438 : */
4439 0 : void CalAtmosphereRow::setFrequencySpectrum (std::vector<Frequency > frequencySpectrum) {
4440 :
4441 :
4442 0 : if (hasBeenAdded) {
4443 :
4444 : }
4445 :
4446 0 : this->frequencySpectrum = frequencySpectrum;
4447 :
4448 0 : }
4449 :
4450 :
4451 :
4452 :
4453 :
4454 :
4455 : /**
4456 : * Get groundTemperature.
4457 : * @return groundTemperature as Temperature
4458 : */
4459 0 : Temperature CalAtmosphereRow::getGroundTemperature() const {
4460 :
4461 0 : return groundTemperature;
4462 : }
4463 :
4464 : /**
4465 : * Set groundTemperature with the specified Temperature.
4466 : * @param groundTemperature The Temperature value to which groundTemperature is to be set.
4467 :
4468 :
4469 :
4470 : */
4471 0 : void CalAtmosphereRow::setGroundTemperature (Temperature groundTemperature) {
4472 :
4473 :
4474 0 : if (hasBeenAdded) {
4475 :
4476 : }
4477 :
4478 0 : this->groundTemperature = groundTemperature;
4479 :
4480 0 : }
4481 :
4482 :
4483 :
4484 :
4485 :
4486 :
4487 : /**
4488 : * Get polarizationTypes.
4489 : * @return polarizationTypes as std::vector<PolarizationTypeMod::PolarizationType >
4490 : */
4491 0 : std::vector<PolarizationTypeMod::PolarizationType > CalAtmosphereRow::getPolarizationTypes() const {
4492 :
4493 0 : return polarizationTypes;
4494 : }
4495 :
4496 : /**
4497 : * Set polarizationTypes with the specified std::vector<PolarizationTypeMod::PolarizationType >.
4498 : * @param polarizationTypes The std::vector<PolarizationTypeMod::PolarizationType > value to which polarizationTypes is to be set.
4499 :
4500 :
4501 :
4502 : */
4503 0 : void CalAtmosphereRow::setPolarizationTypes (std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes) {
4504 :
4505 :
4506 0 : if (hasBeenAdded) {
4507 :
4508 : }
4509 :
4510 0 : this->polarizationTypes = polarizationTypes;
4511 :
4512 0 : }
4513 :
4514 :
4515 :
4516 :
4517 :
4518 :
4519 : /**
4520 : * Get powerSkySpectrum.
4521 : * @return powerSkySpectrum as std::vector<std::vector<float > >
4522 : */
4523 0 : std::vector<std::vector<float > > CalAtmosphereRow::getPowerSkySpectrum() const {
4524 :
4525 0 : return powerSkySpectrum;
4526 : }
4527 :
4528 : /**
4529 : * Set powerSkySpectrum with the specified std::vector<std::vector<float > >.
4530 : * @param powerSkySpectrum The std::vector<std::vector<float > > value to which powerSkySpectrum is to be set.
4531 :
4532 :
4533 :
4534 : */
4535 0 : void CalAtmosphereRow::setPowerSkySpectrum (std::vector<std::vector<float > > powerSkySpectrum) {
4536 :
4537 :
4538 0 : if (hasBeenAdded) {
4539 :
4540 : }
4541 :
4542 0 : this->powerSkySpectrum = powerSkySpectrum;
4543 :
4544 0 : }
4545 :
4546 :
4547 :
4548 :
4549 :
4550 :
4551 : /**
4552 : * Get powerLoadSpectrum.
4553 : * @return powerLoadSpectrum as std::vector<std::vector<std::vector<float > > >
4554 : */
4555 0 : std::vector<std::vector<std::vector<float > > > CalAtmosphereRow::getPowerLoadSpectrum() const {
4556 :
4557 0 : return powerLoadSpectrum;
4558 : }
4559 :
4560 : /**
4561 : * Set powerLoadSpectrum with the specified std::vector<std::vector<std::vector<float > > >.
4562 : * @param powerLoadSpectrum The std::vector<std::vector<std::vector<float > > > value to which powerLoadSpectrum is to be set.
4563 :
4564 :
4565 :
4566 : */
4567 0 : void CalAtmosphereRow::setPowerLoadSpectrum (std::vector<std::vector<std::vector<float > > > powerLoadSpectrum) {
4568 :
4569 :
4570 0 : if (hasBeenAdded) {
4571 :
4572 : }
4573 :
4574 0 : this->powerLoadSpectrum = powerLoadSpectrum;
4575 :
4576 0 : }
4577 :
4578 :
4579 :
4580 :
4581 :
4582 :
4583 : /**
4584 : * Get syscalType.
4585 : * @return syscalType as SyscalMethodMod::SyscalMethod
4586 : */
4587 0 : SyscalMethodMod::SyscalMethod CalAtmosphereRow::getSyscalType() const {
4588 :
4589 0 : return syscalType;
4590 : }
4591 :
4592 : /**
4593 : * Set syscalType with the specified SyscalMethodMod::SyscalMethod.
4594 : * @param syscalType The SyscalMethodMod::SyscalMethod value to which syscalType is to be set.
4595 :
4596 :
4597 :
4598 : */
4599 0 : void CalAtmosphereRow::setSyscalType (SyscalMethodMod::SyscalMethod syscalType) {
4600 :
4601 :
4602 0 : if (hasBeenAdded) {
4603 :
4604 : }
4605 :
4606 0 : this->syscalType = syscalType;
4607 :
4608 0 : }
4609 :
4610 :
4611 :
4612 :
4613 :
4614 :
4615 : /**
4616 : * Get tAtmSpectrum.
4617 : * @return tAtmSpectrum as std::vector<std::vector<Temperature > >
4618 : */
4619 0 : std::vector<std::vector<Temperature > > CalAtmosphereRow::getTAtmSpectrum() const {
4620 :
4621 0 : return tAtmSpectrum;
4622 : }
4623 :
4624 : /**
4625 : * Set tAtmSpectrum with the specified std::vector<std::vector<Temperature > >.
4626 : * @param tAtmSpectrum The std::vector<std::vector<Temperature > > value to which tAtmSpectrum is to be set.
4627 :
4628 :
4629 :
4630 : */
4631 0 : void CalAtmosphereRow::setTAtmSpectrum (std::vector<std::vector<Temperature > > tAtmSpectrum) {
4632 :
4633 :
4634 0 : if (hasBeenAdded) {
4635 :
4636 : }
4637 :
4638 0 : this->tAtmSpectrum = tAtmSpectrum;
4639 :
4640 0 : }
4641 :
4642 :
4643 :
4644 :
4645 :
4646 :
4647 : /**
4648 : * Get tRecSpectrum.
4649 : * @return tRecSpectrum as std::vector<std::vector<Temperature > >
4650 : */
4651 0 : std::vector<std::vector<Temperature > > CalAtmosphereRow::getTRecSpectrum() const {
4652 :
4653 0 : return tRecSpectrum;
4654 : }
4655 :
4656 : /**
4657 : * Set tRecSpectrum with the specified std::vector<std::vector<Temperature > >.
4658 : * @param tRecSpectrum The std::vector<std::vector<Temperature > > value to which tRecSpectrum is to be set.
4659 :
4660 :
4661 :
4662 : */
4663 0 : void CalAtmosphereRow::setTRecSpectrum (std::vector<std::vector<Temperature > > tRecSpectrum) {
4664 :
4665 :
4666 0 : if (hasBeenAdded) {
4667 :
4668 : }
4669 :
4670 0 : this->tRecSpectrum = tRecSpectrum;
4671 :
4672 0 : }
4673 :
4674 :
4675 :
4676 :
4677 :
4678 :
4679 : /**
4680 : * Get tSysSpectrum.
4681 : * @return tSysSpectrum as std::vector<std::vector<Temperature > >
4682 : */
4683 0 : std::vector<std::vector<Temperature > > CalAtmosphereRow::getTSysSpectrum() const {
4684 :
4685 0 : return tSysSpectrum;
4686 : }
4687 :
4688 : /**
4689 : * Set tSysSpectrum with the specified std::vector<std::vector<Temperature > >.
4690 : * @param tSysSpectrum The std::vector<std::vector<Temperature > > value to which tSysSpectrum is to be set.
4691 :
4692 :
4693 :
4694 : */
4695 0 : void CalAtmosphereRow::setTSysSpectrum (std::vector<std::vector<Temperature > > tSysSpectrum) {
4696 :
4697 :
4698 0 : if (hasBeenAdded) {
4699 :
4700 : }
4701 :
4702 0 : this->tSysSpectrum = tSysSpectrum;
4703 :
4704 0 : }
4705 :
4706 :
4707 :
4708 :
4709 :
4710 :
4711 : /**
4712 : * Get tauSpectrum.
4713 : * @return tauSpectrum as std::vector<std::vector<float > >
4714 : */
4715 0 : std::vector<std::vector<float > > CalAtmosphereRow::getTauSpectrum() const {
4716 :
4717 0 : return tauSpectrum;
4718 : }
4719 :
4720 : /**
4721 : * Set tauSpectrum with the specified std::vector<std::vector<float > >.
4722 : * @param tauSpectrum The std::vector<std::vector<float > > value to which tauSpectrum is to be set.
4723 :
4724 :
4725 :
4726 : */
4727 0 : void CalAtmosphereRow::setTauSpectrum (std::vector<std::vector<float > > tauSpectrum) {
4728 :
4729 :
4730 0 : if (hasBeenAdded) {
4731 :
4732 : }
4733 :
4734 0 : this->tauSpectrum = tauSpectrum;
4735 :
4736 0 : }
4737 :
4738 :
4739 :
4740 :
4741 :
4742 :
4743 : /**
4744 : * Get tAtm.
4745 : * @return tAtm as std::vector<Temperature >
4746 : */
4747 0 : std::vector<Temperature > CalAtmosphereRow::getTAtm() const {
4748 :
4749 0 : return tAtm;
4750 : }
4751 :
4752 : /**
4753 : * Set tAtm with the specified std::vector<Temperature >.
4754 : * @param tAtm The std::vector<Temperature > value to which tAtm is to be set.
4755 :
4756 :
4757 :
4758 : */
4759 0 : void CalAtmosphereRow::setTAtm (std::vector<Temperature > tAtm) {
4760 :
4761 :
4762 0 : if (hasBeenAdded) {
4763 :
4764 : }
4765 :
4766 0 : this->tAtm = tAtm;
4767 :
4768 0 : }
4769 :
4770 :
4771 :
4772 :
4773 :
4774 :
4775 : /**
4776 : * Get tRec.
4777 : * @return tRec as std::vector<Temperature >
4778 : */
4779 0 : std::vector<Temperature > CalAtmosphereRow::getTRec() const {
4780 :
4781 0 : return tRec;
4782 : }
4783 :
4784 : /**
4785 : * Set tRec with the specified std::vector<Temperature >.
4786 : * @param tRec The std::vector<Temperature > value to which tRec is to be set.
4787 :
4788 :
4789 :
4790 : */
4791 0 : void CalAtmosphereRow::setTRec (std::vector<Temperature > tRec) {
4792 :
4793 :
4794 0 : if (hasBeenAdded) {
4795 :
4796 : }
4797 :
4798 0 : this->tRec = tRec;
4799 :
4800 0 : }
4801 :
4802 :
4803 :
4804 :
4805 :
4806 :
4807 : /**
4808 : * Get tSys.
4809 : * @return tSys as std::vector<Temperature >
4810 : */
4811 0 : std::vector<Temperature > CalAtmosphereRow::getTSys() const {
4812 :
4813 0 : return tSys;
4814 : }
4815 :
4816 : /**
4817 : * Set tSys with the specified std::vector<Temperature >.
4818 : * @param tSys The std::vector<Temperature > value to which tSys is to be set.
4819 :
4820 :
4821 :
4822 : */
4823 0 : void CalAtmosphereRow::setTSys (std::vector<Temperature > tSys) {
4824 :
4825 :
4826 0 : if (hasBeenAdded) {
4827 :
4828 : }
4829 :
4830 0 : this->tSys = tSys;
4831 :
4832 0 : }
4833 :
4834 :
4835 :
4836 :
4837 :
4838 :
4839 : /**
4840 : * Get tau.
4841 : * @return tau as std::vector<float >
4842 : */
4843 0 : std::vector<float > CalAtmosphereRow::getTau() const {
4844 :
4845 0 : return tau;
4846 : }
4847 :
4848 : /**
4849 : * Set tau with the specified std::vector<float >.
4850 : * @param tau The std::vector<float > value to which tau is to be set.
4851 :
4852 :
4853 :
4854 : */
4855 0 : void CalAtmosphereRow::setTau (std::vector<float > tau) {
4856 :
4857 :
4858 0 : if (hasBeenAdded) {
4859 :
4860 : }
4861 :
4862 0 : this->tau = tau;
4863 :
4864 0 : }
4865 :
4866 :
4867 :
4868 :
4869 :
4870 :
4871 : /**
4872 : * Get water.
4873 : * @return water as std::vector<Length >
4874 : */
4875 0 : std::vector<Length > CalAtmosphereRow::getWater() const {
4876 :
4877 0 : return water;
4878 : }
4879 :
4880 : /**
4881 : * Set water with the specified std::vector<Length >.
4882 : * @param water The std::vector<Length > value to which water is to be set.
4883 :
4884 :
4885 :
4886 : */
4887 0 : void CalAtmosphereRow::setWater (std::vector<Length > water) {
4888 :
4889 :
4890 0 : if (hasBeenAdded) {
4891 :
4892 : }
4893 :
4894 0 : this->water = water;
4895 :
4896 0 : }
4897 :
4898 :
4899 :
4900 :
4901 :
4902 :
4903 : /**
4904 : * Get waterError.
4905 : * @return waterError as std::vector<Length >
4906 : */
4907 0 : std::vector<Length > CalAtmosphereRow::getWaterError() const {
4908 :
4909 0 : return waterError;
4910 : }
4911 :
4912 : /**
4913 : * Set waterError with the specified std::vector<Length >.
4914 : * @param waterError The std::vector<Length > value to which waterError is to be set.
4915 :
4916 :
4917 :
4918 : */
4919 0 : void CalAtmosphereRow::setWaterError (std::vector<Length > waterError) {
4920 :
4921 :
4922 0 : if (hasBeenAdded) {
4923 :
4924 : }
4925 :
4926 0 : this->waterError = waterError;
4927 :
4928 0 : }
4929 :
4930 :
4931 :
4932 :
4933 : /**
4934 : * The attribute alphaSpectrum is optional. Return true if this attribute exists.
4935 : * @return true if and only if the alphaSpectrum attribute exists.
4936 : */
4937 0 : bool CalAtmosphereRow::isAlphaSpectrumExists() const {
4938 0 : return alphaSpectrumExists;
4939 : }
4940 :
4941 :
4942 :
4943 : /**
4944 : * Get alphaSpectrum, which is optional.
4945 : * @return alphaSpectrum as std::vector<std::vector<float > >
4946 : * @throw IllegalAccessException If alphaSpectrum does not exist.
4947 : */
4948 0 : std::vector<std::vector<float > > CalAtmosphereRow::getAlphaSpectrum() const {
4949 0 : if (!alphaSpectrumExists) {
4950 0 : throw IllegalAccessException("alphaSpectrum", "CalAtmosphere");
4951 : }
4952 :
4953 0 : return alphaSpectrum;
4954 : }
4955 :
4956 : /**
4957 : * Set alphaSpectrum with the specified std::vector<std::vector<float > >.
4958 : * @param alphaSpectrum The std::vector<std::vector<float > > value to which alphaSpectrum is to be set.
4959 :
4960 :
4961 : */
4962 0 : void CalAtmosphereRow::setAlphaSpectrum (std::vector<std::vector<float > > alphaSpectrum) {
4963 :
4964 0 : this->alphaSpectrum = alphaSpectrum;
4965 :
4966 0 : alphaSpectrumExists = true;
4967 :
4968 0 : }
4969 :
4970 :
4971 : /**
4972 : * Mark alphaSpectrum, which is an optional field, as non-existent.
4973 : */
4974 0 : void CalAtmosphereRow::clearAlphaSpectrum () {
4975 0 : alphaSpectrumExists = false;
4976 0 : }
4977 :
4978 :
4979 :
4980 : /**
4981 : * The attribute forwardEfficiency is optional. Return true if this attribute exists.
4982 : * @return true if and only if the forwardEfficiency attribute exists.
4983 : */
4984 0 : bool CalAtmosphereRow::isForwardEfficiencyExists() const {
4985 0 : return forwardEfficiencyExists;
4986 : }
4987 :
4988 :
4989 :
4990 : /**
4991 : * Get forwardEfficiency, which is optional.
4992 : * @return forwardEfficiency as std::vector<float >
4993 : * @throw IllegalAccessException If forwardEfficiency does not exist.
4994 : */
4995 0 : std::vector<float > CalAtmosphereRow::getForwardEfficiency() const {
4996 0 : if (!forwardEfficiencyExists) {
4997 0 : throw IllegalAccessException("forwardEfficiency", "CalAtmosphere");
4998 : }
4999 :
5000 0 : return forwardEfficiency;
5001 : }
5002 :
5003 : /**
5004 : * Set forwardEfficiency with the specified std::vector<float >.
5005 : * @param forwardEfficiency The std::vector<float > value to which forwardEfficiency is to be set.
5006 :
5007 :
5008 : */
5009 0 : void CalAtmosphereRow::setForwardEfficiency (std::vector<float > forwardEfficiency) {
5010 :
5011 0 : this->forwardEfficiency = forwardEfficiency;
5012 :
5013 0 : forwardEfficiencyExists = true;
5014 :
5015 0 : }
5016 :
5017 :
5018 : /**
5019 : * Mark forwardEfficiency, which is an optional field, as non-existent.
5020 : */
5021 0 : void CalAtmosphereRow::clearForwardEfficiency () {
5022 0 : forwardEfficiencyExists = false;
5023 0 : }
5024 :
5025 :
5026 :
5027 : /**
5028 : * The attribute forwardEfficiencyError is optional. Return true if this attribute exists.
5029 : * @return true if and only if the forwardEfficiencyError attribute exists.
5030 : */
5031 0 : bool CalAtmosphereRow::isForwardEfficiencyErrorExists() const {
5032 0 : return forwardEfficiencyErrorExists;
5033 : }
5034 :
5035 :
5036 :
5037 : /**
5038 : * Get forwardEfficiencyError, which is optional.
5039 : * @return forwardEfficiencyError as std::vector<double >
5040 : * @throw IllegalAccessException If forwardEfficiencyError does not exist.
5041 : */
5042 0 : std::vector<double > CalAtmosphereRow::getForwardEfficiencyError() const {
5043 0 : if (!forwardEfficiencyErrorExists) {
5044 0 : throw IllegalAccessException("forwardEfficiencyError", "CalAtmosphere");
5045 : }
5046 :
5047 0 : return forwardEfficiencyError;
5048 : }
5049 :
5050 : /**
5051 : * Set forwardEfficiencyError with the specified std::vector<double >.
5052 : * @param forwardEfficiencyError The std::vector<double > value to which forwardEfficiencyError is to be set.
5053 :
5054 :
5055 : */
5056 0 : void CalAtmosphereRow::setForwardEfficiencyError (std::vector<double > forwardEfficiencyError) {
5057 :
5058 0 : this->forwardEfficiencyError = forwardEfficiencyError;
5059 :
5060 0 : forwardEfficiencyErrorExists = true;
5061 :
5062 0 : }
5063 :
5064 :
5065 : /**
5066 : * Mark forwardEfficiencyError, which is an optional field, as non-existent.
5067 : */
5068 0 : void CalAtmosphereRow::clearForwardEfficiencyError () {
5069 0 : forwardEfficiencyErrorExists = false;
5070 0 : }
5071 :
5072 :
5073 :
5074 : /**
5075 : * The attribute sbGain is optional. Return true if this attribute exists.
5076 : * @return true if and only if the sbGain attribute exists.
5077 : */
5078 0 : bool CalAtmosphereRow::isSbGainExists() const {
5079 0 : return sbGainExists;
5080 : }
5081 :
5082 :
5083 :
5084 : /**
5085 : * Get sbGain, which is optional.
5086 : * @return sbGain as std::vector<float >
5087 : * @throw IllegalAccessException If sbGain does not exist.
5088 : */
5089 0 : std::vector<float > CalAtmosphereRow::getSbGain() const {
5090 0 : if (!sbGainExists) {
5091 0 : throw IllegalAccessException("sbGain", "CalAtmosphere");
5092 : }
5093 :
5094 0 : return sbGain;
5095 : }
5096 :
5097 : /**
5098 : * Set sbGain with the specified std::vector<float >.
5099 : * @param sbGain The std::vector<float > value to which sbGain is to be set.
5100 :
5101 :
5102 : */
5103 0 : void CalAtmosphereRow::setSbGain (std::vector<float > sbGain) {
5104 :
5105 0 : this->sbGain = sbGain;
5106 :
5107 0 : sbGainExists = true;
5108 :
5109 0 : }
5110 :
5111 :
5112 : /**
5113 : * Mark sbGain, which is an optional field, as non-existent.
5114 : */
5115 0 : void CalAtmosphereRow::clearSbGain () {
5116 0 : sbGainExists = false;
5117 0 : }
5118 :
5119 :
5120 :
5121 : /**
5122 : * The attribute sbGainError is optional. Return true if this attribute exists.
5123 : * @return true if and only if the sbGainError attribute exists.
5124 : */
5125 0 : bool CalAtmosphereRow::isSbGainErrorExists() const {
5126 0 : return sbGainErrorExists;
5127 : }
5128 :
5129 :
5130 :
5131 : /**
5132 : * Get sbGainError, which is optional.
5133 : * @return sbGainError as std::vector<float >
5134 : * @throw IllegalAccessException If sbGainError does not exist.
5135 : */
5136 0 : std::vector<float > CalAtmosphereRow::getSbGainError() const {
5137 0 : if (!sbGainErrorExists) {
5138 0 : throw IllegalAccessException("sbGainError", "CalAtmosphere");
5139 : }
5140 :
5141 0 : return sbGainError;
5142 : }
5143 :
5144 : /**
5145 : * Set sbGainError with the specified std::vector<float >.
5146 : * @param sbGainError The std::vector<float > value to which sbGainError is to be set.
5147 :
5148 :
5149 : */
5150 0 : void CalAtmosphereRow::setSbGainError (std::vector<float > sbGainError) {
5151 :
5152 0 : this->sbGainError = sbGainError;
5153 :
5154 0 : sbGainErrorExists = true;
5155 :
5156 0 : }
5157 :
5158 :
5159 : /**
5160 : * Mark sbGainError, which is an optional field, as non-existent.
5161 : */
5162 0 : void CalAtmosphereRow::clearSbGainError () {
5163 0 : sbGainErrorExists = false;
5164 0 : }
5165 :
5166 :
5167 :
5168 : /**
5169 : * The attribute sbGainSpectrum is optional. Return true if this attribute exists.
5170 : * @return true if and only if the sbGainSpectrum attribute exists.
5171 : */
5172 0 : bool CalAtmosphereRow::isSbGainSpectrumExists() const {
5173 0 : return sbGainSpectrumExists;
5174 : }
5175 :
5176 :
5177 :
5178 : /**
5179 : * Get sbGainSpectrum, which is optional.
5180 : * @return sbGainSpectrum as std::vector<std::vector<float > >
5181 : * @throw IllegalAccessException If sbGainSpectrum does not exist.
5182 : */
5183 0 : std::vector<std::vector<float > > CalAtmosphereRow::getSbGainSpectrum() const {
5184 0 : if (!sbGainSpectrumExists) {
5185 0 : throw IllegalAccessException("sbGainSpectrum", "CalAtmosphere");
5186 : }
5187 :
5188 0 : return sbGainSpectrum;
5189 : }
5190 :
5191 : /**
5192 : * Set sbGainSpectrum with the specified std::vector<std::vector<float > >.
5193 : * @param sbGainSpectrum The std::vector<std::vector<float > > value to which sbGainSpectrum is to be set.
5194 :
5195 :
5196 : */
5197 0 : void CalAtmosphereRow::setSbGainSpectrum (std::vector<std::vector<float > > sbGainSpectrum) {
5198 :
5199 0 : this->sbGainSpectrum = sbGainSpectrum;
5200 :
5201 0 : sbGainSpectrumExists = true;
5202 :
5203 0 : }
5204 :
5205 :
5206 : /**
5207 : * Mark sbGainSpectrum, which is an optional field, as non-existent.
5208 : */
5209 0 : void CalAtmosphereRow::clearSbGainSpectrum () {
5210 0 : sbGainSpectrumExists = false;
5211 0 : }
5212 :
5213 :
5214 :
5215 : ///////////////////////////////////////////////
5216 : // Extrinsic Table Attributes getters/setters//
5217 : ///////////////////////////////////////////////
5218 :
5219 :
5220 :
5221 :
5222 : /**
5223 : * Get calDataId.
5224 : * @return calDataId as Tag
5225 : */
5226 0 : Tag CalAtmosphereRow::getCalDataId() const {
5227 :
5228 0 : return calDataId;
5229 : }
5230 :
5231 : /**
5232 : * Set calDataId with the specified Tag.
5233 : * @param calDataId The Tag value to which calDataId is to be set.
5234 :
5235 :
5236 :
5237 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
5238 :
5239 : */
5240 0 : void CalAtmosphereRow::setCalDataId (Tag calDataId) {
5241 :
5242 :
5243 0 : if (hasBeenAdded) {
5244 :
5245 0 : throw IllegalAccessException("calDataId", "CalAtmosphere");
5246 :
5247 : }
5248 :
5249 0 : this->calDataId = calDataId;
5250 :
5251 0 : }
5252 :
5253 :
5254 :
5255 :
5256 :
5257 :
5258 : /**
5259 : * Get calReductionId.
5260 : * @return calReductionId as Tag
5261 : */
5262 0 : Tag CalAtmosphereRow::getCalReductionId() const {
5263 :
5264 0 : return calReductionId;
5265 : }
5266 :
5267 : /**
5268 : * Set calReductionId with the specified Tag.
5269 : * @param calReductionId The Tag value to which calReductionId is to be set.
5270 :
5271 :
5272 :
5273 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
5274 :
5275 : */
5276 0 : void CalAtmosphereRow::setCalReductionId (Tag calReductionId) {
5277 :
5278 :
5279 0 : if (hasBeenAdded) {
5280 :
5281 0 : throw IllegalAccessException("calReductionId", "CalAtmosphere");
5282 :
5283 : }
5284 :
5285 0 : this->calReductionId = calReductionId;
5286 :
5287 0 : }
5288 :
5289 :
5290 :
5291 :
5292 : //////////////////////////////////////
5293 : // Links Attributes getters/setters //
5294 : //////////////////////////////////////
5295 :
5296 :
5297 :
5298 :
5299 :
5300 :
5301 : /**
5302 : * Returns the pointer to the row in the CalReduction table having CalReduction.calReductionId == calReductionId
5303 : * @return a CalReductionRow*
5304 : *
5305 :
5306 : */
5307 0 : CalReductionRow* CalAtmosphereRow::getCalReductionUsingCalReductionId() {
5308 :
5309 0 : return table.getContainer().getCalReduction().getRowByKey(calReductionId);
5310 : }
5311 :
5312 :
5313 :
5314 :
5315 :
5316 :
5317 :
5318 :
5319 :
5320 : /**
5321 : * Returns the pointer to the row in the CalData table having CalData.calDataId == calDataId
5322 : * @return a CalDataRow*
5323 : *
5324 :
5325 : */
5326 0 : CalDataRow* CalAtmosphereRow::getCalDataUsingCalDataId() {
5327 :
5328 0 : return table.getContainer().getCalData().getRowByKey(calDataId);
5329 : }
5330 :
5331 :
5332 :
5333 :
5334 :
5335 : /**
5336 : * Create a CalAtmosphereRow.
5337 : * <p>
5338 : * This constructor is private because only the
5339 : * table can create rows. All rows know the table
5340 : * to which they belong.
5341 : * @param table The table to which this row belongs.
5342 : */
5343 0 : CalAtmosphereRow::CalAtmosphereRow (CalAtmosphereTable &t) : table(t) {
5344 0 : hasBeenAdded = false;
5345 :
5346 :
5347 :
5348 :
5349 :
5350 :
5351 :
5352 :
5353 :
5354 :
5355 :
5356 :
5357 :
5358 :
5359 :
5360 :
5361 :
5362 :
5363 :
5364 :
5365 :
5366 :
5367 :
5368 :
5369 :
5370 :
5371 :
5372 :
5373 :
5374 :
5375 :
5376 :
5377 :
5378 :
5379 :
5380 :
5381 :
5382 :
5383 :
5384 :
5385 :
5386 :
5387 :
5388 :
5389 :
5390 :
5391 :
5392 :
5393 :
5394 :
5395 :
5396 :
5397 :
5398 :
5399 :
5400 :
5401 :
5402 :
5403 :
5404 0 : alphaSpectrumExists = false;
5405 :
5406 :
5407 :
5408 0 : forwardEfficiencyExists = false;
5409 :
5410 :
5411 :
5412 0 : forwardEfficiencyErrorExists = false;
5413 :
5414 :
5415 :
5416 0 : sbGainExists = false;
5417 :
5418 :
5419 :
5420 0 : sbGainErrorExists = false;
5421 :
5422 :
5423 :
5424 0 : sbGainSpectrumExists = false;
5425 :
5426 :
5427 :
5428 :
5429 :
5430 :
5431 :
5432 :
5433 :
5434 :
5435 :
5436 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5437 0 : receiverBand = CReceiverBand::from_int(0);
5438 :
5439 :
5440 :
5441 :
5442 :
5443 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5444 0 : basebandName = CBasebandName::from_int(0);
5445 :
5446 :
5447 :
5448 :
5449 :
5450 :
5451 :
5452 :
5453 :
5454 :
5455 :
5456 :
5457 :
5458 :
5459 :
5460 :
5461 :
5462 :
5463 :
5464 :
5465 :
5466 :
5467 :
5468 :
5469 :
5470 :
5471 :
5472 :
5473 :
5474 :
5475 :
5476 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5477 0 : syscalType = CSyscalMethod::from_int(0);
5478 :
5479 :
5480 :
5481 :
5482 :
5483 :
5484 :
5485 :
5486 :
5487 :
5488 :
5489 :
5490 :
5491 :
5492 :
5493 :
5494 :
5495 :
5496 :
5497 :
5498 :
5499 :
5500 :
5501 :
5502 :
5503 :
5504 :
5505 :
5506 :
5507 :
5508 :
5509 :
5510 :
5511 :
5512 :
5513 :
5514 0 : fromBinMethods["antennaName"] = &CalAtmosphereRow::antennaNameFromBin;
5515 0 : fromBinMethods["receiverBand"] = &CalAtmosphereRow::receiverBandFromBin;
5516 0 : fromBinMethods["basebandName"] = &CalAtmosphereRow::basebandNameFromBin;
5517 0 : fromBinMethods["calDataId"] = &CalAtmosphereRow::calDataIdFromBin;
5518 0 : fromBinMethods["calReductionId"] = &CalAtmosphereRow::calReductionIdFromBin;
5519 0 : fromBinMethods["startValidTime"] = &CalAtmosphereRow::startValidTimeFromBin;
5520 0 : fromBinMethods["endValidTime"] = &CalAtmosphereRow::endValidTimeFromBin;
5521 0 : fromBinMethods["numFreq"] = &CalAtmosphereRow::numFreqFromBin;
5522 0 : fromBinMethods["numLoad"] = &CalAtmosphereRow::numLoadFromBin;
5523 0 : fromBinMethods["numReceptor"] = &CalAtmosphereRow::numReceptorFromBin;
5524 0 : fromBinMethods["forwardEffSpectrum"] = &CalAtmosphereRow::forwardEffSpectrumFromBin;
5525 0 : fromBinMethods["frequencyRange"] = &CalAtmosphereRow::frequencyRangeFromBin;
5526 0 : fromBinMethods["groundPressure"] = &CalAtmosphereRow::groundPressureFromBin;
5527 0 : fromBinMethods["groundRelHumidity"] = &CalAtmosphereRow::groundRelHumidityFromBin;
5528 0 : fromBinMethods["frequencySpectrum"] = &CalAtmosphereRow::frequencySpectrumFromBin;
5529 0 : fromBinMethods["groundTemperature"] = &CalAtmosphereRow::groundTemperatureFromBin;
5530 0 : fromBinMethods["polarizationTypes"] = &CalAtmosphereRow::polarizationTypesFromBin;
5531 0 : fromBinMethods["powerSkySpectrum"] = &CalAtmosphereRow::powerSkySpectrumFromBin;
5532 0 : fromBinMethods["powerLoadSpectrum"] = &CalAtmosphereRow::powerLoadSpectrumFromBin;
5533 0 : fromBinMethods["syscalType"] = &CalAtmosphereRow::syscalTypeFromBin;
5534 0 : fromBinMethods["tAtmSpectrum"] = &CalAtmosphereRow::tAtmSpectrumFromBin;
5535 0 : fromBinMethods["tRecSpectrum"] = &CalAtmosphereRow::tRecSpectrumFromBin;
5536 0 : fromBinMethods["tSysSpectrum"] = &CalAtmosphereRow::tSysSpectrumFromBin;
5537 0 : fromBinMethods["tauSpectrum"] = &CalAtmosphereRow::tauSpectrumFromBin;
5538 0 : fromBinMethods["tAtm"] = &CalAtmosphereRow::tAtmFromBin;
5539 0 : fromBinMethods["tRec"] = &CalAtmosphereRow::tRecFromBin;
5540 0 : fromBinMethods["tSys"] = &CalAtmosphereRow::tSysFromBin;
5541 0 : fromBinMethods["tau"] = &CalAtmosphereRow::tauFromBin;
5542 0 : fromBinMethods["water"] = &CalAtmosphereRow::waterFromBin;
5543 0 : fromBinMethods["waterError"] = &CalAtmosphereRow::waterErrorFromBin;
5544 :
5545 :
5546 0 : fromBinMethods["alphaSpectrum"] = &CalAtmosphereRow::alphaSpectrumFromBin;
5547 0 : fromBinMethods["forwardEfficiency"] = &CalAtmosphereRow::forwardEfficiencyFromBin;
5548 0 : fromBinMethods["forwardEfficiencyError"] = &CalAtmosphereRow::forwardEfficiencyErrorFromBin;
5549 0 : fromBinMethods["sbGain"] = &CalAtmosphereRow::sbGainFromBin;
5550 0 : fromBinMethods["sbGainError"] = &CalAtmosphereRow::sbGainErrorFromBin;
5551 0 : fromBinMethods["sbGainSpectrum"] = &CalAtmosphereRow::sbGainSpectrumFromBin;
5552 :
5553 :
5554 :
5555 :
5556 :
5557 0 : fromTextMethods["antennaName"] = &CalAtmosphereRow::antennaNameFromText;
5558 :
5559 :
5560 :
5561 0 : fromTextMethods["receiverBand"] = &CalAtmosphereRow::receiverBandFromText;
5562 :
5563 :
5564 :
5565 0 : fromTextMethods["basebandName"] = &CalAtmosphereRow::basebandNameFromText;
5566 :
5567 :
5568 :
5569 0 : fromTextMethods["calDataId"] = &CalAtmosphereRow::calDataIdFromText;
5570 :
5571 :
5572 :
5573 0 : fromTextMethods["calReductionId"] = &CalAtmosphereRow::calReductionIdFromText;
5574 :
5575 :
5576 :
5577 0 : fromTextMethods["startValidTime"] = &CalAtmosphereRow::startValidTimeFromText;
5578 :
5579 :
5580 :
5581 0 : fromTextMethods["endValidTime"] = &CalAtmosphereRow::endValidTimeFromText;
5582 :
5583 :
5584 :
5585 0 : fromTextMethods["numFreq"] = &CalAtmosphereRow::numFreqFromText;
5586 :
5587 :
5588 :
5589 0 : fromTextMethods["numLoad"] = &CalAtmosphereRow::numLoadFromText;
5590 :
5591 :
5592 :
5593 0 : fromTextMethods["numReceptor"] = &CalAtmosphereRow::numReceptorFromText;
5594 :
5595 :
5596 :
5597 0 : fromTextMethods["forwardEffSpectrum"] = &CalAtmosphereRow::forwardEffSpectrumFromText;
5598 :
5599 :
5600 :
5601 0 : fromTextMethods["frequencyRange"] = &CalAtmosphereRow::frequencyRangeFromText;
5602 :
5603 :
5604 :
5605 0 : fromTextMethods["groundPressure"] = &CalAtmosphereRow::groundPressureFromText;
5606 :
5607 :
5608 :
5609 0 : fromTextMethods["groundRelHumidity"] = &CalAtmosphereRow::groundRelHumidityFromText;
5610 :
5611 :
5612 :
5613 0 : fromTextMethods["frequencySpectrum"] = &CalAtmosphereRow::frequencySpectrumFromText;
5614 :
5615 :
5616 :
5617 0 : fromTextMethods["groundTemperature"] = &CalAtmosphereRow::groundTemperatureFromText;
5618 :
5619 :
5620 :
5621 0 : fromTextMethods["polarizationTypes"] = &CalAtmosphereRow::polarizationTypesFromText;
5622 :
5623 :
5624 :
5625 0 : fromTextMethods["powerSkySpectrum"] = &CalAtmosphereRow::powerSkySpectrumFromText;
5626 :
5627 :
5628 :
5629 0 : fromTextMethods["powerLoadSpectrum"] = &CalAtmosphereRow::powerLoadSpectrumFromText;
5630 :
5631 :
5632 :
5633 0 : fromTextMethods["syscalType"] = &CalAtmosphereRow::syscalTypeFromText;
5634 :
5635 :
5636 :
5637 0 : fromTextMethods["tAtmSpectrum"] = &CalAtmosphereRow::tAtmSpectrumFromText;
5638 :
5639 :
5640 :
5641 0 : fromTextMethods["tRecSpectrum"] = &CalAtmosphereRow::tRecSpectrumFromText;
5642 :
5643 :
5644 :
5645 0 : fromTextMethods["tSysSpectrum"] = &CalAtmosphereRow::tSysSpectrumFromText;
5646 :
5647 :
5648 :
5649 0 : fromTextMethods["tauSpectrum"] = &CalAtmosphereRow::tauSpectrumFromText;
5650 :
5651 :
5652 :
5653 0 : fromTextMethods["tAtm"] = &CalAtmosphereRow::tAtmFromText;
5654 :
5655 :
5656 :
5657 0 : fromTextMethods["tRec"] = &CalAtmosphereRow::tRecFromText;
5658 :
5659 :
5660 :
5661 0 : fromTextMethods["tSys"] = &CalAtmosphereRow::tSysFromText;
5662 :
5663 :
5664 :
5665 0 : fromTextMethods["tau"] = &CalAtmosphereRow::tauFromText;
5666 :
5667 :
5668 :
5669 0 : fromTextMethods["water"] = &CalAtmosphereRow::waterFromText;
5670 :
5671 :
5672 :
5673 0 : fromTextMethods["waterError"] = &CalAtmosphereRow::waterErrorFromText;
5674 :
5675 :
5676 :
5677 :
5678 :
5679 0 : fromTextMethods["alphaSpectrum"] = &CalAtmosphereRow::alphaSpectrumFromText;
5680 :
5681 :
5682 :
5683 0 : fromTextMethods["forwardEfficiency"] = &CalAtmosphereRow::forwardEfficiencyFromText;
5684 :
5685 :
5686 :
5687 0 : fromTextMethods["forwardEfficiencyError"] = &CalAtmosphereRow::forwardEfficiencyErrorFromText;
5688 :
5689 :
5690 :
5691 0 : fromTextMethods["sbGain"] = &CalAtmosphereRow::sbGainFromText;
5692 :
5693 :
5694 :
5695 0 : fromTextMethods["sbGainError"] = &CalAtmosphereRow::sbGainErrorFromText;
5696 :
5697 :
5698 :
5699 0 : fromTextMethods["sbGainSpectrum"] = &CalAtmosphereRow::sbGainSpectrumFromText;
5700 :
5701 :
5702 0 : }
5703 :
5704 0 : CalAtmosphereRow::CalAtmosphereRow (CalAtmosphereTable &t, CalAtmosphereRow *row) : table(t) {
5705 0 : hasBeenAdded = false;
5706 :
5707 0 : if (row == 0) {
5708 :
5709 :
5710 :
5711 :
5712 :
5713 :
5714 :
5715 :
5716 :
5717 :
5718 :
5719 :
5720 :
5721 :
5722 :
5723 :
5724 :
5725 :
5726 :
5727 :
5728 :
5729 :
5730 :
5731 :
5732 :
5733 :
5734 :
5735 :
5736 :
5737 :
5738 :
5739 :
5740 :
5741 :
5742 :
5743 :
5744 :
5745 :
5746 :
5747 :
5748 :
5749 :
5750 :
5751 :
5752 :
5753 :
5754 :
5755 :
5756 :
5757 :
5758 :
5759 :
5760 :
5761 :
5762 :
5763 :
5764 :
5765 :
5766 :
5767 0 : alphaSpectrumExists = false;
5768 :
5769 :
5770 :
5771 0 : forwardEfficiencyExists = false;
5772 :
5773 :
5774 :
5775 0 : forwardEfficiencyErrorExists = false;
5776 :
5777 :
5778 :
5779 0 : sbGainExists = false;
5780 :
5781 :
5782 :
5783 0 : sbGainErrorExists = false;
5784 :
5785 :
5786 :
5787 0 : sbGainSpectrumExists = false;
5788 :
5789 :
5790 :
5791 :
5792 :
5793 :
5794 :
5795 : }
5796 : else {
5797 :
5798 :
5799 0 : antennaName = row->antennaName;
5800 :
5801 0 : receiverBand = row->receiverBand;
5802 :
5803 0 : basebandName = row->basebandName;
5804 :
5805 0 : calDataId = row->calDataId;
5806 :
5807 0 : calReductionId = row->calReductionId;
5808 :
5809 :
5810 :
5811 :
5812 0 : startValidTime = row->startValidTime;
5813 :
5814 0 : endValidTime = row->endValidTime;
5815 :
5816 0 : numFreq = row->numFreq;
5817 :
5818 0 : numLoad = row->numLoad;
5819 :
5820 0 : numReceptor = row->numReceptor;
5821 :
5822 0 : forwardEffSpectrum = row->forwardEffSpectrum;
5823 :
5824 0 : frequencyRange = row->frequencyRange;
5825 :
5826 0 : groundPressure = row->groundPressure;
5827 :
5828 0 : groundRelHumidity = row->groundRelHumidity;
5829 :
5830 0 : frequencySpectrum = row->frequencySpectrum;
5831 :
5832 0 : groundTemperature = row->groundTemperature;
5833 :
5834 0 : polarizationTypes = row->polarizationTypes;
5835 :
5836 0 : powerSkySpectrum = row->powerSkySpectrum;
5837 :
5838 0 : powerLoadSpectrum = row->powerLoadSpectrum;
5839 :
5840 0 : syscalType = row->syscalType;
5841 :
5842 0 : tAtmSpectrum = row->tAtmSpectrum;
5843 :
5844 0 : tRecSpectrum = row->tRecSpectrum;
5845 :
5846 0 : tSysSpectrum = row->tSysSpectrum;
5847 :
5848 0 : tauSpectrum = row->tauSpectrum;
5849 :
5850 0 : tAtm = row->tAtm;
5851 :
5852 0 : tRec = row->tRec;
5853 :
5854 0 : tSys = row->tSys;
5855 :
5856 0 : tau = row->tau;
5857 :
5858 0 : water = row->water;
5859 :
5860 0 : waterError = row->waterError;
5861 :
5862 :
5863 :
5864 :
5865 0 : if (row->alphaSpectrumExists) {
5866 0 : alphaSpectrum = row->alphaSpectrum;
5867 0 : alphaSpectrumExists = true;
5868 : }
5869 : else
5870 0 : alphaSpectrumExists = false;
5871 :
5872 0 : if (row->forwardEfficiencyExists) {
5873 0 : forwardEfficiency = row->forwardEfficiency;
5874 0 : forwardEfficiencyExists = true;
5875 : }
5876 : else
5877 0 : forwardEfficiencyExists = false;
5878 :
5879 0 : if (row->forwardEfficiencyErrorExists) {
5880 0 : forwardEfficiencyError = row->forwardEfficiencyError;
5881 0 : forwardEfficiencyErrorExists = true;
5882 : }
5883 : else
5884 0 : forwardEfficiencyErrorExists = false;
5885 :
5886 0 : if (row->sbGainExists) {
5887 0 : sbGain = row->sbGain;
5888 0 : sbGainExists = true;
5889 : }
5890 : else
5891 0 : sbGainExists = false;
5892 :
5893 0 : if (row->sbGainErrorExists) {
5894 0 : sbGainError = row->sbGainError;
5895 0 : sbGainErrorExists = true;
5896 : }
5897 : else
5898 0 : sbGainErrorExists = false;
5899 :
5900 0 : if (row->sbGainSpectrumExists) {
5901 0 : sbGainSpectrum = row->sbGainSpectrum;
5902 0 : sbGainSpectrumExists = true;
5903 : }
5904 : else
5905 0 : sbGainSpectrumExists = false;
5906 :
5907 : }
5908 :
5909 0 : fromBinMethods["antennaName"] = &CalAtmosphereRow::antennaNameFromBin;
5910 0 : fromBinMethods["receiverBand"] = &CalAtmosphereRow::receiverBandFromBin;
5911 0 : fromBinMethods["basebandName"] = &CalAtmosphereRow::basebandNameFromBin;
5912 0 : fromBinMethods["calDataId"] = &CalAtmosphereRow::calDataIdFromBin;
5913 0 : fromBinMethods["calReductionId"] = &CalAtmosphereRow::calReductionIdFromBin;
5914 0 : fromBinMethods["startValidTime"] = &CalAtmosphereRow::startValidTimeFromBin;
5915 0 : fromBinMethods["endValidTime"] = &CalAtmosphereRow::endValidTimeFromBin;
5916 0 : fromBinMethods["numFreq"] = &CalAtmosphereRow::numFreqFromBin;
5917 0 : fromBinMethods["numLoad"] = &CalAtmosphereRow::numLoadFromBin;
5918 0 : fromBinMethods["numReceptor"] = &CalAtmosphereRow::numReceptorFromBin;
5919 0 : fromBinMethods["forwardEffSpectrum"] = &CalAtmosphereRow::forwardEffSpectrumFromBin;
5920 0 : fromBinMethods["frequencyRange"] = &CalAtmosphereRow::frequencyRangeFromBin;
5921 0 : fromBinMethods["groundPressure"] = &CalAtmosphereRow::groundPressureFromBin;
5922 0 : fromBinMethods["groundRelHumidity"] = &CalAtmosphereRow::groundRelHumidityFromBin;
5923 0 : fromBinMethods["frequencySpectrum"] = &CalAtmosphereRow::frequencySpectrumFromBin;
5924 0 : fromBinMethods["groundTemperature"] = &CalAtmosphereRow::groundTemperatureFromBin;
5925 0 : fromBinMethods["polarizationTypes"] = &CalAtmosphereRow::polarizationTypesFromBin;
5926 0 : fromBinMethods["powerSkySpectrum"] = &CalAtmosphereRow::powerSkySpectrumFromBin;
5927 0 : fromBinMethods["powerLoadSpectrum"] = &CalAtmosphereRow::powerLoadSpectrumFromBin;
5928 0 : fromBinMethods["syscalType"] = &CalAtmosphereRow::syscalTypeFromBin;
5929 0 : fromBinMethods["tAtmSpectrum"] = &CalAtmosphereRow::tAtmSpectrumFromBin;
5930 0 : fromBinMethods["tRecSpectrum"] = &CalAtmosphereRow::tRecSpectrumFromBin;
5931 0 : fromBinMethods["tSysSpectrum"] = &CalAtmosphereRow::tSysSpectrumFromBin;
5932 0 : fromBinMethods["tauSpectrum"] = &CalAtmosphereRow::tauSpectrumFromBin;
5933 0 : fromBinMethods["tAtm"] = &CalAtmosphereRow::tAtmFromBin;
5934 0 : fromBinMethods["tRec"] = &CalAtmosphereRow::tRecFromBin;
5935 0 : fromBinMethods["tSys"] = &CalAtmosphereRow::tSysFromBin;
5936 0 : fromBinMethods["tau"] = &CalAtmosphereRow::tauFromBin;
5937 0 : fromBinMethods["water"] = &CalAtmosphereRow::waterFromBin;
5938 0 : fromBinMethods["waterError"] = &CalAtmosphereRow::waterErrorFromBin;
5939 :
5940 :
5941 0 : fromBinMethods["alphaSpectrum"] = &CalAtmosphereRow::alphaSpectrumFromBin;
5942 0 : fromBinMethods["forwardEfficiency"] = &CalAtmosphereRow::forwardEfficiencyFromBin;
5943 0 : fromBinMethods["forwardEfficiencyError"] = &CalAtmosphereRow::forwardEfficiencyErrorFromBin;
5944 0 : fromBinMethods["sbGain"] = &CalAtmosphereRow::sbGainFromBin;
5945 0 : fromBinMethods["sbGainError"] = &CalAtmosphereRow::sbGainErrorFromBin;
5946 0 : fromBinMethods["sbGainSpectrum"] = &CalAtmosphereRow::sbGainSpectrumFromBin;
5947 :
5948 0 : }
5949 :
5950 :
5951 0 : bool CalAtmosphereRow::compareNoAutoInc(std::string antennaName, ReceiverBandMod::ReceiverBand receiverBand, BasebandNameMod::BasebandName basebandName, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, int numFreq, int numLoad, int numReceptor, std::vector<std::vector<float > > forwardEffSpectrum, std::vector<Frequency > frequencyRange, Pressure groundPressure, Humidity groundRelHumidity, std::vector<Frequency > frequencySpectrum, Temperature groundTemperature, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, std::vector<std::vector<float > > powerSkySpectrum, std::vector<std::vector<std::vector<float > > > powerLoadSpectrum, SyscalMethodMod::SyscalMethod syscalType, std::vector<std::vector<Temperature > > tAtmSpectrum, std::vector<std::vector<Temperature > > tRecSpectrum, std::vector<std::vector<Temperature > > tSysSpectrum, std::vector<std::vector<float > > tauSpectrum, std::vector<Temperature > tAtm, std::vector<Temperature > tRec, std::vector<Temperature > tSys, std::vector<float > tau, std::vector<Length > water, std::vector<Length > waterError) {
5952 : bool result;
5953 0 : result = true;
5954 :
5955 :
5956 :
5957 0 : result = result && (this->antennaName == antennaName);
5958 :
5959 0 : if (!result) return false;
5960 :
5961 :
5962 :
5963 :
5964 0 : result = result && (this->receiverBand == receiverBand);
5965 :
5966 0 : if (!result) return false;
5967 :
5968 :
5969 :
5970 :
5971 0 : result = result && (this->basebandName == basebandName);
5972 :
5973 0 : if (!result) return false;
5974 :
5975 :
5976 :
5977 :
5978 0 : result = result && (this->calDataId == calDataId);
5979 :
5980 0 : if (!result) return false;
5981 :
5982 :
5983 :
5984 :
5985 0 : result = result && (this->calReductionId == calReductionId);
5986 :
5987 0 : if (!result) return false;
5988 :
5989 :
5990 :
5991 :
5992 0 : result = result && (this->startValidTime == startValidTime);
5993 :
5994 0 : if (!result) return false;
5995 :
5996 :
5997 :
5998 :
5999 0 : result = result && (this->endValidTime == endValidTime);
6000 :
6001 0 : if (!result) return false;
6002 :
6003 :
6004 :
6005 :
6006 0 : result = result && (this->numFreq == numFreq);
6007 :
6008 0 : if (!result) return false;
6009 :
6010 :
6011 :
6012 :
6013 0 : result = result && (this->numLoad == numLoad);
6014 :
6015 0 : if (!result) return false;
6016 :
6017 :
6018 :
6019 :
6020 0 : result = result && (this->numReceptor == numReceptor);
6021 :
6022 0 : if (!result) return false;
6023 :
6024 :
6025 :
6026 :
6027 0 : result = result && (this->forwardEffSpectrum == forwardEffSpectrum);
6028 :
6029 0 : if (!result) return false;
6030 :
6031 :
6032 :
6033 :
6034 0 : result = result && (this->frequencyRange == frequencyRange);
6035 :
6036 0 : if (!result) return false;
6037 :
6038 :
6039 :
6040 :
6041 0 : result = result && (this->groundPressure == groundPressure);
6042 :
6043 0 : if (!result) return false;
6044 :
6045 :
6046 :
6047 :
6048 0 : result = result && (this->groundRelHumidity == groundRelHumidity);
6049 :
6050 0 : if (!result) return false;
6051 :
6052 :
6053 :
6054 :
6055 0 : result = result && (this->frequencySpectrum == frequencySpectrum);
6056 :
6057 0 : if (!result) return false;
6058 :
6059 :
6060 :
6061 :
6062 0 : result = result && (this->groundTemperature == groundTemperature);
6063 :
6064 0 : if (!result) return false;
6065 :
6066 :
6067 :
6068 :
6069 0 : result = result && (this->polarizationTypes == polarizationTypes);
6070 :
6071 0 : if (!result) return false;
6072 :
6073 :
6074 :
6075 :
6076 0 : result = result && (this->powerSkySpectrum == powerSkySpectrum);
6077 :
6078 0 : if (!result) return false;
6079 :
6080 :
6081 :
6082 :
6083 0 : result = result && (this->powerLoadSpectrum == powerLoadSpectrum);
6084 :
6085 0 : if (!result) return false;
6086 :
6087 :
6088 :
6089 :
6090 0 : result = result && (this->syscalType == syscalType);
6091 :
6092 0 : if (!result) return false;
6093 :
6094 :
6095 :
6096 :
6097 0 : result = result && (this->tAtmSpectrum == tAtmSpectrum);
6098 :
6099 0 : if (!result) return false;
6100 :
6101 :
6102 :
6103 :
6104 0 : result = result && (this->tRecSpectrum == tRecSpectrum);
6105 :
6106 0 : if (!result) return false;
6107 :
6108 :
6109 :
6110 :
6111 0 : result = result && (this->tSysSpectrum == tSysSpectrum);
6112 :
6113 0 : if (!result) return false;
6114 :
6115 :
6116 :
6117 :
6118 0 : result = result && (this->tauSpectrum == tauSpectrum);
6119 :
6120 0 : if (!result) return false;
6121 :
6122 :
6123 :
6124 :
6125 0 : result = result && (this->tAtm == tAtm);
6126 :
6127 0 : if (!result) return false;
6128 :
6129 :
6130 :
6131 :
6132 0 : result = result && (this->tRec == tRec);
6133 :
6134 0 : if (!result) return false;
6135 :
6136 :
6137 :
6138 :
6139 0 : result = result && (this->tSys == tSys);
6140 :
6141 0 : if (!result) return false;
6142 :
6143 :
6144 :
6145 :
6146 0 : result = result && (this->tau == tau);
6147 :
6148 0 : if (!result) return false;
6149 :
6150 :
6151 :
6152 :
6153 0 : result = result && (this->water == water);
6154 :
6155 0 : if (!result) return false;
6156 :
6157 :
6158 :
6159 :
6160 0 : result = result && (this->waterError == waterError);
6161 :
6162 0 : if (!result) return false;
6163 :
6164 :
6165 0 : return result;
6166 : }
6167 :
6168 :
6169 :
6170 0 : bool CalAtmosphereRow::compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, int numFreq, int numLoad, int numReceptor, std::vector<std::vector<float > > forwardEffSpectrum, std::vector<Frequency > frequencyRange, Pressure groundPressure, Humidity groundRelHumidity, std::vector<Frequency > frequencySpectrum, Temperature groundTemperature, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, std::vector<std::vector<float > > powerSkySpectrum, std::vector<std::vector<std::vector<float > > > powerLoadSpectrum, SyscalMethodMod::SyscalMethod syscalType, std::vector<std::vector<Temperature > > tAtmSpectrum, std::vector<std::vector<Temperature > > tRecSpectrum, std::vector<std::vector<Temperature > > tSysSpectrum, std::vector<std::vector<float > > tauSpectrum, std::vector<Temperature > tAtm, std::vector<Temperature > tRec, std::vector<Temperature > tSys, std::vector<float > tau, std::vector<Length > water, std::vector<Length > waterError) {
6171 : bool result;
6172 0 : result = true;
6173 :
6174 :
6175 0 : if (!(this->startValidTime == startValidTime)) return false;
6176 :
6177 :
6178 :
6179 0 : if (!(this->endValidTime == endValidTime)) return false;
6180 :
6181 :
6182 :
6183 0 : if (!(this->numFreq == numFreq)) return false;
6184 :
6185 :
6186 :
6187 0 : if (!(this->numLoad == numLoad)) return false;
6188 :
6189 :
6190 :
6191 0 : if (!(this->numReceptor == numReceptor)) return false;
6192 :
6193 :
6194 :
6195 0 : if (!(this->forwardEffSpectrum == forwardEffSpectrum)) return false;
6196 :
6197 :
6198 :
6199 0 : if (!(this->frequencyRange == frequencyRange)) return false;
6200 :
6201 :
6202 :
6203 0 : if (!(this->groundPressure == groundPressure)) return false;
6204 :
6205 :
6206 :
6207 0 : if (!(this->groundRelHumidity == groundRelHumidity)) return false;
6208 :
6209 :
6210 :
6211 0 : if (!(this->frequencySpectrum == frequencySpectrum)) return false;
6212 :
6213 :
6214 :
6215 0 : if (!(this->groundTemperature == groundTemperature)) return false;
6216 :
6217 :
6218 :
6219 0 : if (!(this->polarizationTypes == polarizationTypes)) return false;
6220 :
6221 :
6222 :
6223 0 : if (!(this->powerSkySpectrum == powerSkySpectrum)) return false;
6224 :
6225 :
6226 :
6227 0 : if (!(this->powerLoadSpectrum == powerLoadSpectrum)) return false;
6228 :
6229 :
6230 :
6231 0 : if (!(this->syscalType == syscalType)) return false;
6232 :
6233 :
6234 :
6235 0 : if (!(this->tAtmSpectrum == tAtmSpectrum)) return false;
6236 :
6237 :
6238 :
6239 0 : if (!(this->tRecSpectrum == tRecSpectrum)) return false;
6240 :
6241 :
6242 :
6243 0 : if (!(this->tSysSpectrum == tSysSpectrum)) return false;
6244 :
6245 :
6246 :
6247 0 : if (!(this->tauSpectrum == tauSpectrum)) return false;
6248 :
6249 :
6250 :
6251 0 : if (!(this->tAtm == tAtm)) return false;
6252 :
6253 :
6254 :
6255 0 : if (!(this->tRec == tRec)) return false;
6256 :
6257 :
6258 :
6259 0 : if (!(this->tSys == tSys)) return false;
6260 :
6261 :
6262 :
6263 0 : if (!(this->tau == tau)) return false;
6264 :
6265 :
6266 :
6267 0 : if (!(this->water == water)) return false;
6268 :
6269 :
6270 :
6271 0 : if (!(this->waterError == waterError)) return false;
6272 :
6273 :
6274 0 : return result;
6275 : }
6276 :
6277 :
6278 : /**
6279 : * Return true if all required attributes of the value part are equal to their homologues
6280 : * in x and false otherwise.
6281 : *
6282 :
6283 : * @param x a pointer on the CalAtmosphereRow whose required attributes of the value part
6284 :
6285 : * will be compared with those of this.
6286 : * @return a boolean.
6287 : */
6288 0 : bool CalAtmosphereRow::equalByRequiredValue(CalAtmosphereRow* x ) {
6289 :
6290 :
6291 0 : if (this->startValidTime != x->startValidTime) return false;
6292 :
6293 0 : if (this->endValidTime != x->endValidTime) return false;
6294 :
6295 0 : if (this->numFreq != x->numFreq) return false;
6296 :
6297 0 : if (this->numLoad != x->numLoad) return false;
6298 :
6299 0 : if (this->numReceptor != x->numReceptor) return false;
6300 :
6301 0 : if (this->forwardEffSpectrum != x->forwardEffSpectrum) return false;
6302 :
6303 0 : if (this->frequencyRange != x->frequencyRange) return false;
6304 :
6305 0 : if (this->groundPressure != x->groundPressure) return false;
6306 :
6307 0 : if (this->groundRelHumidity != x->groundRelHumidity) return false;
6308 :
6309 0 : if (this->frequencySpectrum != x->frequencySpectrum) return false;
6310 :
6311 0 : if (this->groundTemperature != x->groundTemperature) return false;
6312 :
6313 0 : if (this->polarizationTypes != x->polarizationTypes) return false;
6314 :
6315 0 : if (this->powerSkySpectrum != x->powerSkySpectrum) return false;
6316 :
6317 0 : if (this->powerLoadSpectrum != x->powerLoadSpectrum) return false;
6318 :
6319 0 : if (this->syscalType != x->syscalType) return false;
6320 :
6321 0 : if (this->tAtmSpectrum != x->tAtmSpectrum) return false;
6322 :
6323 0 : if (this->tRecSpectrum != x->tRecSpectrum) return false;
6324 :
6325 0 : if (this->tSysSpectrum != x->tSysSpectrum) return false;
6326 :
6327 0 : if (this->tauSpectrum != x->tauSpectrum) return false;
6328 :
6329 0 : if (this->tAtm != x->tAtm) return false;
6330 :
6331 0 : if (this->tRec != x->tRec) return false;
6332 :
6333 0 : if (this->tSys != x->tSys) return false;
6334 :
6335 0 : if (this->tau != x->tau) return false;
6336 :
6337 0 : if (this->water != x->water) return false;
6338 :
6339 0 : if (this->waterError != x->waterError) return false;
6340 :
6341 :
6342 0 : return true;
6343 : }
6344 :
6345 : /*
6346 : map<string, CalAtmosphereAttributeFromBin> CalAtmosphereRow::initFromBinMethods() {
6347 : map<string, CalAtmosphereAttributeFromBin> result;
6348 :
6349 : result["antennaName"] = &CalAtmosphereRow::antennaNameFromBin;
6350 : result["receiverBand"] = &CalAtmosphereRow::receiverBandFromBin;
6351 : result["basebandName"] = &CalAtmosphereRow::basebandNameFromBin;
6352 : result["calDataId"] = &CalAtmosphereRow::calDataIdFromBin;
6353 : result["calReductionId"] = &CalAtmosphereRow::calReductionIdFromBin;
6354 : result["startValidTime"] = &CalAtmosphereRow::startValidTimeFromBin;
6355 : result["endValidTime"] = &CalAtmosphereRow::endValidTimeFromBin;
6356 : result["numFreq"] = &CalAtmosphereRow::numFreqFromBin;
6357 : result["numLoad"] = &CalAtmosphereRow::numLoadFromBin;
6358 : result["numReceptor"] = &CalAtmosphereRow::numReceptorFromBin;
6359 : result["forwardEffSpectrum"] = &CalAtmosphereRow::forwardEffSpectrumFromBin;
6360 : result["frequencyRange"] = &CalAtmosphereRow::frequencyRangeFromBin;
6361 : result["groundPressure"] = &CalAtmosphereRow::groundPressureFromBin;
6362 : result["groundRelHumidity"] = &CalAtmosphereRow::groundRelHumidityFromBin;
6363 : result["frequencySpectrum"] = &CalAtmosphereRow::frequencySpectrumFromBin;
6364 : result["groundTemperature"] = &CalAtmosphereRow::groundTemperatureFromBin;
6365 : result["polarizationTypes"] = &CalAtmosphereRow::polarizationTypesFromBin;
6366 : result["powerSkySpectrum"] = &CalAtmosphereRow::powerSkySpectrumFromBin;
6367 : result["powerLoadSpectrum"] = &CalAtmosphereRow::powerLoadSpectrumFromBin;
6368 : result["syscalType"] = &CalAtmosphereRow::syscalTypeFromBin;
6369 : result["tAtmSpectrum"] = &CalAtmosphereRow::tAtmSpectrumFromBin;
6370 : result["tRecSpectrum"] = &CalAtmosphereRow::tRecSpectrumFromBin;
6371 : result["tSysSpectrum"] = &CalAtmosphereRow::tSysSpectrumFromBin;
6372 : result["tauSpectrum"] = &CalAtmosphereRow::tauSpectrumFromBin;
6373 : result["tAtm"] = &CalAtmosphereRow::tAtmFromBin;
6374 : result["tRec"] = &CalAtmosphereRow::tRecFromBin;
6375 : result["tSys"] = &CalAtmosphereRow::tSysFromBin;
6376 : result["tau"] = &CalAtmosphereRow::tauFromBin;
6377 : result["water"] = &CalAtmosphereRow::waterFromBin;
6378 : result["waterError"] = &CalAtmosphereRow::waterErrorFromBin;
6379 :
6380 :
6381 : result["alphaSpectrum"] = &CalAtmosphereRow::alphaSpectrumFromBin;
6382 : result["forwardEfficiency"] = &CalAtmosphereRow::forwardEfficiencyFromBin;
6383 : result["forwardEfficiencyError"] = &CalAtmosphereRow::forwardEfficiencyErrorFromBin;
6384 : result["sbGain"] = &CalAtmosphereRow::sbGainFromBin;
6385 : result["sbGainError"] = &CalAtmosphereRow::sbGainErrorFromBin;
6386 : result["sbGainSpectrum"] = &CalAtmosphereRow::sbGainSpectrumFromBin;
6387 :
6388 :
6389 : return result;
6390 : }
6391 : */
6392 : } // End namespace asdm
6393 :
|
