CalFluxRow.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 CalFluxRow.h
00032  */
00033  
00034 #ifndef CalFluxRow_CLASS
00035 #define CalFluxRow_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::CalFluxRowIDL;
00047 #endif
00048 
00049 #include <Angle.h>
00050 #include <AngularRate.h>
00051 #include <ArrayTime.h>
00052 #include <ArrayTimeInterval.h>
00053 #include <Complex.h>
00054 #include <Entity.h>
00055 #include <EntityId.h>
00056 #include <EntityRef.h>
00057 #include <Flux.h>
00058 #include <Frequency.h>
00059 #include <Humidity.h>
00060 #include <Interval.h>
00061 #include <Length.h>
00062 #include <Pressure.h>
00063 #include <Speed.h>
00064 #include <Tag.h>
00065 #include <Temperature.h>
00066 #include <ConversionException.h>
00067 #include <NoSuchRow.h>
00068 #include <IllegalAccessException.h>
00069 
00070 /*
00071 #include <Enumerations.h>
00072 using namespace enumerations;
00073  */
00074 
00075 
00076 
00077 
00078         
00079 
00080         
00081 
00082         
00083 
00084         
00085 
00086         
00087 
00088         
00089 #include "CStokesParameter.h"
00090 using namespace StokesParameterMod;
00091         
00092 
00093         
00094 
00095         
00096 
00097         
00098 
00099         
00100 
00101         
00102 
00103         
00104 
00105         
00106 #include "CFluxCalibrationMethod.h"
00107 using namespace FluxCalibrationMethodMod;
00108         
00109 
00110         
00111 
00112         
00113 #include "CSourceModel.h"
00114 using namespace SourceModelMod;
00115         
00116 
00117         
00118 
00119 
00120 
00121 using asdm::Angle;
00122 using asdm::AngularRate;
00123 using asdm::ArrayTime;
00124 using asdm::Complex;
00125 using asdm::Entity;
00126 using asdm::EntityId;
00127 using asdm::EntityRef;
00128 using asdm::Flux;
00129 using asdm::Frequency;
00130 using asdm::Humidity;
00131 using asdm::Interval;
00132 using asdm::Length;
00133 using asdm::Pressure;
00134 using asdm::Speed;
00135 using asdm::Tag;
00136 using asdm::Temperature;
00137 using asdm::ConversionException;
00138 using asdm::NoSuchRow;
00139 using asdm::IllegalAccessException;
00140 
00141 /*\file CalFlux.h
00142     \brief Generated from model's revision "1.46", branch "ALMA-5_1_1-B"
00143 */
00144 
00145 namespace asdm {
00146 
00147 //class asdm::CalFluxTable;
00148 
00149 
00150 // class asdm::CalDataRow;
00151 class CalDataRow;
00152 
00153 // class asdm::CalReductionRow;
00154 class CalReductionRow;
00155         
00156 
00163 class CalFluxRow {
00164 friend class asdm::CalFluxTable;
00165 
00166 public:
00167 
00168         virtual ~CalFluxRow();
00169 
00173         CalFluxTable &getTable() const;
00174         
00175 #ifndef WITHOUT_ACS
00176 
00180         CalFluxRowIDL *toIDL() const;
00181 #endif
00182         
00183 #ifndef WITHOUT_ACS
00184 
00188         void setFromIDL (CalFluxRowIDL x) throw(ConversionException);
00189 #endif
00190         
00195         string toXML() const;
00196 
00202         void setFromXML (string rowDoc) throw(ConversionException);
00203         
00205         // Intrinsic Table Attributes //
00207         
00208         
00209         // ===> Attribute sourceName
00210         
00211         
00212         
00213 
00214         
00219         string getSourceName() const;
00220         
00221  
00222         
00223         
00231         void setSourceName (string sourceName) throw(IllegalAccessException);
00232                 
00233         
00234         
00235         
00236 
00237 
00238         
00239         // ===> Attribute numFrequency
00240         
00241         
00242         
00243 
00244         
00249         int getNumFrequency() const;
00250         
00251  
00252         
00253         
00261         void setNumFrequency (int numFrequency) throw(IllegalAccessException);
00262                 
00263         
00264         
00265         
00266 
00267 
00268         
00269         // ===> Attribute numStokes
00270         
00271         
00272         
00273 
00274         
00279         int getNumStokes() const;
00280         
00281  
00282         
00283         
00291         void setNumStokes (int numStokes) throw(IllegalAccessException);
00292                 
00293         
00294         
00295         
00296 
00297 
00298         
00299         // ===> Attribute startValidTime
00300         
00301         
00302         
00303 
00304         
00309         ArrayTime getStartValidTime() const;
00310         
00311  
00312         
00313         
00321         void setStartValidTime (ArrayTime startValidTime) throw(IllegalAccessException);
00322                 
00323         
00324         
00325         
00326 
00327 
00328         
00329         // ===> Attribute endValidTime
00330         
00331         
00332         
00333 
00334         
00339         ArrayTime getEndValidTime() const;
00340         
00341  
00342         
00343         
00351         void setEndValidTime (ArrayTime endValidTime) throw(IllegalAccessException);
00352                 
00353         
00354         
00355         
00356 
00357 
00358         
00359         // ===> Attribute stokes
00360         
00361         
00362         
00363 
00364         
00369         vector<StokesParameterMod::StokesParameter > getStokes() const;
00370         
00371  
00372         
00373         
00381         void setStokes (vector<StokesParameterMod::StokesParameter > stokes) throw(IllegalAccessException);
00382                 
00383         
00384         
00385         
00386 
00387 
00388         
00389         // ===> Attribute flux
00390         
00391         
00392         
00393 
00394         
00399         vector<vector<double > > getFlux() const;
00400         
00401  
00402         
00403         
00411         void setFlux (vector<vector<double > > flux) throw(IllegalAccessException);
00412                 
00413         
00414         
00415         
00416 
00417 
00418         
00419         // ===> Attribute fluxError
00420         
00421         
00422         
00423 
00424         
00429         vector<vector<double > > getFluxError() const;
00430         
00431  
00432         
00433         
00441         void setFluxError (vector<vector<double > > fluxError) throw(IllegalAccessException);
00442                 
00443         
00444         
00445         
00446 
00447 
00448         
00449         // ===> Attribute size, which is optional
00450         
00451         
00452         
00457         bool isSizeExists() const;
00458         
00459 
00460         
00466         vector<vector<vector<Angle > > > getSize() const throw(IllegalAccessException);
00467         
00468  
00469         
00470         
00477         void setSize (vector<vector<vector<Angle > > > size);
00478                 
00479         
00480         
00481         
00485         void clearSize ();
00486         
00487 
00488 
00489         
00490         // ===> Attribute sizeError, which is optional
00491         
00492         
00493         
00498         bool isSizeErrorExists() const;
00499         
00500 
00501         
00507         vector<vector<vector<Angle > > > getSizeError() const throw(IllegalAccessException);
00508         
00509  
00510         
00511         
00518         void setSizeError (vector<vector<vector<Angle > > > sizeError);
00519                 
00520         
00521         
00522         
00526         void clearSizeError ();
00527         
00528 
00529 
00530         
00531         // ===> Attribute PA, which is optional
00532         
00533         
00534         
00539         bool isPAExists() const;
00540         
00541 
00542         
00548         vector<vector<Angle > > getPA() const throw(IllegalAccessException);
00549         
00550  
00551         
00552         
00559         void setPA (vector<vector<Angle > > PA);
00560                 
00561         
00562         
00563         
00567         void clearPA ();
00568         
00569 
00570 
00571         
00572         // ===> Attribute PAError, which is optional
00573         
00574         
00575         
00580         bool isPAErrorExists() const;
00581         
00582 
00583         
00589         vector<vector<Angle > > getPAError() const throw(IllegalAccessException);
00590         
00591  
00592         
00593         
00600         void setPAError (vector<vector<Angle > > PAError);
00601                 
00602         
00603         
00604         
00608         void clearPAError ();
00609         
00610 
00611 
00612         
00613         // ===> Attribute fluxMethod
00614         
00615         
00616         
00617 
00618         
00623         FluxCalibrationMethodMod::FluxCalibrationMethod getFluxMethod() const;
00624         
00625  
00626         
00627         
00635         void setFluxMethod (FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod) throw(IllegalAccessException);
00636                 
00637         
00638         
00639         
00640 
00641 
00642         
00643         // ===> Attribute direction, which is optional
00644         
00645         
00646         
00651         bool isDirectionExists() const;
00652         
00653 
00654         
00660         vector<Angle > getDirection() const throw(IllegalAccessException);
00661         
00662  
00663         
00664         
00671         void setDirection (vector<Angle > direction);
00672                 
00673         
00674         
00675         
00679         void clearDirection ();
00680         
00681 
00682 
00683         
00684         // ===> Attribute sourceModel, which is optional
00685         
00686         
00687         
00692         bool isSourceModelExists() const;
00693         
00694 
00695         
00701         SourceModelMod::SourceModel getSourceModel() const throw(IllegalAccessException);
00702         
00703  
00704         
00705         
00712         void setSourceModel (SourceModelMod::SourceModel sourceModel);
00713                 
00714         
00715         
00716         
00720         void clearSourceModel ();
00721         
00722 
00723 
00724         
00725         // ===> Attribute frequencyRange
00726         
00727         
00728         
00729 
00730         
00735         vector<Frequency > getFrequencyRange() const;
00736         
00737  
00738         
00739         
00747         void setFrequencyRange (vector<Frequency > frequencyRange) throw(IllegalAccessException);
00748                 
00749         
00750         
00751         
00752 
00753 
00755         // Extrinsic Table Attributes //
00757         
00758         
00759         // ===> Attribute calDataId
00760         
00761         
00762         
00763 
00764         
00769         Tag getCalDataId() const;
00770         
00771  
00772         
00773         
00781         void setCalDataId (Tag calDataId) throw(IllegalAccessException);
00782                 
00783         
00784         
00785         
00786 
00787 
00788         
00789         // ===> Attribute calReductionId
00790         
00791         
00792         
00793 
00794         
00799         Tag getCalReductionId() const;
00800         
00801  
00802         
00803         
00811         void setCalReductionId (Tag calReductionId) throw(IllegalAccessException);
00812                 
00813         
00814         
00815         
00816 
00817 
00819         // Links //
00821         
00822         
00823 
00824         
00825                 
00832          CalDataRow* getCalDataUsingCalDataId();
00833          
00834 
00835         
00836 
00837         
00838 
00839         
00840                 
00847          CalReductionRow* getCalReductionUsingCalReductionId();
00848          
00849 
00850         
00851 
00852         
00853         
00854         
00859         bool compareNoAutoInc(Tag calDataId, Tag calReductionId, string sourceName, int numFrequency, int numStokes, ArrayTime startValidTime, ArrayTime endValidTime, vector<StokesParameterMod::StokesParameter > stokes, vector<vector<double > > flux, vector<vector<double > > fluxError, FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod, vector<Frequency > frequencyRange);
00860         
00861         
00862 
00863         
00864         bool compareRequiredValue(int numFrequency, int numStokes, ArrayTime startValidTime, ArrayTime endValidTime, vector<StokesParameterMod::StokesParameter > stokes, vector<vector<double > > flux, vector<vector<double > > fluxError, FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod, vector<Frequency > frequencyRange); 
00865                  
00866         
00875         bool equalByRequiredValue(CalFluxRow* x) ;
00876 
00877 private:
00881         CalFluxTable &table;
00885         bool hasBeenAdded;
00886 
00887         // This method is used by the Table class when this row is added to the table.
00888         void isAdded();
00889 
00890 
00899         CalFluxRow (CalFluxTable &table);
00900 
00918          CalFluxRow (CalFluxTable &table, CalFluxRow &row);
00919                 
00921         // Intrinsic Table Attributes //
00923         
00924         
00925         // ===> Attribute sourceName
00926         
00927         
00928 
00929         string sourceName;
00930 
00931         
00932         
00933         
00934 
00935         
00936         // ===> Attribute numFrequency
00937         
00938         
00939 
00940         int numFrequency;
00941 
00942         
00943         
00944         
00945 
00946         
00947         // ===> Attribute numStokes
00948         
00949         
00950 
00951         int numStokes;
00952 
00953         
00954         
00955         
00956 
00957         
00958         // ===> Attribute startValidTime
00959         
00960         
00961 
00962         ArrayTime startValidTime;
00963 
00964         
00965         
00966         
00967 
00968         
00969         // ===> Attribute endValidTime
00970         
00971         
00972 
00973         ArrayTime endValidTime;
00974 
00975         
00976         
00977         
00978 
00979         
00980         // ===> Attribute stokes
00981         
00982         
00983 
00984         vector<StokesParameterMod::StokesParameter > stokes;
00985 
00986         
00987         
00988         
00989 
00990         
00991         // ===> Attribute flux
00992         
00993         
00994 
00995         vector<vector<double > > flux;
00996 
00997         
00998         
00999         
01000 
01001         
01002         // ===> Attribute fluxError
01003         
01004         
01005 
01006         vector<vector<double > > fluxError;
01007 
01008         
01009         
01010         
01011 
01012         
01013         // ===> Attribute size, which is optional
01014         
01015         
01016         bool sizeExists;
01017         
01018 
01019         vector<vector<vector<Angle > > > size;
01020 
01021         
01022         
01023         
01024 
01025         
01026         // ===> Attribute sizeError, which is optional
01027         
01028         
01029         bool sizeErrorExists;
01030         
01031 
01032         vector<vector<vector<Angle > > > sizeError;
01033 
01034         
01035         
01036         
01037 
01038         
01039         // ===> Attribute PA, which is optional
01040         
01041         
01042         bool PAExists;
01043         
01044 
01045         vector<vector<Angle > > PA;
01046 
01047         
01048         
01049         
01050 
01051         
01052         // ===> Attribute PAError, which is optional
01053         
01054         
01055         bool PAErrorExists;
01056         
01057 
01058         vector<vector<Angle > > PAError;
01059 
01060         
01061         
01062         
01063 
01064         
01065         // ===> Attribute fluxMethod
01066         
01067         
01068 
01069         FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod;
01070 
01071         
01072         
01073         
01074 
01075         
01076         // ===> Attribute direction, which is optional
01077         
01078         
01079         bool directionExists;
01080         
01081 
01082         vector<Angle > direction;
01083 
01084         
01085         
01086         
01087 
01088         
01089         // ===> Attribute sourceModel, which is optional
01090         
01091         
01092         bool sourceModelExists;
01093         
01094 
01095         SourceModelMod::SourceModel sourceModel;
01096 
01097         
01098         
01099         
01100 
01101         
01102         // ===> Attribute frequencyRange
01103         
01104         
01105 
01106         vector<Frequency > frequencyRange;
01107 
01108         
01109         
01110         
01111 
01113         // Extrinsic Table Attributes //
01115         
01116         
01117         // ===> Attribute calDataId
01118         
01119         
01120 
01121         Tag calDataId;
01122 
01123         
01124         
01125         
01126 
01127         
01128         // ===> Attribute calReductionId
01129         
01130         
01131 
01132         Tag calReductionId;
01133 
01134         
01135         
01136         
01137 
01139         // Links //
01141         
01142         
01143                 
01144 
01145          
01146 
01147         
01148 
01149         
01150                 
01151 
01152          
01153 
01154         
01155 
01156 
01157 };
01158 
01159 } // End namespace asdm
01160 
01161 #endif /* CalFlux_CLASS */

Generated on Mon Sep 1 22:33:01 2008 for NRAOCASA by  doxygen 1.5.1