YodaProfiler/inc/GLTables.h

#ifndef gltables_h
#define gltables_h

#include <TString.h>
#include <TObject.h>
#include <TSQLServer.h>
#include <TSQLRow.h>
#include <TSQLResult.h>
#include <TSystem.h>
#include <GLTablesStruct.h>
#include <EventHeader.h>
#include <PscuHeader.h>
#include <RunHeaderEvent.h>
#include <RunTrailerEvent.h>
#include <sgp4.h>
//

using namespace pamela;
//

static const TString *fHost;
static const TString *fUser;
static const TString *fPsw;
static UInt_t fNquery;
static Bool_t fSet;

// ==================================================================
/**
 * \brief Class to store GL_RUN data
 */
class GL_TABLES : public TObject {
 private:

 public:
    //
    TString mh;
    TString mp;
    TString mu;
    GL_TABLES();   
    GL_TABLES(TString, TString, TString);
    //
    void Set(TString, TString, TString);
    //
    Bool_t IsConnected(TSQLServer *&);
    //
    void ResetCounters();
    void AddQ();
    //
    const TString* GetHost(){return(fHost);};
    const TString* GetUser(){return(fUser);};
    const TString* GetPsw(){return(fPsw);};
    TString CGetHost(){return(mh);};
    TString CGetUser(){return(mu);};
    TString CGetPsw(){return(mp);};
    UInt_t GetfNquery(){return(fNquery);};
    UInt_t GetNqueries();
    Bool_t IsSet(){return(fSet);};
    //
    GL_TABLES *GetGLTABLES(){return this;};
    //
    ClassDef(GL_TABLES,2);
};

// ==================================================================
/**
 * \brief Class to store GL_RUN data
 */
//class GL_RUN : public TObject {
class GL_RUN : public GL_TABLES {
 private:
    
 public:
    //
    UInt_t ID; 
    UInt_t ID_RUN_FRAG;
    UInt_t ID_ROOT_L0;
    UInt_t ID_ROOT_L2;
    UInt_t RUNHEADER_TIME;
    UInt_t RUNTRAILER_TIME;
    UInt_t RUNHEADER_OBT;
    UInt_t RUNTRAILER_OBT;
    UInt_t RUNHEADER_PKT;
    UInt_t RUNTRAILER_PKT;
    UInt_t BOOT_NUMBER;
    UInt_t EV_FROM;
    UInt_t EV_TO;
    UInt_t NEVENTS;
    UInt_t PKT_COUNTER;
    UInt_t PKT_READY_COUNTER;
    UInt_t COMPILATIONTIMESTAMP;
    UInt_t FAV_WRK_SCHEDULE;
    UInt_t EFF_WRK_SCHEDULE;
    UInt_t PRH_VAR_TRG_MODE_A; 
    UInt_t PRH_VAR_TRG_MODE_B; 
    UInt_t ACQ_BUILD_INFO;
    UInt_t ACQ_VAR_INFO;
    UInt_t RM_ACQ_AFTER_CALIB;
    UInt_t RM_ACQ_SETTING_MODE;
    UInt_t TRK_CALIB_USED;
    UInt_t CAL_DSP_MASK;
    UInt_t LAST_TIMESYNC;
    UInt_t OBT_TIMESYNC;
    UInt_t VALIDATION;
    //
    //
    //
    GL_RUN();
    //
    // functions
    //
    Int_t Query_GL_RUN(UInt_t, TSQLServer*);
    Int_t Fill_GL_RUN(TSQLServer*);
    Int_t Query_GL_RUN_FRAGMENTS(TString, TSQLServer*);
    Int_t Fill_GL_RUN_FRAGMENTS(TSQLServer*);
    Int_t DeleteRun(TSQLServer*, UInt_t, TString);
    Int_t RestoreRun(TSQLServer*, UInt_t, TString);
    void Clear();
    //
    // SETTERS
    //
    void Set_GL_RUNT(RunTrailerEvent *runt, PscuHeader *pht);
    void Set_GL_RUNH(RunHeaderEvent *runt, PscuHeader *pht);
    void Set_GL_RUNT0();
    void Set_GL_RUNH0();
    //
    void Set_GL_RUN(TSQLRow *row);
    //
    void SetRUNHEADER_TIME(UInt_t abst);
    void SetRUNTRAILER_TIME(UInt_t abst);
    void SetRUNHEADER_PKT(UInt_t abst);
    void SetRUNTRAILER_PKT(UInt_t abst);
    void SetRUNHEADER_OBT(UInt_t abst);
    void SetRUNTRAILER_OBT(UInt_t abst);
    void SetBOOTNUMBER(UInt_t abst);
    void SetID(UInt_t);
    void SetID_ROOT_L2(UInt_t L2);
    void SetID_ROOT_L0(UInt_t L0);
    void SetID_RUN_FRAG(UInt_t RUN);
    void SetVALIDATION(UInt_t valid);
    void SetEV_FROM(UInt_t evfrom);
    void SetEV_TO(UInt_t evto);
    void SetNEVENTS(UInt_t nev);
    void SetLAST_TIMESYNC(UInt_t ts);
    void SetOBT_TIMESYNC(UInt_t ts);
    void SetPKT_COUNTER(UInt_t);
    void SetPKT_READY_COUNTER(UInt_t);
    void SetCOMPILATIONTIMESTAMP(UInt_t);
    void SetFAV_WRK_SCHEDULE(UInt_t);
    void SetEFF_WRK_SCHEDULE(UInt_t);
    void SetPRH_VAR_TRG_MODE_A(UInt_t);
    void SetPRH_VAR_TRG_MODE_B(UInt_t);
    void SetACQ_BUILD_INFO(UInt_t);
    void SetACQ_VAR_INFO(UInt_t);
    void SetRM_ACQ_AFTER_CALIB(UInt_t);
    void SetRM_ACQ_SETTING_MODE(UInt_t);
    void SetTRK_CALIB_USED(UInt_t);
    void SetCAL_DSP_MASK(UInt_t);
    //
    // GETTERS
    //
    void GetLevel2Struct(cGLRun *l2) const;
    UInt_t GetID(){return(ID);};
    UInt_t GetRUNHEADER_PKT(){return(RUNHEADER_PKT);};
    UInt_t GetRUNTRAILER_PKT(){return(RUNTRAILER_PKT);};
    UInt_t GetRUNHEADER_TIME(){return(RUNHEADER_TIME);};
    UInt_t GetRUNTRAILER_TIME(){return(RUNTRAILER_TIME);};
    UInt_t GetRUNHEADER_OBT(){return(RUNHEADER_OBT);};
    UInt_t GetRUNTRAILER_OBT(){return(RUNTRAILER_OBT);};
    UInt_t GetNEVENTS(){return(NEVENTS);};
    UInt_t GetBOOT_NUMBER(){return(BOOT_NUMBER);};
    UInt_t GetTRK_CALIB(){return(TRK_CALIB_USED);};
    UInt_t GetPKT_COUNTER(){return(PKT_COUNTER);};
    UInt_t GetLAST_TIMESYNC(){return(LAST_TIMESYNC);};
    UInt_t GetOBT_TIMESYNC(){return(OBT_TIMESYNC);};
    UInt_t GetPKT_READY_COUNTER(){return(PKT_READY_COUNTER);};
    UInt_t GetCOMPILATIONTIMESTAMP(){return(COMPILATIONTIMESTAMP);};
    UInt_t GetFAV_WRK_SCHEDULE(){return(FAV_WRK_SCHEDULE);};
    UInt_t GetEFF_WRK_SCHEDULE(){return(EFF_WRK_SCHEDULE);};
    UInt_t GetPRH_VAR_TRG_MODE_A(){return(PRH_VAR_TRG_MODE_A);};
    UInt_t GetPRH_VAR_TRG_MODE_B(){return(PRH_VAR_TRG_MODE_B);};
    UInt_t GetACQ_BUILD_INFO(){return(ACQ_BUILD_INFO);};
    UInt_t GetACQ_VAR_INFO(){return(ACQ_VAR_INFO);};
    UInt_t GetRM_ACQ_AFTER_CALIB(){return(RM_ACQ_AFTER_CALIB);};
    UInt_t GetRM_ACQ_SETTING_MODE(){return(RM_ACQ_SETTING_MODE);};
    UInt_t GetTRK_CALIB_USED(){return(TRK_CALIB_USED);};
    UInt_t GetCAL_DSP_MASK(){return(CAL_DSP_MASK);};
    //
    GL_RUN* GetGL_RUN(){return this;};
    //
    ClassDef(GL_RUN,1);
};

// ==================================================================
/**
 * \brief Class to store GL_ROOT 
 */
class GL_ROOT : public GL_TABLES {
    //class GL_ROOT : public TObject{
 private:
    
 public:
    //
    UInt_t ID;
    UInt_t ID_RAW;
    UInt_t ID_TIMESYNC;
    TString   PATH;
    TString   NAME;

    GL_ROOT();

    Int_t Query_GL_ROOT(UInt_t id, TSQLServer *dbc);

    ClassDef(GL_ROOT,1);
};
// ==================================================================
/**
 * \brief Class to store GL_PARAM data
 */
class GL_PARAM : public GL_TABLES {
    //class GL_PARAM : public TObject{
 private:
    
 public:
    //
    UInt_t ID;
    TString   PATH;
    TString   NAME;
    UInt_t FROM_TIME;
    UInt_t TO_TIME;
    UInt_t TYPE;
    TString   DESCR;

    GL_PARAM();

    Int_t Query_GL_PARAM(UInt_t time, UInt_t type, TSQLServer *dbc);
 
    ClassDef(GL_PARAM,1);
};
// ==================================================================
/**
 * \brief Class to store GL_TRK_CALIB data
 */
//class GL_TRK_CALIB : public TObject{
class GL_TRK_CALIB : public GL_TABLES {
 private:
    
 public:
    //
    UInt_t ID;
    UInt_t ID_ROOT_L0;
    UInt_t EV_ROOT_CALIBTRK1 ;
    UInt_t EV_ROOT_CALIBTRK2 ;
    UInt_t FROM_TIME;
    UInt_t TO_TIME;
    UInt_t OBT1;
    UInt_t OBT2;
    UInt_t PKT1;
    UInt_t PKT2;
        UInt_t BOOT_NUMBER;
        UInt_t VALIDATION;

    GL_TRK_CALIB();

    Int_t Query_GL_TRK_CALIB(UInt_t time, TSQLServer *dbc);

    ClassDef(GL_TRK_CALIB,1);
};

// ==================================================================
/**
 * \brief Class to store GL_CALO_CALIB data
 */
class GL_CALO_CALIB : public GL_TABLES {
    //class GL_CALO_CALIB : public TObject{
 private:
    
 public:
    //
    UInt_t ID;
    UInt_t ID_ROOT_L0;
    UInt_t EV_ROOT;
    UInt_t FROM_TIME;
    UInt_t TO_TIME;
    UInt_t SECTION;
    UInt_t OBT;
    UInt_t PKT;
    UInt_t BOOT_NUMBER;
    UInt_t VALIDATION;

    GL_CALO_CALIB();

    Int_t Query_GL_CALO_CALIB(UInt_t time, UInt_t &uptime, UInt_t section, TSQLServer *dbc);

    ClassDef(GL_CALO_CALIB,2);
};

// ==================================================================
/**
 * \brief Class to store GL_CALOPULSE_CALIB data
 */
class GL_CALOPULSE_CALIB : public GL_TABLES {
 private:
    
 public:
    //
    UInt_t ID;
    UInt_t ID_ROOT_L0;
    UInt_t EV_ROOT;
    UInt_t FROM_TIME;
    UInt_t TO_TIME;
    UInt_t SECTION;
    UInt_t PULSED_STRIP;
    UInt_t PULSE_AMPLITUDE;
    UInt_t OBT;
    UInt_t PKT;
    UInt_t BOOT_NUMBER;
    UInt_t VALIDATION;

    GL_CALOPULSE_CALIB();

    Int_t Query_GL_CALOPULSE_CALIB(UInt_t time, UInt_t section, UInt_t pampli, TSQLServer *dbc);

    ClassDef(GL_CALOPULSE_CALIB,1);
};
// ==================================================================
/**
 * \brief Class to store GL_S4_CALIB data
 */
class GL_S4_CALIB : public GL_TABLES {
    //class GL_S4_CALIB : public TObject{
 private:
    
 public:
    //
    UInt_t ID;
    UInt_t ID_ROOT_L0;
    UInt_t EV_ROOT;
    UInt_t FROM_TIME;
    UInt_t TO_TIME;
    UInt_t OBT;
    UInt_t PKT;
    UInt_t BOOT_NUMBER;

    GL_S4_CALIB();

    Int_t Query_GL_S4_CALIB(UInt_t time, TSQLServer *dbc);

    ClassDef(GL_S4_CALIB,2);
};

// ==================================================================
/**
 * \brief Class to store TIMESYNC data
 */
class GL_TIMESYNC : public GL_TABLES {
    //class GL_TIMESYNC : public TObject{
 private:
    UInt_t obtfirst;
    UInt_t pktfirst;
    UInt_t toffset;
    //
    UInt_t ID;
    UInt_t ID_RAW;
    UInt_t ID_RESURS_OFFSET;
    UInt_t OBT0;
    UInt_t TIMESYNC;
    UInt_t TYPE;
    UInt_t T0;
    
 public:
    //
    GL_TIMESYNC();
    GL_TIMESYNC(UInt_t ID, TString TYPE, TSQLServer *dbc);
    //
    UInt_t DBabsTime(UInt_t OBT);
    UInt_t ResursTime(UInt_t OBT);
    //
    Long64_t DBpkt(UInt_t PKT);
    Long64_t DBobt(UInt_t OBT);
    //
    TString ConvertTime(TString &tzone, UInt_t dbt);
    TString UnConvertTime(TString &tzone, UInt_t dbt);
    //
    UInt_t GetTimesync() { return TIMESYNC; };
    UInt_t GetObt0() { return OBT0; };
    UInt_t GetT0() { return T0; };
    UInt_t GetType() { return TYPE; };
    //
    ClassDef(GL_TIMESYNC,3);
};


/* 
 * Class to query a TLE from the db.
 *
 * Two non default constructor are avaiable.  It is the same to call
 * the Query method.
 * 
 * The class looks for a TLE in the GL_TLE table using the connection
 * dbc.  You need to pass an UTC date in SQL datetime format or in
 * unix time (UTC) and it will look for the tle with the nearest and
 * previous date.  Then it initialize tle to a cTle object,
 * tleFromTime to the UTC unix time of the tle and tleToTime to the
 * UTC unix time of the next avaible tle.
 */
class GL_TLE : public GL_TABLES {
    //class GL_TLE : public TObject{
 private:
  Int_t DoQuery(TString query, TSQLServer *dbc);
  cTle* GiveTle(TSQLRow*);

  cTle *tle; // the requested tle
  UInt_t tleFromTime; // unix time (UTC) of the tle
  UInt_t tleToTime; // unix time (UTC) of the next tle

 public:
  GL_TLE(){
    tle = NULL;
    tleFromTime = 0;
    tleToTime = 0;
  };

  GL_TLE(UInt_t unixtime, TSQLServer *dbc) {
    Query(unixtime, dbc);
  };

  GL_TLE(TString date, TSQLServer *dbc) {
    Query(date, dbc);
  };

  Int_t Query(UInt_t unixtime, TSQLServer *dbc);
  Int_t Query(TString date, TSQLServer *dbc);

  cTle* GetTle() const { return tle; }
  UInt_t GetFromTime() const { return tleFromTime; }
  UInt_t GetToTime() const { return tleToTime; }

  ClassDef(GL_TLE,1);
};

#endif

1	mocchiut	1.1	#ifndef gltables_h
2			#define gltables_h
3
4			#include <TString.h>
5			#include <TObject.h>
6			#include <TSQLServer.h>
7			#include <TSQLRow.h>
8			#include <TSQLResult.h>
9	mocchiut	1.16	#include <TSystem.h>
10	mocchiut	1.1	#include <GLTablesStruct.h>
11			#include <EventHeader.h>
12			#include <PscuHeader.h>
13			#include <RunHeaderEvent.h>
14			#include <RunTrailerEvent.h>
15	mocchiut	1.10	#include <sgp4.h>
16	mocchiut	1.15	//
17	mocchiut	1.1
18			using namespace pamela;
19	mocchiut	1.15	//
20
21			static const TString *fHost;
22			static const TString *fUser;
23			static const TString *fPsw;
24			static UInt_t fNquery;
25			static Bool_t fSet;
26
27			// ==================================================================
28			/**
29			* \brief Class to store GL_RUN data
30			*/
31			class GL_TABLES : public TObject {
32			private:
33
34			public:
35			//
36	mocchiut	1.19	TString mh;
37			TString mp;
38			TString mu;
39	mocchiut	1.15	GL_TABLES();
40			GL_TABLES(TString, TString, TString);
41			//
42			void Set(TString, TString, TString);
43			//
44	mocchiut	1.18	Bool_t IsConnected(TSQLServer *&);
45	mocchiut	1.15	//
46			void ResetCounters();
47			void AddQ();
48			//
49			const TString* GetHost(){return(fHost);};
50			const TString* GetUser(){return(fUser);};
51			const TString* GetPsw(){return(fPsw);};
52	mocchiut	1.19	TString CGetHost(){return(mh);};
53			TString CGetUser(){return(mu);};
54			TString CGetPsw(){return(mp);};
55	mocchiut	1.15	UInt_t GetfNquery(){return(fNquery);};
56			UInt_t GetNqueries();
57			Bool_t IsSet(){return(fSet);};
58			//
59			GL_TABLES *GetGLTABLES(){return this;};
60			//
61	mocchiut	1.20	ClassDef(GL_TABLES,2);
62	mocchiut	1.15	};
63
64	mocchiut	1.1	// ==================================================================
65			/**
66			* \brief Class to store GL_RUN data
67			*/
68	mocchiut	1.15	//class GL_RUN : public TObject {
69			class GL_RUN : public GL_TABLES {
70	mocchiut	1.1	private:
71
72			public:
73			//
74			UInt_t ID;
75			UInt_t ID_RUN_FRAG;
76			UInt_t ID_ROOT_L0;
77			UInt_t ID_ROOT_L2;
78			UInt_t RUNHEADER_TIME;
79			UInt_t RUNTRAILER_TIME;
80			UInt_t RUNHEADER_OBT;
81			UInt_t RUNTRAILER_OBT;
82			UInt_t RUNHEADER_PKT;
83			UInt_t RUNTRAILER_PKT;
84			UInt_t BOOT_NUMBER;
85			UInt_t EV_FROM;
86			UInt_t EV_TO;
87			UInt_t NEVENTS;
88			UInt_t PKT_COUNTER;
89			UInt_t PKT_READY_COUNTER;
90			UInt_t COMPILATIONTIMESTAMP;
91			UInt_t FAV_WRK_SCHEDULE;
92			UInt_t EFF_WRK_SCHEDULE;
93			UInt_t PRH_VAR_TRG_MODE_A;
94			UInt_t PRH_VAR_TRG_MODE_B;
95			UInt_t ACQ_BUILD_INFO;
96			UInt_t ACQ_VAR_INFO;
97			UInt_t RM_ACQ_AFTER_CALIB;
98			UInt_t RM_ACQ_SETTING_MODE;
99			UInt_t TRK_CALIB_USED;
100			UInt_t CAL_DSP_MASK;
101			UInt_t LAST_TIMESYNC;
102			UInt_t OBT_TIMESYNC;
103			UInt_t VALIDATION;
104			//
105			//
106			//
107			GL_RUN();
108			//
109			// functions
110			//
111			Int_t Query_GL_RUN(UInt_t, TSQLServer*);
112			Int_t Fill_GL_RUN(TSQLServer*);
113			Int_t Query_GL_RUN_FRAGMENTS(TString, TSQLServer*);
114			Int_t Fill_GL_RUN_FRAGMENTS(TSQLServer*);
115	mocchiut	1.11	Int_t DeleteRun(TSQLServer*, UInt_t, TString);
116			Int_t RestoreRun(TSQLServer*, UInt_t, TString);
117	mocchiut	1.1	void Clear();
118			//
119			// SETTERS
120			//
121			void Set_GL_RUNT(RunTrailerEvent runt, PscuHeader pht);
122			void Set_GL_RUNH(RunHeaderEvent runt, PscuHeader pht);
123			void Set_GL_RUNT0();
124			void Set_GL_RUNH0();
125	mocchiut	1.9	//
126			void Set_GL_RUN(TSQLRow *row);
127			//
128	mocchiut	1.1	void SetRUNHEADER_TIME(UInt_t abst);
129			void SetRUNTRAILER_TIME(UInt_t abst);
130			void SetRUNHEADER_PKT(UInt_t abst);
131			void SetRUNTRAILER_PKT(UInt_t abst);
132			void SetRUNHEADER_OBT(UInt_t abst);
133			void SetRUNTRAILER_OBT(UInt_t abst);
134			void SetBOOTNUMBER(UInt_t abst);
135			void SetID(UInt_t);
136			void SetID_ROOT_L2(UInt_t L2);
137			void SetID_ROOT_L0(UInt_t L0);
138			void SetID_RUN_FRAG(UInt_t RUN);
139			void SetVALIDATION(UInt_t valid);
140			void SetEV_FROM(UInt_t evfrom);
141			void SetEV_TO(UInt_t evto);
142			void SetNEVENTS(UInt_t nev);
143			void SetLAST_TIMESYNC(UInt_t ts);
144			void SetOBT_TIMESYNC(UInt_t ts);
145			void SetPKT_COUNTER(UInt_t);
146			void SetPKT_READY_COUNTER(UInt_t);
147			void SetCOMPILATIONTIMESTAMP(UInt_t);
148			void SetFAV_WRK_SCHEDULE(UInt_t);
149			void SetEFF_WRK_SCHEDULE(UInt_t);
150			void SetPRH_VAR_TRG_MODE_A(UInt_t);
151			void SetPRH_VAR_TRG_MODE_B(UInt_t);
152			void SetACQ_BUILD_INFO(UInt_t);
153			void SetACQ_VAR_INFO(UInt_t);
154			void SetRM_ACQ_AFTER_CALIB(UInt_t);
155			void SetRM_ACQ_SETTING_MODE(UInt_t);
156			void SetTRK_CALIB_USED(UInt_t);
157			void SetCAL_DSP_MASK(UInt_t);
158			//
159			// GETTERS
160			//
161			void GetLevel2Struct(cGLRun *l2) const;
162	mocchiut	1.9	UInt_t GetID(){return(ID);};
163	mocchiut	1.1	UInt_t GetRUNHEADER_PKT(){return(RUNHEADER_PKT);};
164			UInt_t GetRUNTRAILER_PKT(){return(RUNTRAILER_PKT);};
165			UInt_t GetRUNHEADER_TIME(){return(RUNHEADER_TIME);};
166			UInt_t GetRUNTRAILER_TIME(){return(RUNTRAILER_TIME);};
167			UInt_t GetRUNHEADER_OBT(){return(RUNHEADER_OBT);};
168			UInt_t GetRUNTRAILER_OBT(){return(RUNTRAILER_OBT);};
169			UInt_t GetNEVENTS(){return(NEVENTS);};
170	mocchiut	1.2	UInt_t GetBOOT_NUMBER(){return(BOOT_NUMBER);};
171	mocchiut	1.1	UInt_t GetTRK_CALIB(){return(TRK_CALIB_USED);};
172			UInt_t GetPKT_COUNTER(){return(PKT_COUNTER);};
173			UInt_t GetLAST_TIMESYNC(){return(LAST_TIMESYNC);};
174			UInt_t GetOBT_TIMESYNC(){return(OBT_TIMESYNC);};
175			UInt_t GetPKT_READY_COUNTER(){return(PKT_READY_COUNTER);};
176			UInt_t GetCOMPILATIONTIMESTAMP(){return(COMPILATIONTIMESTAMP);};
177			UInt_t GetFAV_WRK_SCHEDULE(){return(FAV_WRK_SCHEDULE);};
178			UInt_t GetEFF_WRK_SCHEDULE(){return(EFF_WRK_SCHEDULE);};
179			UInt_t GetPRH_VAR_TRG_MODE_A(){return(PRH_VAR_TRG_MODE_A);};
180			UInt_t GetPRH_VAR_TRG_MODE_B(){return(PRH_VAR_TRG_MODE_B);};
181			UInt_t GetACQ_BUILD_INFO(){return(ACQ_BUILD_INFO);};
182			UInt_t GetACQ_VAR_INFO(){return(ACQ_VAR_INFO);};
183			UInt_t GetRM_ACQ_AFTER_CALIB(){return(RM_ACQ_AFTER_CALIB);};
184			UInt_t GetRM_ACQ_SETTING_MODE(){return(RM_ACQ_SETTING_MODE);};
185			UInt_t GetTRK_CALIB_USED(){return(TRK_CALIB_USED);};
186			UInt_t GetCAL_DSP_MASK(){return(CAL_DSP_MASK);};
187	mocchiut	1.17	//
188			GL_RUN* GetGL_RUN(){return this;};
189	mocchiut	1.1	//
190			ClassDef(GL_RUN,1);
191			};
192
193			// ==================================================================
194			/**
195			* \brief Class to store GL_ROOT
196			*/
197	mocchiut	1.15	class GL_ROOT : public GL_TABLES {
198			//class GL_ROOT : public TObject{
199	mocchiut	1.1	private:
200
201			public:
202			//
203			UInt_t ID;
204			UInt_t ID_RAW;
205			UInt_t ID_TIMESYNC;
206			TString PATH;
207			TString NAME;
208
209			GL_ROOT();
210
211			Int_t Query_GL_ROOT(UInt_t id, TSQLServer *dbc);
212
213			ClassDef(GL_ROOT,1);
214			};
215			// ==================================================================
216			/**
217			* \brief Class to store GL_PARAM data
218			*/
219	mocchiut	1.15	class GL_PARAM : public GL_TABLES {
220			//class GL_PARAM : public TObject{
221	mocchiut	1.1	private:
222
223			public:
224			//
225			UInt_t ID;
226			TString PATH;
227			TString NAME;
228			UInt_t FROM_TIME;
229			UInt_t TO_TIME;
230			UInt_t TYPE;
231			TString DESCR;
232
233			GL_PARAM();
234
235			Int_t Query_GL_PARAM(UInt_t time, UInt_t type, TSQLServer *dbc);
236
237			ClassDef(GL_PARAM,1);
238			};
239			// ==================================================================
240			/**
241			* \brief Class to store GL_TRK_CALIB data
242			*/
243	mocchiut	1.15	//class GL_TRK_CALIB : public TObject{
244			class GL_TRK_CALIB : public GL_TABLES {
245	mocchiut	1.1	private:
246
247			public:
248			//
249			UInt_t ID;
250			UInt_t ID_ROOT_L0;
251			UInt_t EV_ROOT_CALIBTRK1 ;
252			UInt_t EV_ROOT_CALIBTRK2 ;
253			UInt_t FROM_TIME;
254			UInt_t TO_TIME;
255			UInt_t OBT1;
256			UInt_t OBT2;
257			UInt_t PKT1;
258			UInt_t PKT2;
259	pam-fi	1.6	UInt_t BOOT_NUMBER;
260			UInt_t VALIDATION;
261	mocchiut	1.1
262			GL_TRK_CALIB();
263
264			Int_t Query_GL_TRK_CALIB(UInt_t time, TSQLServer *dbc);
265
266			ClassDef(GL_TRK_CALIB,1);
267			};
268
269			// ==================================================================
270			/**
271			* \brief Class to store GL_CALO_CALIB data
272			*/
273	mocchiut	1.15	class GL_CALO_CALIB : public GL_TABLES {
274			//class GL_CALO_CALIB : public TObject{
275	mocchiut	1.1	private:
276
277			public:
278			//
279			UInt_t ID;
280			UInt_t ID_ROOT_L0;
281	mocchiut	1.22	UInt_t EV_ROOT;
282	mocchiut	1.1	UInt_t FROM_TIME;
283			UInt_t TO_TIME;
284	mocchiut	1.22	UInt_t SECTION;
285			UInt_t OBT;
286			UInt_t PKT;
287			UInt_t BOOT_NUMBER;
288			UInt_t VALIDATION;
289	mocchiut	1.1
290			GL_CALO_CALIB();
291
292	mocchiut	1.5	Int_t Query_GL_CALO_CALIB(UInt_t time, UInt_t &uptime, UInt_t section, TSQLServer *dbc);
293	mocchiut	1.1
294	mocchiut	1.22	ClassDef(GL_CALO_CALIB,2);
295			};
296
297			// ==================================================================
298			/**
299			* \brief Class to store GL_CALOPULSE_CALIB data
300			*/
301			class GL_CALOPULSE_CALIB : public GL_TABLES {
302			private:
303
304			public:
305			//
306			UInt_t ID;
307			UInt_t ID_ROOT_L0;
308			UInt_t EV_ROOT;
309			UInt_t FROM_TIME;
310			UInt_t TO_TIME;
311			UInt_t SECTION;
312			UInt_t PULSED_STRIP;
313			UInt_t PULSE_AMPLITUDE;
314			UInt_t OBT;
315			UInt_t PKT;
316			UInt_t BOOT_NUMBER;
317			UInt_t VALIDATION;
318
319			GL_CALOPULSE_CALIB();
320
321			Int_t Query_GL_CALOPULSE_CALIB(UInt_t time, UInt_t section, UInt_t pampli, TSQLServer *dbc);
322
323			ClassDef(GL_CALOPULSE_CALIB,1);
324	mocchiut	1.1	};
325			// ==================================================================
326			/**
327			* \brief Class to store GL_S4_CALIB data
328			*/
329	mocchiut	1.15	class GL_S4_CALIB : public GL_TABLES {
330			//class GL_S4_CALIB : public TObject{
331	mocchiut	1.1	private:
332
333			public:
334			//
335			UInt_t ID;
336			UInt_t ID_ROOT_L0;
337	mocchiut	1.22	UInt_t EV_ROOT;
338	mocchiut	1.1	UInt_t FROM_TIME;
339			UInt_t TO_TIME;
340	mocchiut	1.22	UInt_t OBT;
341			UInt_t PKT;
342			UInt_t BOOT_NUMBER;
343	mocchiut	1.1
344			GL_S4_CALIB();
345
346			Int_t Query_GL_S4_CALIB(UInt_t time, TSQLServer *dbc);
347
348	mocchiut	1.22	ClassDef(GL_S4_CALIB,2);
349	mocchiut	1.1	};
350
351			// ==================================================================
352			/**
353			* \brief Class to store TIMESYNC data
354			*/
355	mocchiut	1.15	class GL_TIMESYNC : public GL_TABLES {
356			//class GL_TIMESYNC : public TObject{
357	mocchiut	1.1	private:
358			UInt_t obtfirst;
359			UInt_t pktfirst;
360			UInt_t toffset;
361			//
362	mocchiut	1.21	UInt_t ID;
363			UInt_t ID_RAW;
364			UInt_t ID_RESURS_OFFSET;
365	mocchiut	1.1	UInt_t OBT0;
366			UInt_t TIMESYNC;
367			UInt_t TYPE;
368	mocchiut	1.12	UInt_t T0;
369	mocchiut	1.1
370			public:
371			//
372			GL_TIMESYNC();
373			GL_TIMESYNC(UInt_t ID, TString TYPE, TSQLServer *dbc);
374			//
375			UInt_t DBabsTime(UInt_t OBT);
376	mocchiut	1.12	UInt_t ResursTime(UInt_t OBT);
377	mocchiut	1.1	//
378	mocchiut	1.13	Long64_t DBpkt(UInt_t PKT);
379			Long64_t DBobt(UInt_t OBT);
380	mocchiut	1.1	//
381	mocchiut	1.7	TString ConvertTime(TString &tzone, UInt_t dbt);
382			TString UnConvertTime(TString &tzone, UInt_t dbt);
383	mocchiut	1.12	//
384			UInt_t GetTimesync() { return TIMESYNC; };
385			UInt_t GetObt0() { return OBT0; };
386			UInt_t GetT0() { return T0; };
387			UInt_t GetType() { return TYPE; };
388			//
389	mocchiut	1.21	ClassDef(GL_TIMESYNC,3);
390	mocchiut	1.8	};
391
392	mocchiut	1.14
393			/*
394			* Class to query a TLE from the db.
395	mocchiut	1.8	*
396	mocchiut	1.14	* Two non default constructor are avaiable. It is the same to call
397			* the Query method.
398			*
399			* The class looks for a TLE in the GL_TLE table using the connection
400			* dbc. You need to pass an UTC date in SQL datetime format or in
401			* unix time (UTC) and it will look for the tle with the nearest and
402			* previous date. Then it initialize tle to a cTle object,
403			* tleFromTime to the UTC unix time of the tle and tleToTime to the
404			* UTC unix time of the next avaible tle.
405	mocchiut	1.8	*/
406	mocchiut	1.15	class GL_TLE : public GL_TABLES {
407			//class GL_TLE : public TObject{
408	mocchiut	1.8	private:
409	mocchiut	1.14	Int_t DoQuery(TString query, TSQLServer *dbc);
410			cTle* GiveTle(TSQLRow*);
411
412			cTle *tle; // the requested tle
413			UInt_t tleFromTime; // unix time (UTC) of the tle
414			UInt_t tleToTime; // unix time (UTC) of the next tle
415	mocchiut	1.1
416	mocchiut	1.8	public:
417	mocchiut	1.14	GL_TLE(){
418			tle = NULL;
419			tleFromTime = 0;
420			tleToTime = 0;
421			};
422
423			GL_TLE(UInt_t unixtime, TSQLServer *dbc) {
424			Query(unixtime, dbc);
425			};
426
427			GL_TLE(TString date, TSQLServer *dbc) {
428			Query(date, dbc);
429			};
430
431			Int_t Query(UInt_t unixtime, TSQLServer *dbc);
432			Int_t Query(TString date, TSQLServer *dbc);
433	mocchiut	1.8
434	mocchiut	1.14	cTle* GetTle() const { return tle; }
435			UInt_t GetFromTime() const { return tleFromTime; }
436			UInt_t GetToTime() const { return tleToTime; }
437	mocchiut	1.8
438			ClassDef(GL_TLE,1);
439	mocchiut	1.1	};
440
441			#endif
442	mocchiut	1.8