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 
00050 
00051 
00052 
00053 
00054 #include <ArrayTime.h>
00055 using  asdm::ArrayTime;
00056 
00057 #include <Angle.h>
00058 using  asdm::Angle;
00059 
00060 #include <Tag.h>
00061 using  asdm::Tag;
00062 
00063 #include <Frequency.h>
00064 using  asdm::Frequency;
00065 
00066 
00067 
00068 
00069         
00070 
00071         
00072 
00073         
00074 
00075         
00076 
00077         
00078 
00079         
00080 
00081         
00082 #include "CFluxCalibrationMethod.h"
00083 using namespace FluxCalibrationMethodMod;
00084         
00085 
00086         
00087 
00088         
00089 
00090         
00091 #include "CStokesParameter.h"
00092 using namespace StokesParameterMod;
00093         
00094 
00095         
00096 
00097         
00098 #include "CDirectionReferenceCode.h"
00099 using namespace DirectionReferenceCodeMod;
00100         
00101 
00102         
00103 
00104         
00105 
00106         
00107 
00108         
00109 
00110         
00111 
00112         
00113 #include "CSourceModel.h"
00114 using namespace SourceModelMod;
00115         
00116 
00117 
00118 
00119 #include <ConversionException.h>
00120 #include <NoSuchRow.h>
00121 #include <IllegalAccessException.h>
00122 
00123 
00124 /*\file CalFlux.h
00125     \brief Generated from model's revision "1.55", branch "HEAD"
00126 */
00127 
00128 namespace asdm {
00129 
00130 //class asdm::CalFluxTable;
00131 
00132 
00133 // class asdm::CalDataRow;
00134 class CalDataRow;
00135 
00136 // class asdm::CalReductionRow;
00137 class CalReductionRow;
00138         
00139 
00140 class CalFluxRow;
00141 typedef void (CalFluxRow::*CalFluxAttributeFromBin) (EndianISStream& eiss);
00142 
00149 class CalFluxRow {
00150 friend class asdm::CalFluxTable;
00151 
00152 public:
00153 
00154         virtual ~CalFluxRow();
00155 
00159         CalFluxTable &getTable() const;
00160         
00165         bool isAdded() const;
00166                 
00168         // Intrinsic Table Attributes //
00170         
00171         
00172         // ===> Attribute sourceName
00173         
00174         
00175         
00176 
00177         
00182         string getSourceName() const;
00183         
00184  
00185         
00186         
00196         void setSourceName (string sourceName);
00197                 
00198         
00199         
00200         
00201 
00202 
00203         
00204         // ===> Attribute startValidTime
00205         
00206         
00207         
00208 
00209         
00214         ArrayTime getStartValidTime() const;
00215         
00216  
00217         
00218         
00226         void setStartValidTime (ArrayTime startValidTime);
00227                 
00228         
00229         
00230         
00231 
00232 
00233         
00234         // ===> Attribute endValidTime
00235         
00236         
00237         
00238 
00239         
00244         ArrayTime getEndValidTime() const;
00245         
00246  
00247         
00248         
00256         void setEndValidTime (ArrayTime endValidTime);
00257                 
00258         
00259         
00260         
00261 
00262 
00263         
00264         // ===> Attribute numFrequencyRanges
00265         
00266         
00267         
00268 
00269         
00274         int getNumFrequencyRanges() const;
00275         
00276  
00277         
00278         
00286         void setNumFrequencyRanges (int numFrequencyRanges);
00287                 
00288         
00289         
00290         
00291 
00292 
00293         
00294         // ===> Attribute numStokes
00295         
00296         
00297         
00298 
00299         
00304         int getNumStokes() const;
00305         
00306  
00307         
00308         
00316         void setNumStokes (int numStokes);
00317                 
00318         
00319         
00320         
00321 
00322 
00323         
00324         // ===> Attribute frequencyRanges
00325         
00326         
00327         
00328 
00329         
00334         vector<vector<Frequency > > getFrequencyRanges() const;
00335         
00336  
00337         
00338         
00346         void setFrequencyRanges (vector<vector<Frequency > > frequencyRanges);
00347                 
00348         
00349         
00350         
00351 
00352 
00353         
00354         // ===> Attribute fluxMethod
00355         
00356         
00357         
00358 
00359         
00364         FluxCalibrationMethodMod::FluxCalibrationMethod getFluxMethod() const;
00365         
00366  
00367         
00368         
00376         void setFluxMethod (FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod);
00377                 
00378         
00379         
00380         
00381 
00382 
00383         
00384         // ===> Attribute flux
00385         
00386         
00387         
00388 
00389         
00394         vector<vector<double > > getFlux() const;
00395         
00396  
00397         
00398         
00406         void setFlux (vector<vector<double > > flux);
00407                 
00408         
00409         
00410         
00411 
00412 
00413         
00414         // ===> Attribute fluxError
00415         
00416         
00417         
00418 
00419         
00424         vector<vector<double > > getFluxError() const;
00425         
00426  
00427         
00428         
00436         void setFluxError (vector<vector<double > > fluxError);
00437                 
00438         
00439         
00440         
00441 
00442 
00443         
00444         // ===> Attribute stokes
00445         
00446         
00447         
00448 
00449         
00454         vector<StokesParameterMod::StokesParameter > getStokes() const;
00455         
00456  
00457         
00458         
00466         void setStokes (vector<StokesParameterMod::StokesParameter > stokes);
00467                 
00468         
00469         
00470         
00471 
00472 
00473         
00474         // ===> Attribute direction, which is optional
00475         
00476         
00477         
00482         bool isDirectionExists() const;
00483         
00484 
00485         
00491         vector<Angle > getDirection() const;
00492         
00493  
00494         
00495         
00502         void setDirection (vector<Angle > direction);
00503                 
00504         
00505         
00506         
00510         void clearDirection ();
00511         
00512 
00513 
00514         
00515         // ===> Attribute directionCode, which is optional
00516         
00517         
00518         
00523         bool isDirectionCodeExists() const;
00524         
00525 
00526         
00532         DirectionReferenceCodeMod::DirectionReferenceCode getDirectionCode() const;
00533         
00534  
00535         
00536         
00543         void setDirectionCode (DirectionReferenceCodeMod::DirectionReferenceCode directionCode);
00544                 
00545         
00546         
00547         
00551         void clearDirectionCode ();
00552         
00553 
00554 
00555         
00556         // ===> Attribute directionEquinox, which is optional
00557         
00558         
00559         
00564         bool isDirectionEquinoxExists() const;
00565         
00566 
00567         
00573         Angle getDirectionEquinox() const;
00574         
00575  
00576         
00577         
00584         void setDirectionEquinox (Angle directionEquinox);
00585                 
00586         
00587         
00588         
00592         void clearDirectionEquinox ();
00593         
00594 
00595 
00596         
00597         // ===> Attribute PA, which is optional
00598         
00599         
00600         
00605         bool isPAExists() const;
00606         
00607 
00608         
00614         vector<vector<Angle > > getPA() const;
00615         
00616  
00617         
00618         
00625         void setPA (vector<vector<Angle > > PA);
00626                 
00627         
00628         
00629         
00633         void clearPA ();
00634         
00635 
00636 
00637         
00638         // ===> Attribute PAError, which is optional
00639         
00640         
00641         
00646         bool isPAErrorExists() const;
00647         
00648 
00649         
00655         vector<vector<Angle > > getPAError() const;
00656         
00657  
00658         
00659         
00666         void setPAError (vector<vector<Angle > > PAError);
00667                 
00668         
00669         
00670         
00674         void clearPAError ();
00675         
00676 
00677 
00678         
00679         // ===> Attribute size, which is optional
00680         
00681         
00682         
00687         bool isSizeExists() const;
00688         
00689 
00690         
00696         vector<vector<vector<Angle > > > getSize() const;
00697         
00698  
00699         
00700         
00707         void setSize (vector<vector<vector<Angle > > > size);
00708                 
00709         
00710         
00711         
00715         void clearSize ();
00716         
00717 
00718 
00719         
00720         // ===> Attribute sizeError, which is optional
00721         
00722         
00723         
00728         bool isSizeErrorExists() const;
00729         
00730 
00731         
00737         vector<vector<vector<Angle > > > getSizeError() const;
00738         
00739  
00740         
00741         
00748         void setSizeError (vector<vector<vector<Angle > > > sizeError);
00749                 
00750         
00751         
00752         
00756         void clearSizeError ();
00757         
00758 
00759 
00760         
00761         // ===> Attribute sourceModel, which is optional
00762         
00763         
00764         
00769         bool isSourceModelExists() const;
00770         
00771 
00772         
00778         SourceModelMod::SourceModel getSourceModel() const;
00779         
00780  
00781         
00782         
00789         void setSourceModel (SourceModelMod::SourceModel sourceModel);
00790                 
00791         
00792         
00793         
00797         void clearSourceModel ();
00798         
00799 
00800 
00802         // Extrinsic Table Attributes //
00804         
00805         
00806         // ===> Attribute calDataId
00807         
00808         
00809         
00810 
00811         
00816         Tag getCalDataId() const;
00817         
00818  
00819         
00820         
00830         void setCalDataId (Tag calDataId);
00831                 
00832         
00833         
00834         
00835 
00836 
00837         
00838         // ===> Attribute calReductionId
00839         
00840         
00841         
00842 
00843         
00848         Tag getCalReductionId() const;
00849         
00850  
00851         
00852         
00862         void setCalReductionId (Tag calReductionId);
00863                 
00864         
00865         
00866         
00867 
00868 
00870         // Links //
00872         
00873         
00874 
00875         
00876                 
00883          CalDataRow* getCalDataUsingCalDataId();
00884          
00885 
00886         
00887 
00888         
00889 
00890         
00891                 
00898          CalReductionRow* getCalReductionUsingCalReductionId();
00899          
00900 
00901         
00902 
00903         
00904         
00905         
00935         bool compareNoAutoInc(string sourceName, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, int numFrequencyRanges, int numStokes, vector<vector<Frequency > > frequencyRanges, FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod, vector<vector<double > > flux, vector<vector<double > > fluxError, vector<StokesParameterMod::StokesParameter > stokes);
00936         
00937         
00938 
00939         
00963         bool compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, int numFrequencyRanges, int numStokes, vector<vector<Frequency > > frequencyRanges, FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod, vector<vector<double > > flux, vector<vector<double > > fluxError, vector<StokesParameterMod::StokesParameter > stokes); 
00964                  
00965         
00974         bool equalByRequiredValue(CalFluxRow* x) ;
00975         
00976 #ifndef WITHOUT_ACS
00977 
00981         CalFluxRowIDL *toIDL() const;
00982 #endif
00983         
00984 #ifndef WITHOUT_ACS
00985 
00990         void setFromIDL (CalFluxRowIDL x) ;
00991 #endif
00992         
00997         string toXML() const;
00998 
01005         void setFromXML (string rowDoc) ;       
01006 
01007 private:
01011         CalFluxTable &table;
01015         bool hasBeenAdded;
01016 
01017         // This method is used by the Table class when this row is added to the table.
01018         void isAdded(bool added);
01019 
01020 
01029         CalFluxRow (CalFluxTable &table);
01030 
01048          CalFluxRow (CalFluxTable &table, CalFluxRow &row);
01049                 
01051         // Intrinsic Table Attributes //
01053         
01054         
01055         // ===> Attribute sourceName
01056         
01057         
01058 
01059         string sourceName;
01060 
01061         
01062         
01063         
01064 
01065         
01066         // ===> Attribute startValidTime
01067         
01068         
01069 
01070         ArrayTime startValidTime;
01071 
01072         
01073         
01074         
01075 
01076         
01077         // ===> Attribute endValidTime
01078         
01079         
01080 
01081         ArrayTime endValidTime;
01082 
01083         
01084         
01085         
01086 
01087         
01088         // ===> Attribute numFrequencyRanges
01089         
01090         
01091 
01092         int numFrequencyRanges;
01093 
01094         
01095         
01096         
01097 
01098         
01099         // ===> Attribute numStokes
01100         
01101         
01102 
01103         int numStokes;
01104 
01105         
01106         
01107         
01108 
01109         
01110         // ===> Attribute frequencyRanges
01111         
01112         
01113 
01114         vector<vector<Frequency > > frequencyRanges;
01115 
01116         
01117         
01118         
01119 
01120         
01121         // ===> Attribute fluxMethod
01122         
01123         
01124 
01125         FluxCalibrationMethodMod::FluxCalibrationMethod fluxMethod;
01126 
01127         
01128         
01129         
01130 
01131         
01132         // ===> Attribute flux
01133         
01134         
01135 
01136         vector<vector<double > > flux;
01137 
01138         
01139         
01140         
01141 
01142         
01143         // ===> Attribute fluxError
01144         
01145         
01146 
01147         vector<vector<double > > fluxError;
01148 
01149         
01150         
01151         
01152 
01153         
01154         // ===> Attribute stokes
01155         
01156         
01157 
01158         vector<StokesParameterMod::StokesParameter > stokes;
01159 
01160         
01161         
01162         
01163 
01164         
01165         // ===> Attribute direction, which is optional
01166         
01167         
01168         bool directionExists;
01169         
01170 
01171         vector<Angle > direction;
01172 
01173         
01174         
01175         
01176 
01177         
01178         // ===> Attribute directionCode, which is optional
01179         
01180         
01181         bool directionCodeExists;
01182         
01183 
01184         DirectionReferenceCodeMod::DirectionReferenceCode directionCode;
01185 
01186         
01187         
01188         
01189 
01190         
01191         // ===> Attribute directionEquinox, which is optional
01192         
01193         
01194         bool directionEquinoxExists;
01195         
01196 
01197         Angle directionEquinox;
01198 
01199         
01200         
01201         
01202 
01203         
01204         // ===> Attribute PA, which is optional
01205         
01206         
01207         bool PAExists;
01208         
01209 
01210         vector<vector<Angle > > PA;
01211 
01212         
01213         
01214         
01215 
01216         
01217         // ===> Attribute PAError, which is optional
01218         
01219         
01220         bool PAErrorExists;
01221         
01222 
01223         vector<vector<Angle > > PAError;
01224 
01225         
01226         
01227         
01228 
01229         
01230         // ===> Attribute size, which is optional
01231         
01232         
01233         bool sizeExists;
01234         
01235 
01236         vector<vector<vector<Angle > > > size;
01237 
01238         
01239         
01240         
01241 
01242         
01243         // ===> Attribute sizeError, which is optional
01244         
01245         
01246         bool sizeErrorExists;
01247         
01248 
01249         vector<vector<vector<Angle > > > sizeError;
01250 
01251         
01252         
01253         
01254 
01255         
01256         // ===> Attribute sourceModel, which is optional
01257         
01258         
01259         bool sourceModelExists;
01260         
01261 
01262         SourceModelMod::SourceModel sourceModel;
01263 
01264         
01265         
01266         
01267 
01269         // Extrinsic Table Attributes //
01271         
01272         
01273         // ===> Attribute calDataId
01274         
01275         
01276 
01277         Tag calDataId;
01278 
01279         
01280         
01281         
01282 
01283         
01284         // ===> Attribute calReductionId
01285         
01286         
01287 
01288         Tag calReductionId;
01289 
01290         
01291         
01292         
01293 
01295         // Links //
01297         
01298         
01299                 
01300 
01301          
01302 
01303         
01304 
01305         
01306                 
01307 
01308          
01309 
01310         
01311 
01312         
01314         // binary-deserialization material//
01316         map<string, CalFluxAttributeFromBin> fromBinMethods;
01317 void sourceNameFromBin( EndianISStream& eiss);
01318 void calDataIdFromBin( EndianISStream& eiss);
01319 void calReductionIdFromBin( EndianISStream& eiss);
01320 void startValidTimeFromBin( EndianISStream& eiss);
01321 void endValidTimeFromBin( EndianISStream& eiss);
01322 void numFrequencyRangesFromBin( EndianISStream& eiss);
01323 void numStokesFromBin( EndianISStream& eiss);
01324 void frequencyRangesFromBin( EndianISStream& eiss);
01325 void fluxMethodFromBin( EndianISStream& eiss);
01326 void fluxFromBin( EndianISStream& eiss);
01327 void fluxErrorFromBin( EndianISStream& eiss);
01328 void stokesFromBin( EndianISStream& eiss);
01329 
01330 void directionFromBin( EndianISStream& eiss);
01331 void directionCodeFromBin( EndianISStream& eiss);
01332 void directionEquinoxFromBin( EndianISStream& eiss);
01333 void PAFromBin( EndianISStream& eiss);
01334 void PAErrorFromBin( EndianISStream& eiss);
01335 void sizeFromBin( EndianISStream& eiss);
01336 void sizeErrorFromBin( EndianISStream& eiss);
01337 void sourceModelFromBin( EndianISStream& eiss);
01338         
01339         
01344          void toBin(EndianOSStream& eoss);
01345                  
01353          static CalFluxRow* fromBin(EndianISStream& eiss, CalFluxTable& table, const vector<string>& attributesSeq);     
01354 
01355 };
01356 
01357 } // End namespace asdm
01358 
01359 #endif /* CalFlux_CLASS */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines