CalPhaseRow.h

Go to the documentation of this file.
00001 
00002 /*
00003  * ALMA - Atacama Large Millimeter Array
00004  * (c) European Southern Observatory, 2002
00005  * (c) Associated Universities Inc., 2002
00006  * Copyright by ESO (in the framework of the ALMA collaboration),
00007  * Copyright by AUI (in the framework of the ALMA collaboration),
00008  * All rights reserved.
00009  * 
00010  * This library is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  * 
00015  * This library is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY, without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  * 
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with this library; if not, write to the Free Software
00022  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
00023  * MA 02111-1307  USA
00024  *
00025  * Warning!
00026  *  -------------------------------------------------------------------- 
00027  * | This is generated code!  Do not modify this file.                  |
00028  * | If you do, all changes will be lost when the file is re-generated. |
00029  *  --------------------------------------------------------------------
00030  *
00031  * File CalPhaseRow.h
00032  */
00033  
00034 #ifndef CalPhaseRow_CLASS
00035 #define CalPhaseRow_CLASS
00036 
00037 #include <vector>
00038 #include <string>
00039 #include <set>
00040 using std::vector;
00041 using std::string;
00042 using std::set;
00043 
00044 #ifndef WITHOUT_ACS
00045 #include <asdmIDLC.h>
00046 using asdmIDL::CalPhaseRowIDL;
00047 #endif
00048 
00049 
00050 
00051 
00052 
00053 
00054 #include <ArrayTime.h>
00055 using  asdm::ArrayTime;
00056 
00057 #include <Interval.h>
00058 using  asdm::Interval;
00059 
00060 #include <Angle.h>
00061 using  asdm::Angle;
00062 
00063 #include <Tag.h>
00064 using  asdm::Tag;
00065 
00066 #include <Length.h>
00067 using  asdm::Length;
00068 
00069 #include <Frequency.h>
00070 using  asdm::Frequency;
00071 
00072 
00073 
00074 
00075         
00076 #include "CBasebandName.h"
00077 using namespace BasebandNameMod;
00078         
00079 
00080         
00081 #include "CReceiverBand.h"
00082 using namespace ReceiverBandMod;
00083         
00084 
00085         
00086 #include "CAtmPhaseCorrection.h"
00087 using namespace AtmPhaseCorrectionMod;
00088         
00089 
00090         
00091 
00092         
00093 
00094         
00095 
00096         
00097 
00098         
00099 
00100         
00101 
00102         
00103 
00104         
00105 
00106         
00107 
00108         
00109 
00110         
00111 
00112         
00113 
00114         
00115 #include "CPolarizationType.h"
00116 using namespace PolarizationTypeMod;
00117         
00118 
00119         
00120 
00121         
00122 
00123         
00124 
00125 
00126 
00127 #include <ConversionException.h>
00128 #include <NoSuchRow.h>
00129 #include <IllegalAccessException.h>
00130 
00131 
00132 /*\file CalPhase.h
00133     \brief Generated from model's revision "1.55", branch "HEAD"
00134 */
00135 
00136 namespace asdm {
00137 
00138 //class asdm::CalPhaseTable;
00139 
00140 
00141 // class asdm::CalDataRow;
00142 class CalDataRow;
00143 
00144 // class asdm::CalReductionRow;
00145 class CalReductionRow;
00146         
00147 
00148 class CalPhaseRow;
00149 typedef void (CalPhaseRow::*CalPhaseAttributeFromBin) (EndianISStream& eiss);
00150 
00157 class CalPhaseRow {
00158 friend class asdm::CalPhaseTable;
00159 
00160 public:
00161 
00162         virtual ~CalPhaseRow();
00163 
00167         CalPhaseTable &getTable() const;
00168         
00173         bool isAdded() const;
00174                 
00176         // Intrinsic Table Attributes //
00178         
00179         
00180         // ===> Attribute basebandName
00181         
00182         
00183         
00184 
00185         
00190         BasebandNameMod::BasebandName getBasebandName() const;
00191         
00192  
00193         
00194         
00204         void setBasebandName (BasebandNameMod::BasebandName basebandName);
00205                 
00206         
00207         
00208         
00209 
00210 
00211         
00212         // ===> Attribute receiverBand
00213         
00214         
00215         
00216 
00217         
00222         ReceiverBandMod::ReceiverBand getReceiverBand() const;
00223         
00224  
00225         
00226         
00236         void setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand);
00237                 
00238         
00239         
00240         
00241 
00242 
00243         
00244         // ===> Attribute atmPhaseCorrection
00245         
00246         
00247         
00248 
00249         
00254         AtmPhaseCorrectionMod::AtmPhaseCorrection getAtmPhaseCorrection() const;
00255         
00256  
00257         
00258         
00268         void setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection);
00269                 
00270         
00271         
00272         
00273 
00274 
00275         
00276         // ===> Attribute startValidTime
00277         
00278         
00279         
00280 
00281         
00286         ArrayTime getStartValidTime() const;
00287         
00288  
00289         
00290         
00298         void setStartValidTime (ArrayTime startValidTime);
00299                 
00300         
00301         
00302         
00303 
00304 
00305         
00306         // ===> Attribute endValidTime
00307         
00308         
00309         
00310 
00311         
00316         ArrayTime getEndValidTime() const;
00317         
00318  
00319         
00320         
00328         void setEndValidTime (ArrayTime endValidTime);
00329                 
00330         
00331         
00332         
00333 
00334 
00335         
00336         // ===> Attribute numBaseline
00337         
00338         
00339         
00340 
00341         
00346         int getNumBaseline() const;
00347         
00348  
00349         
00350         
00358         void setNumBaseline (int numBaseline);
00359                 
00360         
00361         
00362         
00363 
00364 
00365         
00366         // ===> Attribute numReceptor
00367         
00368         
00369         
00370 
00371         
00376         int getNumReceptor() const;
00377         
00378  
00379         
00380         
00388         void setNumReceptor (int numReceptor);
00389                 
00390         
00391         
00392         
00393 
00394 
00395         
00396         // ===> Attribute ampli
00397         
00398         
00399         
00400 
00401         
00406         vector<vector<float > > getAmpli() const;
00407         
00408  
00409         
00410         
00418         void setAmpli (vector<vector<float > > ampli);
00419                 
00420         
00421         
00422         
00423 
00424 
00425         
00426         // ===> Attribute antennaNames
00427         
00428         
00429         
00430 
00431         
00436         vector<vector<string > > getAntennaNames() const;
00437         
00438  
00439         
00440         
00448         void setAntennaNames (vector<vector<string > > antennaNames);
00449                 
00450         
00451         
00452         
00453 
00454 
00455         
00456         // ===> Attribute baselineLengths
00457         
00458         
00459         
00460 
00461         
00466         vector<Length > getBaselineLengths() const;
00467         
00468  
00469         
00470         
00478         void setBaselineLengths (vector<Length > baselineLengths);
00479                 
00480         
00481         
00482         
00483 
00484 
00485         
00486         // ===> Attribute decorrelationFactor
00487         
00488         
00489         
00490 
00491         
00496         vector<vector<float > > getDecorrelationFactor() const;
00497         
00498  
00499         
00500         
00508         void setDecorrelationFactor (vector<vector<float > > decorrelationFactor);
00509                 
00510         
00511         
00512         
00513 
00514 
00515         
00516         // ===> Attribute direction
00517         
00518         
00519         
00520 
00521         
00526         vector<Angle > getDirection() const;
00527         
00528  
00529         
00530         
00538         void setDirection (vector<Angle > direction);
00539                 
00540         
00541         
00542         
00543 
00544 
00545         
00546         // ===> Attribute frequencyRange
00547         
00548         
00549         
00550 
00551         
00556         vector<Frequency > getFrequencyRange() const;
00557         
00558  
00559         
00560         
00568         void setFrequencyRange (vector<Frequency > frequencyRange);
00569                 
00570         
00571         
00572         
00573 
00574 
00575         
00576         // ===> Attribute integrationTime
00577         
00578         
00579         
00580 
00581         
00586         Interval getIntegrationTime() const;
00587         
00588  
00589         
00590         
00598         void setIntegrationTime (Interval integrationTime);
00599                 
00600         
00601         
00602         
00603 
00604 
00605         
00606         // ===> Attribute phase
00607         
00608         
00609         
00610 
00611         
00616         vector<vector<float > > getPhase() const;
00617         
00618  
00619         
00620         
00628         void setPhase (vector<vector<float > > phase);
00629                 
00630         
00631         
00632         
00633 
00634 
00635         
00636         // ===> Attribute polarizationTypes
00637         
00638         
00639         
00640 
00641         
00646         vector<PolarizationTypeMod::PolarizationType > getPolarizationTypes() const;
00647         
00648  
00649         
00650         
00658         void setPolarizationTypes (vector<PolarizationTypeMod::PolarizationType > polarizationTypes);
00659                 
00660         
00661         
00662         
00663 
00664 
00665         
00666         // ===> Attribute phaseRMS
00667         
00668         
00669         
00670 
00671         
00676         vector<vector<float > > getPhaseRMS() const;
00677         
00678  
00679         
00680         
00688         void setPhaseRMS (vector<vector<float > > phaseRMS);
00689                 
00690         
00691         
00692         
00693 
00694 
00695         
00696         // ===> Attribute statPhaseRMS
00697         
00698         
00699         
00700 
00701         
00706         vector<vector<float > > getStatPhaseRMS() const;
00707         
00708  
00709         
00710         
00718         void setStatPhaseRMS (vector<vector<float > > statPhaseRMS);
00719                 
00720         
00721         
00722         
00723 
00724 
00725         
00726         // ===> Attribute correctionValidity, which is optional
00727         
00728         
00729         
00734         bool isCorrectionValidityExists() const;
00735         
00736 
00737         
00743         vector<bool > getCorrectionValidity() const;
00744         
00745  
00746         
00747         
00754         void setCorrectionValidity (vector<bool > correctionValidity);
00755                 
00756         
00757         
00758         
00762         void clearCorrectionValidity ();
00763         
00764 
00765 
00767         // Extrinsic Table Attributes //
00769         
00770         
00771         // ===> Attribute calDataId
00772         
00773         
00774         
00775 
00776         
00781         Tag getCalDataId() const;
00782         
00783  
00784         
00785         
00795         void setCalDataId (Tag calDataId);
00796                 
00797         
00798         
00799         
00800 
00801 
00802         
00803         // ===> Attribute calReductionId
00804         
00805         
00806         
00807 
00808         
00813         Tag getCalReductionId() const;
00814         
00815  
00816         
00817         
00827         void setCalReductionId (Tag calReductionId);
00828                 
00829         
00830         
00831         
00832 
00833 
00835         // Links //
00837         
00838         
00839 
00840         
00841                 
00848          CalDataRow* getCalDataUsingCalDataId();
00849          
00850 
00851         
00852 
00853         
00854 
00855         
00856                 
00863          CalReductionRow* getCalReductionUsingCalReductionId();
00864          
00865 
00866         
00867 
00868         
00869         
00870         
00916         bool compareNoAutoInc(BasebandNameMod::BasebandName basebandName, ReceiverBandMod::ReceiverBand receiverBand, AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, int numBaseline, int numReceptor, vector<vector<float > > ampli, vector<vector<string > > antennaNames, vector<Length > baselineLengths, vector<vector<float > > decorrelationFactor, vector<Angle > direction, vector<Frequency > frequencyRange, Interval integrationTime, vector<vector<float > > phase, vector<PolarizationTypeMod::PolarizationType > polarizationTypes, vector<vector<float > > phaseRMS, vector<vector<float > > statPhaseRMS);
00917         
00918         
00919 
00920         
00956         bool compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, int numBaseline, int numReceptor, vector<vector<float > > ampli, vector<vector<string > > antennaNames, vector<Length > baselineLengths, vector<vector<float > > decorrelationFactor, vector<Angle > direction, vector<Frequency > frequencyRange, Interval integrationTime, vector<vector<float > > phase, vector<PolarizationTypeMod::PolarizationType > polarizationTypes, vector<vector<float > > phaseRMS, vector<vector<float > > statPhaseRMS); 
00957                  
00958         
00967         bool equalByRequiredValue(CalPhaseRow* x) ;
00968         
00969 #ifndef WITHOUT_ACS
00970 
00974         CalPhaseRowIDL *toIDL() const;
00975 #endif
00976         
00977 #ifndef WITHOUT_ACS
00978 
00983         void setFromIDL (CalPhaseRowIDL x) ;
00984 #endif
00985         
00990         string toXML() const;
00991 
00998         void setFromXML (string rowDoc) ;       
00999 
01000 private:
01004         CalPhaseTable &table;
01008         bool hasBeenAdded;
01009 
01010         // This method is used by the Table class when this row is added to the table.
01011         void isAdded(bool added);
01012 
01013 
01022         CalPhaseRow (CalPhaseTable &table);
01023 
01041          CalPhaseRow (CalPhaseTable &table, CalPhaseRow &row);
01042                 
01044         // Intrinsic Table Attributes //
01046         
01047         
01048         // ===> Attribute basebandName
01049         
01050         
01051 
01052         BasebandNameMod::BasebandName basebandName;
01053 
01054         
01055         
01056         
01057 
01058         
01059         // ===> Attribute receiverBand
01060         
01061         
01062 
01063         ReceiverBandMod::ReceiverBand receiverBand;
01064 
01065         
01066         
01067         
01068 
01069         
01070         // ===> Attribute atmPhaseCorrection
01071         
01072         
01073 
01074         AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection;
01075 
01076         
01077         
01078         
01079 
01080         
01081         // ===> Attribute startValidTime
01082         
01083         
01084 
01085         ArrayTime startValidTime;
01086 
01087         
01088         
01089         
01090 
01091         
01092         // ===> Attribute endValidTime
01093         
01094         
01095 
01096         ArrayTime endValidTime;
01097 
01098         
01099         
01100         
01101 
01102         
01103         // ===> Attribute numBaseline
01104         
01105         
01106 
01107         int numBaseline;
01108 
01109         
01110         
01111         
01112 
01113         
01114         // ===> Attribute numReceptor
01115         
01116         
01117 
01118         int numReceptor;
01119 
01120         
01121         
01122         
01123 
01124         
01125         // ===> Attribute ampli
01126         
01127         
01128 
01129         vector<vector<float > > ampli;
01130 
01131         
01132         
01133         
01134 
01135         
01136         // ===> Attribute antennaNames
01137         
01138         
01139 
01140         vector<vector<string > > antennaNames;
01141 
01142         
01143         
01144         
01145 
01146         
01147         // ===> Attribute baselineLengths
01148         
01149         
01150 
01151         vector<Length > baselineLengths;
01152 
01153         
01154         
01155         
01156 
01157         
01158         // ===> Attribute decorrelationFactor
01159         
01160         
01161 
01162         vector<vector<float > > decorrelationFactor;
01163 
01164         
01165         
01166         
01167 
01168         
01169         // ===> Attribute direction
01170         
01171         
01172 
01173         vector<Angle > direction;
01174 
01175         
01176         
01177         
01178 
01179         
01180         // ===> Attribute frequencyRange
01181         
01182         
01183 
01184         vector<Frequency > frequencyRange;
01185 
01186         
01187         
01188         
01189 
01190         
01191         // ===> Attribute integrationTime
01192         
01193         
01194 
01195         Interval integrationTime;
01196 
01197         
01198         
01199         
01200 
01201         
01202         // ===> Attribute phase
01203         
01204         
01205 
01206         vector<vector<float > > phase;
01207 
01208         
01209         
01210         
01211 
01212         
01213         // ===> Attribute polarizationTypes
01214         
01215         
01216 
01217         vector<PolarizationTypeMod::PolarizationType > polarizationTypes;
01218 
01219         
01220         
01221         
01222 
01223         
01224         // ===> Attribute phaseRMS
01225         
01226         
01227 
01228         vector<vector<float > > phaseRMS;
01229 
01230         
01231         
01232         
01233 
01234         
01235         // ===> Attribute statPhaseRMS
01236         
01237         
01238 
01239         vector<vector<float > > statPhaseRMS;
01240 
01241         
01242         
01243         
01244 
01245         
01246         // ===> Attribute correctionValidity, which is optional
01247         
01248         
01249         bool correctionValidityExists;
01250         
01251 
01252         vector<bool > correctionValidity;
01253 
01254         
01255         
01256         
01257 
01259         // Extrinsic Table Attributes //
01261         
01262         
01263         // ===> Attribute calDataId
01264         
01265         
01266 
01267         Tag calDataId;
01268 
01269         
01270         
01271         
01272 
01273         
01274         // ===> Attribute calReductionId
01275         
01276         
01277 
01278         Tag calReductionId;
01279 
01280         
01281         
01282         
01283 
01285         // Links //
01287         
01288         
01289                 
01290 
01291          
01292 
01293         
01294 
01295         
01296                 
01297 
01298          
01299 
01300         
01301 
01302         
01304         // binary-deserialization material//
01306         map<string, CalPhaseAttributeFromBin> fromBinMethods;
01307 void basebandNameFromBin( EndianISStream& eiss);
01308 void receiverBandFromBin( EndianISStream& eiss);
01309 void atmPhaseCorrectionFromBin( EndianISStream& eiss);
01310 void calDataIdFromBin( EndianISStream& eiss);
01311 void calReductionIdFromBin( EndianISStream& eiss);
01312 void startValidTimeFromBin( EndianISStream& eiss);
01313 void endValidTimeFromBin( EndianISStream& eiss);
01314 void numBaselineFromBin( EndianISStream& eiss);
01315 void numReceptorFromBin( EndianISStream& eiss);
01316 void ampliFromBin( EndianISStream& eiss);
01317 void antennaNamesFromBin( EndianISStream& eiss);
01318 void baselineLengthsFromBin( EndianISStream& eiss);
01319 void decorrelationFactorFromBin( EndianISStream& eiss);
01320 void directionFromBin( EndianISStream& eiss);
01321 void frequencyRangeFromBin( EndianISStream& eiss);
01322 void integrationTimeFromBin( EndianISStream& eiss);
01323 void phaseFromBin( EndianISStream& eiss);
01324 void polarizationTypesFromBin( EndianISStream& eiss);
01325 void phaseRMSFromBin( EndianISStream& eiss);
01326 void statPhaseRMSFromBin( EndianISStream& eiss);
01327 
01328 void correctionValidityFromBin( EndianISStream& eiss);
01329         
01330         
01335          void toBin(EndianOSStream& eoss);
01336                  
01344          static CalPhaseRow* fromBin(EndianISStream& eiss, CalPhaseTable& table, const vector<string>& attributesSeq);   
01345 
01346 };
01347 
01348 } // End namespace asdm
01349 
01350 #endif /* CalPhase_CLASS */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines