PointingRow.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 PointingRow.h
00032  */
00033  
00034 #ifndef PointingRow_CLASS
00035 #define PointingRow_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::PointingRowIDL;
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 <ArrayTimeInterval.h>
00064 using  asdm::ArrayTimeInterval;
00065 
00066 
00067 
00068 
00069         
00070 
00071         
00072 
00073         
00074 
00075         
00076 
00077         
00078 
00079         
00080 
00081         
00082 
00083         
00084 
00085         
00086 
00087         
00088 
00089         
00090 
00091         
00092 
00093         
00094 #include "CDirectionReferenceCode.h"
00095 using namespace DirectionReferenceCodeMod;
00096         
00097 
00098         
00099 
00100         
00101 
00102 
00103 
00104 #include <ConversionException.h>
00105 #include <NoSuchRow.h>
00106 #include <IllegalAccessException.h>
00107 
00108 
00109 /*\file Pointing.h
00110     \brief Generated from model's revision "1.55", branch "HEAD"
00111 */
00112 
00113 namespace asdm {
00114 
00115 //class asdm::PointingTable;
00116 
00117 
00118 // class asdm::PointingModelRow;
00119 class PointingModelRow;
00120 
00121 // class asdm::AntennaRow;
00122 class AntennaRow;
00123         
00124 
00125 class PointingRow;
00126 typedef void (PointingRow::*PointingAttributeFromBin) (EndianISStream& eiss);
00127 
00134 class PointingRow {
00135 friend class asdm::PointingTable;
00136 
00137 public:
00138 
00139         virtual ~PointingRow();
00140 
00144         PointingTable &getTable() const;
00145         
00150         bool isAdded() const;
00151                 
00153         // Intrinsic Table Attributes //
00155         
00156         
00157         // ===> Attribute timeInterval
00158         
00159         
00160         
00161 
00162         
00167         ArrayTimeInterval getTimeInterval() const;
00168         
00169  
00170         
00171         
00181         void setTimeInterval (ArrayTimeInterval timeInterval);
00182                 
00183         
00184         
00185         
00186 
00187 
00188         
00189         // ===> Attribute numSample
00190         
00191         
00192         
00193 
00194         
00199         int getNumSample() const;
00200         
00201  
00202         
00203         
00211         void setNumSample (int numSample);
00212                 
00213         
00214         
00215         
00216 
00217 
00218         
00219         // ===> Attribute encoder
00220         
00221         
00222         
00223 
00224         
00229         vector<vector<Angle > > getEncoder() const;
00230         
00231  
00232         
00233         
00241         void setEncoder (vector<vector<Angle > > encoder);
00242                 
00243         
00244         
00245         
00246 
00247 
00248         
00249         // ===> Attribute pointingTracking
00250         
00251         
00252         
00253 
00254         
00259         bool getPointingTracking() const;
00260         
00261  
00262         
00263         
00271         void setPointingTracking (bool pointingTracking);
00272                 
00273         
00274         
00275         
00276 
00277 
00278         
00279         // ===> Attribute usePolynomials
00280         
00281         
00282         
00283 
00284         
00289         bool getUsePolynomials() const;
00290         
00291  
00292         
00293         
00301         void setUsePolynomials (bool usePolynomials);
00302                 
00303         
00304         
00305         
00306 
00307 
00308         
00309         // ===> Attribute timeOrigin
00310         
00311         
00312         
00313 
00314         
00319         ArrayTime getTimeOrigin() const;
00320         
00321  
00322         
00323         
00331         void setTimeOrigin (ArrayTime timeOrigin);
00332                 
00333         
00334         
00335         
00336 
00337 
00338         
00339         // ===> Attribute numTerm
00340         
00341         
00342         
00343 
00344         
00349         int getNumTerm() const;
00350         
00351  
00352         
00353         
00361         void setNumTerm (int numTerm);
00362                 
00363         
00364         
00365         
00366 
00367 
00368         
00369         // ===> Attribute pointingDirection
00370         
00371         
00372         
00373 
00374         
00379         vector<vector<Angle > > getPointingDirection() const;
00380         
00381  
00382         
00383         
00391         void setPointingDirection (vector<vector<Angle > > pointingDirection);
00392                 
00393         
00394         
00395         
00396 
00397 
00398         
00399         // ===> Attribute target
00400         
00401         
00402         
00403 
00404         
00409         vector<vector<Angle > > getTarget() const;
00410         
00411  
00412         
00413         
00421         void setTarget (vector<vector<Angle > > target);
00422                 
00423         
00424         
00425         
00426 
00427 
00428         
00429         // ===> Attribute offset
00430         
00431         
00432         
00433 
00434         
00439         vector<vector<Angle > > getOffset() const;
00440         
00441  
00442         
00443         
00451         void setOffset (vector<vector<Angle > > offset);
00452                 
00453         
00454         
00455         
00456 
00457 
00458         
00459         // ===> Attribute overTheTop, which is optional
00460         
00461         
00462         
00467         bool isOverTheTopExists() const;
00468         
00469 
00470         
00476         bool getOverTheTop() const;
00477         
00478  
00479         
00480         
00487         void setOverTheTop (bool overTheTop);
00488                 
00489         
00490         
00491         
00495         void clearOverTheTop ();
00496         
00497 
00498 
00499         
00500         // ===> Attribute sourceOffset, which is optional
00501         
00502         
00503         
00508         bool isSourceOffsetExists() const;
00509         
00510 
00511         
00517         vector<vector<Angle > > getSourceOffset() const;
00518         
00519  
00520         
00521         
00528         void setSourceOffset (vector<vector<Angle > > sourceOffset);
00529                 
00530         
00531         
00532         
00536         void clearSourceOffset ();
00537         
00538 
00539 
00540         
00541         // ===> Attribute sourceOffsetReferenceCode, which is optional
00542         
00543         
00544         
00549         bool isSourceOffsetReferenceCodeExists() const;
00550         
00551 
00552         
00558         DirectionReferenceCodeMod::DirectionReferenceCode getSourceOffsetReferenceCode() const;
00559         
00560  
00561         
00562         
00569         void setSourceOffsetReferenceCode (DirectionReferenceCodeMod::DirectionReferenceCode sourceOffsetReferenceCode);
00570                 
00571         
00572         
00573         
00577         void clearSourceOffsetReferenceCode ();
00578         
00579 
00580 
00581         
00582         // ===> Attribute sourceOffsetEquinox, which is optional
00583         
00584         
00585         
00590         bool isSourceOffsetEquinoxExists() const;
00591         
00592 
00593         
00599         ArrayTime getSourceOffsetEquinox() const;
00600         
00601  
00602         
00603         
00610         void setSourceOffsetEquinox (ArrayTime sourceOffsetEquinox);
00611                 
00612         
00613         
00614         
00618         void clearSourceOffsetEquinox ();
00619         
00620 
00621 
00622         
00623         // ===> Attribute sampledTimeInterval, which is optional
00624         
00625         
00626         
00631         bool isSampledTimeIntervalExists() const;
00632         
00633 
00634         
00640         vector<ArrayTimeInterval > getSampledTimeInterval() const;
00641         
00642  
00643         
00644         
00651         void setSampledTimeInterval (vector<ArrayTimeInterval > sampledTimeInterval);
00652                 
00653         
00654         
00655         
00659         void clearSampledTimeInterval ();
00660         
00661 
00662 
00664         // Extrinsic Table Attributes //
00666         
00667         
00668         // ===> Attribute antennaId
00669         
00670         
00671         
00672 
00673         
00678         Tag getAntennaId() const;
00679         
00680  
00681         
00682         
00692         void setAntennaId (Tag antennaId);
00693                 
00694         
00695         
00696         
00697 
00698 
00699         
00700         // ===> Attribute pointingModelId
00701         
00702         
00703         
00704 
00705         
00710         int getPointingModelId() const;
00711         
00712  
00713         
00714         
00722         void setPointingModelId (int pointingModelId);
00723                 
00724         
00725         
00726         
00727 
00728 
00730         // Links //
00732         
00733         
00734 
00735         
00736                 
00737         // ===> Slice link from a row of Pointing table to a collection of row of PointingModel table.
00738         
00744         vector <PointingModelRow *> getPointingModels();
00745         
00746         
00747 
00748         
00749 
00750         
00751 
00752         
00753                 
00760          AntennaRow* getAntennaUsingAntennaId();
00761          
00762 
00763         
00764 
00765         
00766         
00767         
00797         bool compareNoAutoInc(Tag antennaId, ArrayTimeInterval timeInterval, int numSample, vector<vector<Angle > > encoder, bool pointingTracking, bool usePolynomials, ArrayTime timeOrigin, int numTerm, vector<vector<Angle > > pointingDirection, vector<vector<Angle > > target, vector<vector<Angle > > offset, int pointingModelId);
00798         
00799         
00800 
00801         
00827         bool compareRequiredValue(int numSample, vector<vector<Angle > > encoder, bool pointingTracking, bool usePolynomials, ArrayTime timeOrigin, int numTerm, vector<vector<Angle > > pointingDirection, vector<vector<Angle > > target, vector<vector<Angle > > offset, int pointingModelId); 
00828                  
00829         
00838         bool equalByRequiredValue(PointingRow* x) ;
00839         
00840 #ifndef WITHOUT_ACS
00841 
00845         PointingRowIDL *toIDL() const;
00846 #endif
00847         
00848 #ifndef WITHOUT_ACS
00849 
00854         void setFromIDL (PointingRowIDL x) ;
00855 #endif
00856         
00861         string toXML() const;
00862 
00869         void setFromXML (string rowDoc) ;       
00870 
00871 private:
00875         PointingTable &table;
00879         bool hasBeenAdded;
00880 
00881         // This method is used by the Table class when this row is added to the table.
00882         void isAdded(bool added);
00883 
00884 
00893         PointingRow (PointingTable &table);
00894 
00912          PointingRow (PointingTable &table, PointingRow &row);
00913                 
00915         // Intrinsic Table Attributes //
00917         
00918         
00919         // ===> Attribute timeInterval
00920         
00921         
00922 
00923         ArrayTimeInterval timeInterval;
00924 
00925         
00926         
00927         
00928 
00929         
00930         // ===> Attribute numSample
00931         
00932         
00933 
00934         int numSample;
00935 
00936         
00937         
00938         
00939 
00940         
00941         // ===> Attribute encoder
00942         
00943         
00944 
00945         vector<vector<Angle > > encoder;
00946 
00947         
00948         
00949         
00950 
00951         
00952         // ===> Attribute pointingTracking
00953         
00954         
00955 
00956         bool pointingTracking;
00957 
00958         
00959         
00960         
00961 
00962         
00963         // ===> Attribute usePolynomials
00964         
00965         
00966 
00967         bool usePolynomials;
00968 
00969         
00970         
00971         
00972 
00973         
00974         // ===> Attribute timeOrigin
00975         
00976         
00977 
00978         ArrayTime timeOrigin;
00979 
00980         
00981         
00982         
00983 
00984         
00985         // ===> Attribute numTerm
00986         
00987         
00988 
00989         int numTerm;
00990 
00991         
00992         
00993         
00994 
00995         
00996         // ===> Attribute pointingDirection
00997         
00998         
00999 
01000         vector<vector<Angle > > pointingDirection;
01001 
01002         
01003         
01004         
01005 
01006         
01007         // ===> Attribute target
01008         
01009         
01010 
01011         vector<vector<Angle > > target;
01012 
01013         
01014         
01015         
01016 
01017         
01018         // ===> Attribute offset
01019         
01020         
01021 
01022         vector<vector<Angle > > offset;
01023 
01024         
01025         
01026         
01027 
01028         
01029         // ===> Attribute overTheTop, which is optional
01030         
01031         
01032         bool overTheTopExists;
01033         
01034 
01035         bool overTheTop;
01036 
01037         
01038         
01039         
01040 
01041         
01042         // ===> Attribute sourceOffset, which is optional
01043         
01044         
01045         bool sourceOffsetExists;
01046         
01047 
01048         vector<vector<Angle > > sourceOffset;
01049 
01050         
01051         
01052         
01053 
01054         
01055         // ===> Attribute sourceOffsetReferenceCode, which is optional
01056         
01057         
01058         bool sourceOffsetReferenceCodeExists;
01059         
01060 
01061         DirectionReferenceCodeMod::DirectionReferenceCode sourceOffsetReferenceCode;
01062 
01063         
01064         
01065         
01066 
01067         
01068         // ===> Attribute sourceOffsetEquinox, which is optional
01069         
01070         
01071         bool sourceOffsetEquinoxExists;
01072         
01073 
01074         ArrayTime sourceOffsetEquinox;
01075 
01076         
01077         
01078         
01079 
01080         
01081         // ===> Attribute sampledTimeInterval, which is optional
01082         
01083         
01084         bool sampledTimeIntervalExists;
01085         
01086 
01087         vector<ArrayTimeInterval > sampledTimeInterval;
01088 
01089         
01090         
01091         
01092 
01094         // Extrinsic Table Attributes //
01096         
01097         
01098         // ===> Attribute antennaId
01099         
01100         
01101 
01102         Tag antennaId;
01103 
01104         
01105         
01106         
01107 
01108         
01109         // ===> Attribute pointingModelId
01110         
01111         
01112 
01113         int pointingModelId;
01114 
01115         
01116         
01117         
01118 
01120         // Links //
01122         
01123         
01124                 
01125 
01126 
01127         
01128 
01129         
01130                 
01131 
01132          
01133 
01134         
01135 
01136         
01138         // binary-deserialization material//
01140         map<string, PointingAttributeFromBin> fromBinMethods;
01141 void antennaIdFromBin( EndianISStream& eiss);
01142 void timeIntervalFromBin( EndianISStream& eiss);
01143 void numSampleFromBin( EndianISStream& eiss);
01144 void encoderFromBin( EndianISStream& eiss);
01145 void pointingTrackingFromBin( EndianISStream& eiss);
01146 void usePolynomialsFromBin( EndianISStream& eiss);
01147 void timeOriginFromBin( EndianISStream& eiss);
01148 void numTermFromBin( EndianISStream& eiss);
01149 void pointingDirectionFromBin( EndianISStream& eiss);
01150 void targetFromBin( EndianISStream& eiss);
01151 void offsetFromBin( EndianISStream& eiss);
01152 void pointingModelIdFromBin( EndianISStream& eiss);
01153 
01154 void overTheTopFromBin( EndianISStream& eiss);
01155 void sourceOffsetFromBin( EndianISStream& eiss);
01156 void sourceOffsetReferenceCodeFromBin( EndianISStream& eiss);
01157 void sourceOffsetEquinoxFromBin( EndianISStream& eiss);
01158 void sampledTimeIntervalFromBin( EndianISStream& eiss);
01159         
01160         
01165          void toBin(EndianOSStream& eoss);
01166                  
01174          static PointingRow* fromBin(EndianISStream& eiss, PointingTable& table, const vector<string>& attributesSeq);   
01175 
01176 };
01177 
01178 } // End namespace asdm
01179 
01180 #endif /* Pointing_CLASS */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines