CalFocusRow.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 CalFocusRow.h
00032  */
00033  
00034 #ifndef CalFocusRow_CLASS
00035 #define CalFocusRow_CLASS
00036 
00037 #include <vector>
00038 #include <string>
00039 #include <set>
00040 
00041 #ifndef WITHOUT_ACS
00042 #include <asdmIDLC.h>
00043 #endif
00044 
00045 
00046 
00047 
00048 
00049 
00050          
00051 #include <ArrayTime.h>
00052         
00053 
00054          
00055 #include <Temperature.h>
00056         
00057 
00058          
00059 #include <Angle.h>
00060         
00061 
00062          
00063 #include <Tag.h>
00064         
00065 
00066          
00067 #include <Length.h>
00068         
00069 
00070          
00071 #include <Frequency.h>
00072         
00073 
00074 
00075 
00076 
00077         
00078 
00079         
00080 
00081         
00082 
00083         
00084 #include "CReceiverBand.h"
00085         
00086 
00087         
00088 
00089         
00090 #include "CAtmPhaseCorrection.h"
00091         
00092 
00093         
00094 #include "CFocusMethod.h"
00095         
00096 
00097         
00098 
00099         
00100 
00101         
00102 
00103         
00104 #include "CPolarizationType.h"
00105         
00106 
00107         
00108 
00109         
00110 
00111         
00112 
00113         
00114 
00115         
00116 
00117         
00118 
00119         
00120 
00121         
00122 
00123         
00124 
00125         
00126 
00127         
00128 
00129         
00130 
00131         
00132 
00133         
00134 
00135         
00136 
00137         
00138 
00139         
00140 
00141         
00142 
00143         
00144 
00145         
00146 
00147         
00148 
00149         
00150 
00151         
00152 
00153 
00154 
00155 #include <ConversionException.h>
00156 #include <NoSuchRow.h>
00157 #include <IllegalAccessException.h>
00158 
00159 #include <RowTransformer.h>
00160 //#include <TableStreamReader.h>
00161 
00162 /*\file CalFocus.h
00163     \brief Generated from model's revision "-1", branch ""
00164 */
00165 
00166 namespace asdm {
00167 
00168 //class asdm::CalFocusTable;
00169 
00170 
00171 // class asdm::CalDataRow;
00172 class CalDataRow;
00173 
00174 // class asdm::CalReductionRow;
00175 class CalReductionRow;
00176         
00177 
00178 class CalFocusRow;
00179 typedef void (CalFocusRow::*CalFocusAttributeFromBin) (EndianIStream& eis);
00180 typedef void (CalFocusRow::*CalFocusAttributeFromText) (const string& s);
00181 
00188 class CalFocusRow {
00189 friend class asdm::CalFocusTable;
00190 friend class asdm::RowTransformer<CalFocusRow>;
00191 //friend class asdm::TableStreamReader<CalFocusTable, CalFocusRow>;
00192 
00193 public:
00194 
00195         virtual ~CalFocusRow();
00196 
00200         CalFocusTable &getTable() const;
00201         
00206         bool isAdded() const;
00207                 
00209         // Intrinsic Table Attributes //
00211         
00212         
00213         // ===> Attribute startValidTime
00214         
00215         
00216         
00217 
00218         
00223         ArrayTime getStartValidTime() const;
00224         
00225  
00226         
00227         
00235         void setStartValidTime (ArrayTime startValidTime);
00236                 
00237         
00238         
00239         
00240 
00241 
00242         
00243         // ===> Attribute endValidTime
00244         
00245         
00246         
00247 
00248         
00253         ArrayTime getEndValidTime() const;
00254         
00255  
00256         
00257         
00265         void setEndValidTime (ArrayTime endValidTime);
00266                 
00267         
00268         
00269         
00270 
00271 
00272         
00273         // ===> Attribute antennaName
00274         
00275         
00276         
00277 
00278         
00283         string getAntennaName() const;
00284         
00285  
00286         
00287         
00297         void setAntennaName (string antennaName);
00298                 
00299         
00300         
00301         
00302 
00303 
00304         
00305         // ===> Attribute receiverBand
00306         
00307         
00308         
00309 
00310         
00315         ReceiverBandMod::ReceiverBand getReceiverBand() const;
00316         
00317  
00318         
00319         
00329         void setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand);
00330                 
00331         
00332         
00333         
00334 
00335 
00336         
00337         // ===> Attribute ambientTemperature
00338         
00339         
00340         
00341 
00342         
00347         Temperature getAmbientTemperature() const;
00348         
00349  
00350         
00351         
00359         void setAmbientTemperature (Temperature ambientTemperature);
00360                 
00361         
00362         
00363         
00364 
00365 
00366         
00367         // ===> Attribute atmPhaseCorrection
00368         
00369         
00370         
00371 
00372         
00377         AtmPhaseCorrectionMod::AtmPhaseCorrection getAtmPhaseCorrection() const;
00378         
00379  
00380         
00381         
00389         void setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection);
00390                 
00391         
00392         
00393         
00394 
00395 
00396         
00397         // ===> Attribute focusMethod
00398         
00399         
00400         
00401 
00402         
00407         FocusMethodMod::FocusMethod getFocusMethod() const;
00408         
00409  
00410         
00411         
00419         void setFocusMethod (FocusMethodMod::FocusMethod focusMethod);
00420                 
00421         
00422         
00423         
00424 
00425 
00426         
00427         // ===> Attribute frequencyRange
00428         
00429         
00430         
00431 
00432         
00437         vector<Frequency > getFrequencyRange() const;
00438         
00439  
00440         
00441         
00449         void setFrequencyRange (vector<Frequency > frequencyRange);
00450                 
00451         
00452         
00453         
00454 
00455 
00456         
00457         // ===> Attribute pointingDirection
00458         
00459         
00460         
00461 
00462         
00467         vector<Angle > getPointingDirection() const;
00468         
00469  
00470         
00471         
00479         void setPointingDirection (vector<Angle > pointingDirection);
00480                 
00481         
00482         
00483         
00484 
00485 
00486         
00487         // ===> Attribute numReceptor
00488         
00489         
00490         
00491 
00492         
00497         int getNumReceptor() const;
00498         
00499  
00500         
00501         
00509         void setNumReceptor (int numReceptor);
00510                 
00511         
00512         
00513         
00514 
00515 
00516         
00517         // ===> Attribute polarizationTypes
00518         
00519         
00520         
00521 
00522         
00527         vector<PolarizationTypeMod::PolarizationType > getPolarizationTypes() const;
00528         
00529  
00530         
00531         
00539         void setPolarizationTypes (vector<PolarizationTypeMod::PolarizationType > polarizationTypes);
00540                 
00541         
00542         
00543         
00544 
00545 
00546         
00547         // ===> Attribute wereFixed
00548         
00549         
00550         
00551 
00552         
00557         vector<bool > getWereFixed() const;
00558         
00559  
00560         
00561         
00569         void setWereFixed (vector<bool > wereFixed);
00570                 
00571         
00572         
00573         
00574 
00575 
00576         
00577         // ===> Attribute offset
00578         
00579         
00580         
00581 
00582         
00587         vector<vector<Length > > getOffset() const;
00588         
00589  
00590         
00591         
00599         void setOffset (vector<vector<Length > > offset);
00600                 
00601         
00602         
00603         
00604 
00605 
00606         
00607         // ===> Attribute offsetError
00608         
00609         
00610         
00611 
00612         
00617         vector<vector<Length > > getOffsetError() const;
00618         
00619  
00620         
00621         
00629         void setOffsetError (vector<vector<Length > > offsetError);
00630                 
00631         
00632         
00633         
00634 
00635 
00636         
00637         // ===> Attribute offsetWasTied
00638         
00639         
00640         
00641 
00642         
00647         vector<vector<bool > > getOffsetWasTied() const;
00648         
00649  
00650         
00651         
00659         void setOffsetWasTied (vector<vector<bool > > offsetWasTied);
00660                 
00661         
00662         
00663         
00664 
00665 
00666         
00667         // ===> Attribute reducedChiSquared
00668         
00669         
00670         
00671 
00672         
00677         vector<vector<double > > getReducedChiSquared() const;
00678         
00679  
00680         
00681         
00689         void setReducedChiSquared (vector<vector<double > > reducedChiSquared);
00690                 
00691         
00692         
00693         
00694 
00695 
00696         
00697         // ===> Attribute position
00698         
00699         
00700         
00701 
00702         
00707         vector<vector<Length > > getPosition() const;
00708         
00709  
00710         
00711         
00719         void setPosition (vector<vector<Length > > position);
00720                 
00721         
00722         
00723         
00724 
00725 
00726         
00727         // ===> Attribute polarizationsAveraged, which is optional
00728         
00729         
00730         
00735         bool isPolarizationsAveragedExists() const;
00736         
00737 
00738         
00744         bool getPolarizationsAveraged() const;
00745         
00746  
00747         
00748         
00755         void setPolarizationsAveraged (bool polarizationsAveraged);
00756                 
00757         
00758         
00759         
00763         void clearPolarizationsAveraged ();
00764         
00765 
00766 
00767         
00768         // ===> Attribute focusCurveWidth, which is optional
00769         
00770         
00771         
00776         bool isFocusCurveWidthExists() const;
00777         
00778 
00779         
00785         vector<vector<Length > > getFocusCurveWidth() const;
00786         
00787  
00788         
00789         
00796         void setFocusCurveWidth (vector<vector<Length > > focusCurveWidth);
00797                 
00798         
00799         
00800         
00804         void clearFocusCurveWidth ();
00805         
00806 
00807 
00808         
00809         // ===> Attribute focusCurveWidthError, which is optional
00810         
00811         
00812         
00817         bool isFocusCurveWidthErrorExists() const;
00818         
00819 
00820         
00826         vector<vector<Length > > getFocusCurveWidthError() const;
00827         
00828  
00829         
00830         
00837         void setFocusCurveWidthError (vector<vector<Length > > focusCurveWidthError);
00838                 
00839         
00840         
00841         
00845         void clearFocusCurveWidthError ();
00846         
00847 
00848 
00849         
00850         // ===> Attribute focusCurveWasFixed, which is optional
00851         
00852         
00853         
00858         bool isFocusCurveWasFixedExists() const;
00859         
00860 
00861         
00867         vector<bool > getFocusCurveWasFixed() const;
00868         
00869  
00870         
00871         
00878         void setFocusCurveWasFixed (vector<bool > focusCurveWasFixed);
00879                 
00880         
00881         
00882         
00886         void clearFocusCurveWasFixed ();
00887         
00888 
00889 
00890         
00891         // ===> Attribute offIntensity, which is optional
00892         
00893         
00894         
00899         bool isOffIntensityExists() const;
00900         
00901 
00902         
00908         vector<Temperature > getOffIntensity() const;
00909         
00910  
00911         
00912         
00919         void setOffIntensity (vector<Temperature > offIntensity);
00920                 
00921         
00922         
00923         
00927         void clearOffIntensity ();
00928         
00929 
00930 
00931         
00932         // ===> Attribute offIntensityError, which is optional
00933         
00934         
00935         
00940         bool isOffIntensityErrorExists() const;
00941         
00942 
00943         
00949         vector<Temperature > getOffIntensityError() const;
00950         
00951  
00952         
00953         
00960         void setOffIntensityError (vector<Temperature > offIntensityError);
00961                 
00962         
00963         
00964         
00968         void clearOffIntensityError ();
00969         
00970 
00971 
00972         
00973         // ===> Attribute offIntensityWasFixed, which is optional
00974         
00975         
00976         
00981         bool isOffIntensityWasFixedExists() const;
00982         
00983 
00984         
00990         bool getOffIntensityWasFixed() const;
00991         
00992  
00993         
00994         
01001         void setOffIntensityWasFixed (bool offIntensityWasFixed);
01002                 
01003         
01004         
01005         
01009         void clearOffIntensityWasFixed ();
01010         
01011 
01012 
01013         
01014         // ===> Attribute peakIntensity, which is optional
01015         
01016         
01017         
01022         bool isPeakIntensityExists() const;
01023         
01024 
01025         
01031         vector<Temperature > getPeakIntensity() const;
01032         
01033  
01034         
01035         
01042         void setPeakIntensity (vector<Temperature > peakIntensity);
01043                 
01044         
01045         
01046         
01050         void clearPeakIntensity ();
01051         
01052 
01053 
01054         
01055         // ===> Attribute peakIntensityError, which is optional
01056         
01057         
01058         
01063         bool isPeakIntensityErrorExists() const;
01064         
01065 
01066         
01072         vector<Temperature > getPeakIntensityError() const;
01073         
01074  
01075         
01076         
01083         void setPeakIntensityError (vector<Temperature > peakIntensityError);
01084                 
01085         
01086         
01087         
01091         void clearPeakIntensityError ();
01092         
01093 
01094 
01095         
01096         // ===> Attribute peakIntensityWasFixed, which is optional
01097         
01098         
01099         
01104         bool isPeakIntensityWasFixedExists() const;
01105         
01106 
01107         
01113         bool getPeakIntensityWasFixed() const;
01114         
01115  
01116         
01117         
01124         void setPeakIntensityWasFixed (bool peakIntensityWasFixed);
01125                 
01126         
01127         
01128         
01132         void clearPeakIntensityWasFixed ();
01133         
01134 
01135 
01136         
01137         // ===> Attribute astigmPlus, which is optional
01138         
01139         
01140         
01145         bool isAstigmPlusExists() const;
01146         
01147 
01148         
01154         vector<Length > getAstigmPlus() const;
01155         
01156  
01157         
01158         
01165         void setAstigmPlus (vector<Length > astigmPlus);
01166                 
01167         
01168         
01169         
01173         void clearAstigmPlus ();
01174         
01175 
01176 
01177         
01178         // ===> Attribute astigmPlusError, which is optional
01179         
01180         
01181         
01186         bool isAstigmPlusErrorExists() const;
01187         
01188 
01189         
01195         vector<Length > getAstigmPlusError() const;
01196         
01197  
01198         
01199         
01206         void setAstigmPlusError (vector<Length > astigmPlusError);
01207                 
01208         
01209         
01210         
01214         void clearAstigmPlusError ();
01215         
01216 
01217 
01218         
01219         // ===> Attribute astigmMult, which is optional
01220         
01221         
01222         
01227         bool isAstigmMultExists() const;
01228         
01229 
01230         
01236         vector<Length > getAstigmMult() const;
01237         
01238  
01239         
01240         
01247         void setAstigmMult (vector<Length > astigmMult);
01248                 
01249         
01250         
01251         
01255         void clearAstigmMult ();
01256         
01257 
01258 
01259         
01260         // ===> Attribute astigmMultError, which is optional
01261         
01262         
01263         
01268         bool isAstigmMultErrorExists() const;
01269         
01270 
01271         
01277         vector<Length > getAstigmMultError() const;
01278         
01279  
01280         
01281         
01288         void setAstigmMultError (vector<Length > astigmMultError);
01289                 
01290         
01291         
01292         
01296         void clearAstigmMultError ();
01297         
01298 
01299 
01300         
01301         // ===> Attribute illumOffset, which is optional
01302         
01303         
01304         
01309         bool isIllumOffsetExists() const;
01310         
01311 
01312         
01318         vector<vector<Length > > getIllumOffset() const;
01319         
01320  
01321         
01322         
01329         void setIllumOffset (vector<vector<Length > > illumOffset);
01330                 
01331         
01332         
01333         
01337         void clearIllumOffset ();
01338         
01339 
01340 
01341         
01342         // ===> Attribute illumOffsetError, which is optional
01343         
01344         
01345         
01350         bool isIllumOffsetErrorExists() const;
01351         
01352 
01353         
01359         vector<vector<Length > > getIllumOffsetError() const;
01360         
01361  
01362         
01363         
01370         void setIllumOffsetError (vector<vector<Length > > illumOffsetError);
01371                 
01372         
01373         
01374         
01378         void clearIllumOffsetError ();
01379         
01380 
01381 
01382         
01383         // ===> Attribute fitRMS, which is optional
01384         
01385         
01386         
01391         bool isFitRMSExists() const;
01392         
01393 
01394         
01400         vector<Length > getFitRMS() const;
01401         
01402  
01403         
01404         
01411         void setFitRMS (vector<Length > fitRMS);
01412                 
01413         
01414         
01415         
01419         void clearFitRMS ();
01420         
01421 
01422 
01424         // Extrinsic Table Attributes //
01426         
01427         
01428         // ===> Attribute calDataId
01429         
01430         
01431         
01432 
01433         
01438         Tag getCalDataId() const;
01439         
01440  
01441         
01442         
01452         void setCalDataId (Tag calDataId);
01453                 
01454         
01455         
01456         
01457 
01458 
01459         
01460         // ===> Attribute calReductionId
01461         
01462         
01463         
01464 
01465         
01470         Tag getCalReductionId() const;
01471         
01472  
01473         
01474         
01484         void setCalReductionId (Tag calReductionId);
01485                 
01486         
01487         
01488         
01489 
01490 
01492         // Links //
01494         
01495         
01496 
01497         
01498                 
01505          CalDataRow* getCalDataUsingCalDataId();
01506          
01507 
01508         
01509 
01510         
01511 
01512         
01513                 
01520          CalReductionRow* getCalReductionUsingCalReductionId();
01521          
01522 
01523         
01524 
01525         
01526         
01527         
01571         bool compareNoAutoInc(string antennaName, ReceiverBandMod::ReceiverBand receiverBand, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, Temperature ambientTemperature, AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, FocusMethodMod::FocusMethod focusMethod, vector<Frequency > frequencyRange, vector<Angle > pointingDirection, int numReceptor, vector<PolarizationTypeMod::PolarizationType > polarizationTypes, vector<bool > wereFixed, vector<vector<Length > > offset, vector<vector<Length > > offsetError, vector<vector<bool > > offsetWasTied, vector<vector<double > > reducedChiSquared, vector<vector<Length > > position);
01572         
01573         
01574 
01575         
01611         bool compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, Temperature ambientTemperature, AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, FocusMethodMod::FocusMethod focusMethod, vector<Frequency > frequencyRange, vector<Angle > pointingDirection, int numReceptor, vector<PolarizationTypeMod::PolarizationType > polarizationTypes, vector<bool > wereFixed, vector<vector<Length > > offset, vector<vector<Length > > offsetError, vector<vector<bool > > offsetWasTied, vector<vector<double > > reducedChiSquared, vector<vector<Length > > position); 
01612                  
01613         
01622         bool equalByRequiredValue(CalFocusRow* x) ;
01623         
01624 #ifndef WITHOUT_ACS
01625 
01629         asdmIDL::CalFocusRowIDL *toIDL() const;
01630         
01638          void toIDL(asdmIDL::CalFocusRowIDL& x) const;
01639 #endif
01640         
01641 #ifndef WITHOUT_ACS
01642 
01647         void setFromIDL (asdmIDL::CalFocusRowIDL x) ;
01648 #endif
01649         
01654         std::string toXML() const;
01655 
01662         void setFromXML (std::string rowDoc) ;
01663 
01666         // binary-deserialization material from an EndianIStream  //
01668 
01669         std::map<std::string, CalFocusAttributeFromBin> fromBinMethods;
01670 void antennaNameFromBin( EndianIStream& eis);
01671 void receiverBandFromBin( EndianIStream& eis);
01672 void calDataIdFromBin( EndianIStream& eis);
01673 void calReductionIdFromBin( EndianIStream& eis);
01674 void startValidTimeFromBin( EndianIStream& eis);
01675 void endValidTimeFromBin( EndianIStream& eis);
01676 void ambientTemperatureFromBin( EndianIStream& eis);
01677 void atmPhaseCorrectionFromBin( EndianIStream& eis);
01678 void focusMethodFromBin( EndianIStream& eis);
01679 void frequencyRangeFromBin( EndianIStream& eis);
01680 void pointingDirectionFromBin( EndianIStream& eis);
01681 void numReceptorFromBin( EndianIStream& eis);
01682 void polarizationTypesFromBin( EndianIStream& eis);
01683 void wereFixedFromBin( EndianIStream& eis);
01684 void offsetFromBin( EndianIStream& eis);
01685 void offsetErrorFromBin( EndianIStream& eis);
01686 void offsetWasTiedFromBin( EndianIStream& eis);
01687 void reducedChiSquaredFromBin( EndianIStream& eis);
01688 void positionFromBin( EndianIStream& eis);
01689 
01690 void polarizationsAveragedFromBin( EndianIStream& eis);
01691 void focusCurveWidthFromBin( EndianIStream& eis);
01692 void focusCurveWidthErrorFromBin( EndianIStream& eis);
01693 void focusCurveWasFixedFromBin( EndianIStream& eis);
01694 void offIntensityFromBin( EndianIStream& eis);
01695 void offIntensityErrorFromBin( EndianIStream& eis);
01696 void offIntensityWasFixedFromBin( EndianIStream& eis);
01697 void peakIntensityFromBin( EndianIStream& eis);
01698 void peakIntensityErrorFromBin( EndianIStream& eis);
01699 void peakIntensityWasFixedFromBin( EndianIStream& eis);
01700 void astigmPlusFromBin( EndianIStream& eis);
01701 void astigmPlusErrorFromBin( EndianIStream& eis);
01702 void astigmMultFromBin( EndianIStream& eis);
01703 void astigmMultErrorFromBin( EndianIStream& eis);
01704 void illumOffsetFromBin( EndianIStream& eis);
01705 void illumOffsetErrorFromBin( EndianIStream& eis);
01706 void fitRMSFromBin( EndianIStream& eis);
01707 
01708 
01716          static CalFocusRow* fromBin(EndianIStream& eis, CalFocusTable& table, const std::vector<std::string>& attributesSeq);   
01717  
01724          void fromText(const std::string& attributeName, const std::string&  t);
01726 
01727 private:
01731         CalFocusTable &table;
01735         bool hasBeenAdded;
01736 
01737         // This method is used by the Table class when this row is added to the table.
01738         void isAdded(bool added);
01739 
01740 
01749         CalFocusRow (CalFocusTable &table);
01750 
01768          CalFocusRow (CalFocusTable &table, CalFocusRow &row);
01769                 
01771         // Intrinsic Table Attributes //
01773         
01774         
01775         // ===> Attribute startValidTime
01776         
01777         
01778 
01779         ArrayTime startValidTime;
01780 
01781         
01782         
01783         
01784 
01785         
01786         // ===> Attribute endValidTime
01787         
01788         
01789 
01790         ArrayTime endValidTime;
01791 
01792         
01793         
01794         
01795 
01796         
01797         // ===> Attribute antennaName
01798         
01799         
01800 
01801         string antennaName;
01802 
01803         
01804         
01805         
01806 
01807         
01808         // ===> Attribute receiverBand
01809         
01810         
01811 
01812         ReceiverBandMod::ReceiverBand receiverBand;
01813 
01814         
01815         
01816         
01817 
01818         
01819         // ===> Attribute ambientTemperature
01820         
01821         
01822 
01823         Temperature ambientTemperature;
01824 
01825         
01826         
01827         
01828 
01829         
01830         // ===> Attribute atmPhaseCorrection
01831         
01832         
01833 
01834         AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection;
01835 
01836         
01837         
01838         
01839 
01840         
01841         // ===> Attribute focusMethod
01842         
01843         
01844 
01845         FocusMethodMod::FocusMethod focusMethod;
01846 
01847         
01848         
01849         
01850 
01851         
01852         // ===> Attribute frequencyRange
01853         
01854         
01855 
01856         vector<Frequency > frequencyRange;
01857 
01858         
01859         
01860         
01861 
01862         
01863         // ===> Attribute pointingDirection
01864         
01865         
01866 
01867         vector<Angle > pointingDirection;
01868 
01869         
01870         
01871         
01872 
01873         
01874         // ===> Attribute numReceptor
01875         
01876         
01877 
01878         int numReceptor;
01879 
01880         
01881         
01882         
01883 
01884         
01885         // ===> Attribute polarizationTypes
01886         
01887         
01888 
01889         vector<PolarizationTypeMod::PolarizationType > polarizationTypes;
01890 
01891         
01892         
01893         
01894 
01895         
01896         // ===> Attribute wereFixed
01897         
01898         
01899 
01900         vector<bool > wereFixed;
01901 
01902         
01903         
01904         
01905 
01906         
01907         // ===> Attribute offset
01908         
01909         
01910 
01911         vector<vector<Length > > offset;
01912 
01913         
01914         
01915         
01916 
01917         
01918         // ===> Attribute offsetError
01919         
01920         
01921 
01922         vector<vector<Length > > offsetError;
01923 
01924         
01925         
01926         
01927 
01928         
01929         // ===> Attribute offsetWasTied
01930         
01931         
01932 
01933         vector<vector<bool > > offsetWasTied;
01934 
01935         
01936         
01937         
01938 
01939         
01940         // ===> Attribute reducedChiSquared
01941         
01942         
01943 
01944         vector<vector<double > > reducedChiSquared;
01945 
01946         
01947         
01948         
01949 
01950         
01951         // ===> Attribute position
01952         
01953         
01954 
01955         vector<vector<Length > > position;
01956 
01957         
01958         
01959         
01960 
01961         
01962         // ===> Attribute polarizationsAveraged, which is optional
01963         
01964         
01965         bool polarizationsAveragedExists;
01966         
01967 
01968         bool polarizationsAveraged;
01969 
01970         
01971         
01972         
01973 
01974         
01975         // ===> Attribute focusCurveWidth, which is optional
01976         
01977         
01978         bool focusCurveWidthExists;
01979         
01980 
01981         vector<vector<Length > > focusCurveWidth;
01982 
01983         
01984         
01985         
01986 
01987         
01988         // ===> Attribute focusCurveWidthError, which is optional
01989         
01990         
01991         bool focusCurveWidthErrorExists;
01992         
01993 
01994         vector<vector<Length > > focusCurveWidthError;
01995 
01996         
01997         
01998         
01999 
02000         
02001         // ===> Attribute focusCurveWasFixed, which is optional
02002         
02003         
02004         bool focusCurveWasFixedExists;
02005         
02006 
02007         vector<bool > focusCurveWasFixed;
02008 
02009         
02010         
02011         
02012 
02013         
02014         // ===> Attribute offIntensity, which is optional
02015         
02016         
02017         bool offIntensityExists;
02018         
02019 
02020         vector<Temperature > offIntensity;
02021 
02022         
02023         
02024         
02025 
02026         
02027         // ===> Attribute offIntensityError, which is optional
02028         
02029         
02030         bool offIntensityErrorExists;
02031         
02032 
02033         vector<Temperature > offIntensityError;
02034 
02035         
02036         
02037         
02038 
02039         
02040         // ===> Attribute offIntensityWasFixed, which is optional
02041         
02042         
02043         bool offIntensityWasFixedExists;
02044         
02045 
02046         bool offIntensityWasFixed;
02047 
02048         
02049         
02050         
02051 
02052         
02053         // ===> Attribute peakIntensity, which is optional
02054         
02055         
02056         bool peakIntensityExists;
02057         
02058 
02059         vector<Temperature > peakIntensity;
02060 
02061         
02062         
02063         
02064 
02065         
02066         // ===> Attribute peakIntensityError, which is optional
02067         
02068         
02069         bool peakIntensityErrorExists;
02070         
02071 
02072         vector<Temperature > peakIntensityError;
02073 
02074         
02075         
02076         
02077 
02078         
02079         // ===> Attribute peakIntensityWasFixed, which is optional
02080         
02081         
02082         bool peakIntensityWasFixedExists;
02083         
02084 
02085         bool peakIntensityWasFixed;
02086 
02087         
02088         
02089         
02090 
02091         
02092         // ===> Attribute astigmPlus, which is optional
02093         
02094         
02095         bool astigmPlusExists;
02096         
02097 
02098         vector<Length > astigmPlus;
02099 
02100         
02101         
02102         
02103 
02104         
02105         // ===> Attribute astigmPlusError, which is optional
02106         
02107         
02108         bool astigmPlusErrorExists;
02109         
02110 
02111         vector<Length > astigmPlusError;
02112 
02113         
02114         
02115         
02116 
02117         
02118         // ===> Attribute astigmMult, which is optional
02119         
02120         
02121         bool astigmMultExists;
02122         
02123 
02124         vector<Length > astigmMult;
02125 
02126         
02127         
02128         
02129 
02130         
02131         // ===> Attribute astigmMultError, which is optional
02132         
02133         
02134         bool astigmMultErrorExists;
02135         
02136 
02137         vector<Length > astigmMultError;
02138 
02139         
02140         
02141         
02142 
02143         
02144         // ===> Attribute illumOffset, which is optional
02145         
02146         
02147         bool illumOffsetExists;
02148         
02149 
02150         vector<vector<Length > > illumOffset;
02151 
02152         
02153         
02154         
02155 
02156         
02157         // ===> Attribute illumOffsetError, which is optional
02158         
02159         
02160         bool illumOffsetErrorExists;
02161         
02162 
02163         vector<vector<Length > > illumOffsetError;
02164 
02165         
02166         
02167         
02168 
02169         
02170         // ===> Attribute fitRMS, which is optional
02171         
02172         
02173         bool fitRMSExists;
02174         
02175 
02176         vector<Length > fitRMS;
02177 
02178         
02179         
02180         
02181 
02183         // Extrinsic Table Attributes //
02185         
02186         
02187         // ===> Attribute calDataId
02188         
02189         
02190 
02191         Tag calDataId;
02192 
02193         
02194         
02195         
02196 
02197         
02198         // ===> Attribute calReductionId
02199         
02200         
02201 
02202         Tag calReductionId;
02203 
02204         
02205         
02206         
02207 
02209         // Links //
02211         
02212         
02213                 
02214 
02215          
02216 
02217         
02218 
02219         
02220                 
02221 
02222          
02223 
02224         
02225 
02226         
02227 /*
02229         // binary-deserialization material from an EndianIStream  //
02231         std::map<std::string, CalFocusAttributeFromBin> fromBinMethods;
02232 void antennaNameFromBin( EndianIStream& eis);
02233 void receiverBandFromBin( EndianIStream& eis);
02234 void calDataIdFromBin( EndianIStream& eis);
02235 void calReductionIdFromBin( EndianIStream& eis);
02236 void startValidTimeFromBin( EndianIStream& eis);
02237 void endValidTimeFromBin( EndianIStream& eis);
02238 void ambientTemperatureFromBin( EndianIStream& eis);
02239 void atmPhaseCorrectionFromBin( EndianIStream& eis);
02240 void focusMethodFromBin( EndianIStream& eis);
02241 void frequencyRangeFromBin( EndianIStream& eis);
02242 void pointingDirectionFromBin( EndianIStream& eis);
02243 void numReceptorFromBin( EndianIStream& eis);
02244 void polarizationTypesFromBin( EndianIStream& eis);
02245 void wereFixedFromBin( EndianIStream& eis);
02246 void offsetFromBin( EndianIStream& eis);
02247 void offsetErrorFromBin( EndianIStream& eis);
02248 void offsetWasTiedFromBin( EndianIStream& eis);
02249 void reducedChiSquaredFromBin( EndianIStream& eis);
02250 void positionFromBin( EndianIStream& eis);
02251 
02252 void polarizationsAveragedFromBin( EndianIStream& eis);
02253 void focusCurveWidthFromBin( EndianIStream& eis);
02254 void focusCurveWidthErrorFromBin( EndianIStream& eis);
02255 void focusCurveWasFixedFromBin( EndianIStream& eis);
02256 void offIntensityFromBin( EndianIStream& eis);
02257 void offIntensityErrorFromBin( EndianIStream& eis);
02258 void offIntensityWasFixedFromBin( EndianIStream& eis);
02259 void peakIntensityFromBin( EndianIStream& eis);
02260 void peakIntensityErrorFromBin( EndianIStream& eis);
02261 void peakIntensityWasFixedFromBin( EndianIStream& eis);
02262 void astigmPlusFromBin( EndianIStream& eis);
02263 void astigmPlusErrorFromBin( EndianIStream& eis);
02264 void astigmMultFromBin( EndianIStream& eis);
02265 void astigmMultErrorFromBin( EndianIStream& eis);
02266 void illumOffsetFromBin( EndianIStream& eis);
02267 void illumOffsetErrorFromBin( EndianIStream& eis);
02268 void fitRMSFromBin( EndianIStream& eis);
02269 
02270 */
02271         
02273         // text-deserialization material //
02275         std::map<std::string, CalFocusAttributeFromText> fromTextMethods;
02276         
02277 void antennaNameFromText (const string & s);
02278         
02279         
02280 void receiverBandFromText (const string & s);
02281         
02282         
02283 void calDataIdFromText (const string & s);
02284         
02285         
02286 void calReductionIdFromText (const string & s);
02287         
02288         
02289 void startValidTimeFromText (const string & s);
02290         
02291         
02292 void endValidTimeFromText (const string & s);
02293         
02294         
02295 void ambientTemperatureFromText (const string & s);
02296         
02297         
02298 void atmPhaseCorrectionFromText (const string & s);
02299         
02300         
02301 void focusMethodFromText (const string & s);
02302         
02303         
02304 void frequencyRangeFromText (const string & s);
02305         
02306         
02307 void pointingDirectionFromText (const string & s);
02308         
02309         
02310 void numReceptorFromText (const string & s);
02311         
02312         
02313 void polarizationTypesFromText (const string & s);
02314         
02315         
02316 void wereFixedFromText (const string & s);
02317         
02318         
02319 void offsetFromText (const string & s);
02320         
02321         
02322 void offsetErrorFromText (const string & s);
02323         
02324         
02325 void offsetWasTiedFromText (const string & s);
02326         
02327         
02328 void reducedChiSquaredFromText (const string & s);
02329         
02330         
02331 void positionFromText (const string & s);
02332         
02333 
02334         
02335 void polarizationsAveragedFromText (const string & s);
02336         
02337         
02338 void focusCurveWidthFromText (const string & s);
02339         
02340         
02341 void focusCurveWidthErrorFromText (const string & s);
02342         
02343         
02344 void focusCurveWasFixedFromText (const string & s);
02345         
02346         
02347 void offIntensityFromText (const string & s);
02348         
02349         
02350 void offIntensityErrorFromText (const string & s);
02351         
02352         
02353 void offIntensityWasFixedFromText (const string & s);
02354         
02355         
02356 void peakIntensityFromText (const string & s);
02357         
02358         
02359 void peakIntensityErrorFromText (const string & s);
02360         
02361         
02362 void peakIntensityWasFixedFromText (const string & s);
02363         
02364         
02365 void astigmPlusFromText (const string & s);
02366         
02367         
02368 void astigmPlusErrorFromText (const string & s);
02369         
02370         
02371 void astigmMultFromText (const string & s);
02372         
02373         
02374 void astigmMultErrorFromText (const string & s);
02375         
02376         
02377 void illumOffsetFromText (const string & s);
02378         
02379         
02380 void illumOffsetErrorFromText (const string & s);
02381         
02382         
02383 void fitRMSFromText (const string & s);
02384         
02385         
02386         
02391          void toBin(EndianOSStream& eoss);
02392                  
02402 };
02403 
02404 } // End namespace asdm
02405 
02406 #endif /* CalFocus_CLASS */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 31 Aug 2016 for casa by  doxygen 1.6.1