LCOV - code coverage report
Current view: top level - alma/ASDM - CalWVRRow.cc (source / functions) Hit Total Coverage
Test: ctest_coverage.info Lines: 0 543 0.0 %
Date: 2023-11-06 10:06:49 Functions: 0 95 0.0 %

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

Generated by: LCOV version 1.16