GainTrackingRow.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 GainTrackingRow.h
00032  */
00033  
00034 #ifndef GainTrackingRow_CLASS
00035 #define GainTrackingRow_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::GainTrackingRowIDL;
00047 #endif
00048 
00049 
00050 
00051 
00052 
00053 
00054 #include <Angle.h>
00055 using  asdm::Angle;
00056 
00057 #include <Tag.h>
00058 using  asdm::Tag;
00059 
00060 #include <Frequency.h>
00061 using  asdm::Frequency;
00062 
00063 #include <ArrayTimeInterval.h>
00064 using  asdm::ArrayTimeInterval;
00065 
00066 #include <Complex.h>
00067 using  asdm::Complex;
00068 
00069 
00070 
00071 
00072         
00073 
00074         
00075 
00076         
00077 
00078         
00079 
00080         
00081 
00082         
00083 
00084         
00085 
00086         
00087 #include "CPolarizationType.h"
00088 using namespace PolarizationTypeMod;
00089         
00090 
00091         
00092 
00093         
00094 
00095         
00096 
00097         
00098 
00099         
00100 
00101         
00102 
00103         
00104 
00105         
00106 
00107 
00108 
00109 #include <ConversionException.h>
00110 #include <NoSuchRow.h>
00111 #include <IllegalAccessException.h>
00112 
00113 
00114 /*\file GainTracking.h
00115     \brief Generated from model's revision "1.55", branch "HEAD"
00116 */
00117 
00118 namespace asdm {
00119 
00120 //class asdm::GainTrackingTable;
00121 
00122 
00123 // class asdm::AntennaRow;
00124 class AntennaRow;
00125 
00126 // class asdm::SpectralWindowRow;
00127 class SpectralWindowRow;
00128 
00129 // class asdm::FeedRow;
00130 class FeedRow;
00131         
00132 
00133 class GainTrackingRow;
00134 typedef void (GainTrackingRow::*GainTrackingAttributeFromBin) (EndianISStream& eiss);
00135 
00142 class GainTrackingRow {
00143 friend class asdm::GainTrackingTable;
00144 
00145 public:
00146 
00147         virtual ~GainTrackingRow();
00148 
00152         GainTrackingTable &getTable() const;
00153         
00158         bool isAdded() const;
00159                 
00161         // Intrinsic Table Attributes //
00163         
00164         
00165         // ===> Attribute timeInterval
00166         
00167         
00168         
00169 
00170         
00175         ArrayTimeInterval getTimeInterval() const;
00176         
00177  
00178         
00179         
00189         void setTimeInterval (ArrayTimeInterval timeInterval);
00190                 
00191         
00192         
00193         
00194 
00195 
00196         
00197         // ===> Attribute attenuator
00198         
00199         
00200         
00201 
00202         
00207         float getAttenuator() const;
00208         
00209  
00210         
00211         
00219         void setAttenuator (float attenuator);
00220                 
00221         
00222         
00223         
00224 
00225 
00226         
00227         // ===> Attribute numLO
00228         
00229         
00230         
00231 
00232         
00237         int getNumLO() const;
00238         
00239  
00240         
00241         
00249         void setNumLO (int numLO);
00250                 
00251         
00252         
00253         
00254 
00255 
00256         
00257         // ===> Attribute numReceptor
00258         
00259         
00260         
00261 
00262         
00267         int getNumReceptor() const;
00268         
00269  
00270         
00271         
00279         void setNumReceptor (int numReceptor);
00280                 
00281         
00282         
00283         
00284 
00285 
00286         
00287         // ===> Attribute cableDelay
00288         
00289         
00290         
00291 
00292         
00297         vector<double > getCableDelay() const;
00298         
00299  
00300         
00301         
00309         void setCableDelay (vector<double > cableDelay);
00310                 
00311         
00312         
00313         
00314 
00315 
00316         
00317         // ===> Attribute crossPolarizationDelay
00318         
00319         
00320         
00321 
00322         
00327         double getCrossPolarizationDelay() const;
00328         
00329  
00330         
00331         
00339         void setCrossPolarizationDelay (double crossPolarizationDelay);
00340                 
00341         
00342         
00343         
00344 
00345 
00346         
00347         // ===> Attribute loPropagationDelay
00348         
00349         
00350         
00351 
00352         
00357         vector<double > getLoPropagationDelay() const;
00358         
00359  
00360         
00361         
00369         void setLoPropagationDelay (vector<double > loPropagationDelay);
00370                 
00371         
00372         
00373         
00374 
00375 
00376         
00377         // ===> Attribute polarizationTypes
00378         
00379         
00380         
00381 
00382         
00387         vector<PolarizationTypeMod::PolarizationType > getPolarizationTypes() const;
00388         
00389  
00390         
00391         
00399         void setPolarizationTypes (vector<PolarizationTypeMod::PolarizationType > polarizationTypes);
00400                 
00401         
00402         
00403         
00404 
00405 
00406         
00407         // ===> Attribute receiverDelay
00408         
00409         
00410         
00411 
00412         
00417         vector<double > getReceiverDelay() const;
00418         
00419  
00420         
00421         
00429         void setReceiverDelay (vector<double > receiverDelay);
00430                 
00431         
00432         
00433         
00434 
00435 
00436         
00437         // ===> Attribute delayOffset, which is optional
00438         
00439         
00440         
00445         bool isDelayOffsetExists() const;
00446         
00447 
00448         
00454         double getDelayOffset() const;
00455         
00456  
00457         
00458         
00465         void setDelayOffset (double delayOffset);
00466                 
00467         
00468         
00469         
00473         void clearDelayOffset ();
00474         
00475 
00476 
00477         
00478         // ===> Attribute freqOffset, which is optional
00479         
00480         
00481         
00486         bool isFreqOffsetExists() const;
00487         
00488 
00489         
00495         vector<Frequency > getFreqOffset() const;
00496         
00497  
00498         
00499         
00506         void setFreqOffset (vector<Frequency > freqOffset);
00507                 
00508         
00509         
00510         
00514         void clearFreqOffset ();
00515         
00516 
00517 
00518         
00519         // ===> Attribute phaseOffset, which is optional
00520         
00521         
00522         
00527         bool isPhaseOffsetExists() const;
00528         
00529 
00530         
00536         vector<Angle > getPhaseOffset() const;
00537         
00538  
00539         
00540         
00547         void setPhaseOffset (vector<Angle > phaseOffset);
00548                 
00549         
00550         
00551         
00555         void clearPhaseOffset ();
00556         
00557 
00558 
00559         
00560         // ===> Attribute samplingLevel, which is optional
00561         
00562         
00563         
00568         bool isSamplingLevelExists() const;
00569         
00570 
00571         
00577         float getSamplingLevel() const;
00578         
00579  
00580         
00581         
00588         void setSamplingLevel (float samplingLevel);
00589                 
00590         
00591         
00592         
00596         void clearSamplingLevel ();
00597         
00598 
00599 
00600         
00601         // ===> Attribute numAttFreq, which is optional
00602         
00603         
00604         
00609         bool isNumAttFreqExists() const;
00610         
00611 
00612         
00618         int getNumAttFreq() const;
00619         
00620  
00621         
00622         
00629         void setNumAttFreq (int numAttFreq);
00630                 
00631         
00632         
00633         
00637         void clearNumAttFreq ();
00638         
00639 
00640 
00641         
00642         // ===> Attribute attFreq, which is optional
00643         
00644         
00645         
00650         bool isAttFreqExists() const;
00651         
00652 
00653         
00659         vector<double > getAttFreq() const;
00660         
00661  
00662         
00663         
00670         void setAttFreq (vector<double > attFreq);
00671                 
00672         
00673         
00674         
00678         void clearAttFreq ();
00679         
00680 
00681 
00682         
00683         // ===> Attribute attSpectrum, which is optional
00684         
00685         
00686         
00691         bool isAttSpectrumExists() const;
00692         
00693 
00694         
00700         vector<Complex > getAttSpectrum() const;
00701         
00702  
00703         
00704         
00711         void setAttSpectrum (vector<Complex > attSpectrum);
00712                 
00713         
00714         
00715         
00719         void clearAttSpectrum ();
00720         
00721 
00722 
00724         // Extrinsic Table Attributes //
00726         
00727         
00728         // ===> Attribute antennaId
00729         
00730         
00731         
00732 
00733         
00738         Tag getAntennaId() const;
00739         
00740  
00741         
00742         
00752         void setAntennaId (Tag antennaId);
00753                 
00754         
00755         
00756         
00757 
00758 
00759         
00760         // ===> Attribute feedId
00761         
00762         
00763         
00764 
00765         
00770         int getFeedId() const;
00771         
00772  
00773         
00774         
00784         void setFeedId (int feedId);
00785                 
00786         
00787         
00788         
00789 
00790 
00791         
00792         // ===> Attribute spectralWindowId
00793         
00794         
00795         
00796 
00797         
00802         Tag getSpectralWindowId() const;
00803         
00804  
00805         
00806         
00816         void setSpectralWindowId (Tag spectralWindowId);
00817                 
00818         
00819         
00820         
00821 
00822 
00824         // Links //
00826         
00827         
00828 
00829         
00830                 
00837          AntennaRow* getAntennaUsingAntennaId();
00838          
00839 
00840         
00841 
00842         
00843 
00844         
00845                 
00852          SpectralWindowRow* getSpectralWindowUsingSpectralWindowId();
00853          
00854 
00855         
00856 
00857         
00858 
00859         
00860                 
00861         // ===> Slice link from a row of GainTracking table to a collection of row of Feed table.
00862         
00868         vector <FeedRow *> getFeeds();
00869         
00870         
00871 
00872         
00873 
00874         
00875         
00876         
00906         bool compareNoAutoInc(Tag antennaId, Tag spectralWindowId, ArrayTimeInterval timeInterval, int feedId, float attenuator, int numLO, int numReceptor, vector<double > cableDelay, double crossPolarizationDelay, vector<double > loPropagationDelay, vector<PolarizationTypeMod::PolarizationType > polarizationTypes, vector<double > receiverDelay);
00907         
00908         
00909 
00910         
00932         bool compareRequiredValue(float attenuator, int numLO, int numReceptor, vector<double > cableDelay, double crossPolarizationDelay, vector<double > loPropagationDelay, vector<PolarizationTypeMod::PolarizationType > polarizationTypes, vector<double > receiverDelay); 
00933                  
00934         
00943         bool equalByRequiredValue(GainTrackingRow* x) ;
00944         
00945 #ifndef WITHOUT_ACS
00946 
00950         GainTrackingRowIDL *toIDL() const;
00951 #endif
00952         
00953 #ifndef WITHOUT_ACS
00954 
00959         void setFromIDL (GainTrackingRowIDL x) ;
00960 #endif
00961         
00966         string toXML() const;
00967 
00974         void setFromXML (string rowDoc) ;       
00975 
00976 private:
00980         GainTrackingTable &table;
00984         bool hasBeenAdded;
00985 
00986         // This method is used by the Table class when this row is added to the table.
00987         void isAdded(bool added);
00988 
00989 
00998         GainTrackingRow (GainTrackingTable &table);
00999 
01017          GainTrackingRow (GainTrackingTable &table, GainTrackingRow &row);
01018                 
01020         // Intrinsic Table Attributes //
01022         
01023         
01024         // ===> Attribute timeInterval
01025         
01026         
01027 
01028         ArrayTimeInterval timeInterval;
01029 
01030         
01031         
01032         
01033 
01034         
01035         // ===> Attribute attenuator
01036         
01037         
01038 
01039         float attenuator;
01040 
01041         
01042         
01043         
01044 
01045         
01046         // ===> Attribute numLO
01047         
01048         
01049 
01050         int numLO;
01051 
01052         
01053         
01054         
01055 
01056         
01057         // ===> Attribute numReceptor
01058         
01059         
01060 
01061         int numReceptor;
01062 
01063         
01064         
01065         
01066 
01067         
01068         // ===> Attribute cableDelay
01069         
01070         
01071 
01072         vector<double > cableDelay;
01073 
01074         
01075         
01076         
01077 
01078         
01079         // ===> Attribute crossPolarizationDelay
01080         
01081         
01082 
01083         double crossPolarizationDelay;
01084 
01085         
01086         
01087         
01088 
01089         
01090         // ===> Attribute loPropagationDelay
01091         
01092         
01093 
01094         vector<double > loPropagationDelay;
01095 
01096         
01097         
01098         
01099 
01100         
01101         // ===> Attribute polarizationTypes
01102         
01103         
01104 
01105         vector<PolarizationTypeMod::PolarizationType > polarizationTypes;
01106 
01107         
01108         
01109         
01110 
01111         
01112         // ===> Attribute receiverDelay
01113         
01114         
01115 
01116         vector<double > receiverDelay;
01117 
01118         
01119         
01120         
01121 
01122         
01123         // ===> Attribute delayOffset, which is optional
01124         
01125         
01126         bool delayOffsetExists;
01127         
01128 
01129         double delayOffset;
01130 
01131         
01132         
01133         
01134 
01135         
01136         // ===> Attribute freqOffset, which is optional
01137         
01138         
01139         bool freqOffsetExists;
01140         
01141 
01142         vector<Frequency > freqOffset;
01143 
01144         
01145         
01146         
01147 
01148         
01149         // ===> Attribute phaseOffset, which is optional
01150         
01151         
01152         bool phaseOffsetExists;
01153         
01154 
01155         vector<Angle > phaseOffset;
01156 
01157         
01158         
01159         
01160 
01161         
01162         // ===> Attribute samplingLevel, which is optional
01163         
01164         
01165         bool samplingLevelExists;
01166         
01167 
01168         float samplingLevel;
01169 
01170         
01171         
01172         
01173 
01174         
01175         // ===> Attribute numAttFreq, which is optional
01176         
01177         
01178         bool numAttFreqExists;
01179         
01180 
01181         int numAttFreq;
01182 
01183         
01184         
01185         
01186 
01187         
01188         // ===> Attribute attFreq, which is optional
01189         
01190         
01191         bool attFreqExists;
01192         
01193 
01194         vector<double > attFreq;
01195 
01196         
01197         
01198         
01199 
01200         
01201         // ===> Attribute attSpectrum, which is optional
01202         
01203         
01204         bool attSpectrumExists;
01205         
01206 
01207         vector<Complex > attSpectrum;
01208 
01209         
01210         
01211         
01212 
01214         // Extrinsic Table Attributes //
01216         
01217         
01218         // ===> Attribute antennaId
01219         
01220         
01221 
01222         Tag antennaId;
01223 
01224         
01225         
01226         
01227 
01228         
01229         // ===> Attribute feedId
01230         
01231         
01232 
01233         int feedId;
01234 
01235         
01236         
01237         
01238 
01239         
01240         // ===> Attribute spectralWindowId
01241         
01242         
01243 
01244         Tag spectralWindowId;
01245 
01246         
01247         
01248         
01249 
01251         // Links //
01253         
01254         
01255                 
01256 
01257          
01258 
01259         
01260 
01261         
01262                 
01263 
01264          
01265 
01266         
01267 
01268         
01269                 
01270 
01271 
01272         
01273 
01274         
01276         // binary-deserialization material//
01278         map<string, GainTrackingAttributeFromBin> fromBinMethods;
01279 void antennaIdFromBin( EndianISStream& eiss);
01280 void spectralWindowIdFromBin( EndianISStream& eiss);
01281 void timeIntervalFromBin( EndianISStream& eiss);
01282 void feedIdFromBin( EndianISStream& eiss);
01283 void attenuatorFromBin( EndianISStream& eiss);
01284 void numLOFromBin( EndianISStream& eiss);
01285 void numReceptorFromBin( EndianISStream& eiss);
01286 void cableDelayFromBin( EndianISStream& eiss);
01287 void crossPolarizationDelayFromBin( EndianISStream& eiss);
01288 void loPropagationDelayFromBin( EndianISStream& eiss);
01289 void polarizationTypesFromBin( EndianISStream& eiss);
01290 void receiverDelayFromBin( EndianISStream& eiss);
01291 
01292 void delayOffsetFromBin( EndianISStream& eiss);
01293 void freqOffsetFromBin( EndianISStream& eiss);
01294 void phaseOffsetFromBin( EndianISStream& eiss);
01295 void samplingLevelFromBin( EndianISStream& eiss);
01296 void numAttFreqFromBin( EndianISStream& eiss);
01297 void attFreqFromBin( EndianISStream& eiss);
01298 void attSpectrumFromBin( EndianISStream& eiss);
01299         
01300         
01305          void toBin(EndianOSStream& eoss);
01306                  
01314          static GainTrackingRow* fromBin(EndianISStream& eiss, GainTrackingTable& table, const vector<string>& attributesSeq);   
01315 
01316 };
01317 
01318 } // End namespace asdm
01319 
01320 #endif /* GainTracking_CLASS */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines