X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=blobdiff_plain;f=T0%2FAliT0DataDCS.h;h=b8b6a5cd84638173e7181529c67322d96e1f5162;hp=84bac79559e9c445e593f78afc1700d456a9af6d;hb=5ebd79a85bb4d972ed19f200c05765fc7e342afb;hpb=970bb0d0cfc306652aadf98e36647c4fbe275e03

diff --git a/T0/AliT0DataDCS.h b/T0/AliT0DataDCS.h
index 84bac79559e..b8b6a5cd846 100644
--- a/T0/AliT0DataDCS.h
+++ b/T0/AliT0DataDCS.h
@@ -1,57 +1,118 @@
-#ifndef AliT0DataDCS_H
-#define AliT0DataDCS_H
+#ifndef ALIT0DATADCS_H
+#define ALIT0DATADCS_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
 
 #include <TMap.h>
-#include <TClonesArray.h>
-#include <TH2F.h>
-#include <TGraph.h>
-#include <TF1.h>
+//#include <TClonesArray.h>
+//#include <TGraph.h>
+#include <TObject.h>
+class TString;
+
+// AliT0DataDCS class
+// fetching T0 data points from DCS, calculating mean values for the run
+// and storing the result to Reference DB
 
 class AliT0DataDCS : public TObject {
 public:
-	enum {kNAliases=6};
-
+	enum {kNAliases=201, kHV=12, kLV=2, kCFD=12, kScalers=32, kTRM=20, kDRM=5, kAtten=1}; // 201 T0 aliases
 
 	AliT0DataDCS();
-	AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime);
-	~AliT0DataDCS();
+	AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery);
+	AliT0DataDCS(const AliT0DataDCS & data);
+  	AliT0DataDCS& operator=(const AliT0DataDCS & data);
+       	~AliT0DataDCS();
 
 	void SetRun(Int_t run) {fRun = run;}
 	void SetStartTime(Int_t startTime) {fStartTime = startTime;}
 	void SetEndTime(Int_t endTime) {fEndTime = endTime;}
-	Int_t GetRun() {return fRun;}
-	Int_t GetStartTime() {return fStartTime;}
-	Int_t GetEndTime() {return fEndTime;}
+	void SetStartTimeDCSQuery(Int_t startTimeDCSQuery) {fStartTimeDCSQuery = startTimeDCSQuery;}
+	void SetEndTimeDCSQuery(Int_t endTimeDCSQuery) {fEndTimeDCSQuery = endTimeDCSQuery;}
 
-	Bool_t ProcessData(TMap& aliasMap);
 
-	//const char* GetAliasName(UInt_t pos)
-	//		{return pos<kNAliases ? fAliasNames[pos].Data() : 0;}
+        Int_t GetRun() const {return fRun;}
+	Int_t GetStartTime() const {return fStartTime;}
+	Int_t GetEndTime() const {return fEndTime;}
+	Int_t GetStartTimeDCSQuery() const {return fStartTimeDCSQuery;}
+  	Int_t GetEndTimeDCSQuery() const {return fEndTimeDCSQuery;}	
 
-	void CalcScalerMean(Float_t* t0_scal);
+        Int_t GetTVDCtop() const {return    fTVDCtop;}     
+	Int_t GetTVDCbottom() const {return fTVDCbottom;} 
 
+        Float_t GetMeanPMTCurrentASide(Int_t pmt)   const {return fHViA[pmt];} 
+        Float_t GetMeanPMTVoltageASide(Int_t pmt)   const {return fHVvA[pmt];} 
+        Float_t GetMeanLVCurrentASide (Int_t index) const {return fLViA[index];} 
+        Float_t GetMeanLVVoltageASide (Int_t index) const {return fLVvA[index];}
 
-private:
-	void Init();
-	void Introduce(UInt_t numAlias, const TObjArray* aliasArr);
+        Float_t GetMeanPMTCurrentCSide(Int_t pmt)   const {return fHViC[pmt];} 
+        Float_t GetMeanPMTVoltageCSide(Int_t pmt)   const {return fHVvC[pmt];} 
+        Float_t GetMeanLVCurrentCSide (Int_t index) const {return fLViC[index];} 
+        Float_t GetMeanLVVoltageCSide (Int_t index) const {return fLVvC[index];}
 
-	Int_t fRun;
-	UInt_t fStartTime;
-	UInt_t fEndTime;
+        Float_t GetMeanCFDThresholdASide(Int_t pmt) const{return fCFDtA[pmt];}
+	Float_t GetMeanCFDWalkASide   (Int_t pmt)   const{return fCFDwA[pmt];}	
+        Float_t GetMeanCFDThresholdCSide(Int_t pmt) const{return fCFDtC[pmt];}
+	Float_t GetMeanCFDWalkCSide   (Int_t pmt)   const{return fCFDwC[pmt];}	
 
+        UInt_t GetMeanValueOfT0ScalerFromEntireRun(Int_t scaler) const{return fScalerMean[scaler];}         
+        UInt_t GetMeanValueOfT0ScalerPerSecond    (Int_t scaler) const{return fScalerSecMean[scaler];} 
 
-	TString fAliasNames[kNAliases];
+        Float_t GetMeanTemperatureTRM (Int_t trm)   const {return fTRM[trm];}			
+	Float_t GetMeanTemperatureDRM (Int_t drm)   const {return fDRM[drm];}	
+	Float_t GetLaserAmplitude() const { return  fAtten;}	
+	Int_t  GetMultDiscriminatorCentralASide() const     {return fMPDcentA;}
+	Int_t  GetMultDiscriminatorCentralCSide() const     {return fMPDcentC;}     
+        Int_t  GetMultDiscriminatorSemiCentralASide() const {return fMPDsemiCentA;}
+        Int_t  GetMultDiscriminatorSemiCentralCSide() const {return fMPDsemiCentC;}          
+	Int_t  GetMultDiscriminatorMode() const {return fMPDmode;}
 
-	Bool_t fIsProcessed;
-	void SetScalerMean(Int_t channel, Float_t val) {fScalerMean[channel]=val;}
-	Float_t  GetScalerMean(Int_t channel)        const {return fScalerMean[channel];}
-	Float_t* GetScalerMean()          const {return (float*)fScalerMean;}
 
+	Bool_t ProcessData(TMap& aliasMap);
+
+	const char* GetAliasName(Int_t pos) const {return pos<kNAliases ? fAliasNames[pos].Data() : 0;}
+
+        void PrintT0Data() const;
 
-	ClassDef(AliT0DataDCS, 2);
+private:
+	void Init();
+	void Introduce(UInt_t numAlias, const TObjArray* aliasArr)const;
+        void PrintfArray(const char *label, const Float_t *array, Int_t numElements) const;
+
+	Int_t fRun;				// Run number
+	UInt_t fStartTime;			// Start time
+	UInt_t fEndTime;			// End time
+	Int_t fStartTimeDCSQuery; 		// Begin time DCSQuery
+  	Int_t fEndTimeDCSQuery;   		// End time DCSQuery
+	Float_t fHViA[kHV];			// Mean value of HV current in uA on A-side
+	Float_t fHVvA[kHV]; 			// Mean value of HV voltage in V on A-side
+	Float_t fLViA[kLV]; 			// Mean value of LV current in uA on A-side
+	Float_t fLVvA[kLV];			// Mean value of LV voltage in V on A-side
+	Float_t fHViC[kHV];			// Mean value of HV current in uA on C-side
+        Float_t fHVvC[kHV];			// Mean value of HV voltage in V on C-side
+        Float_t fLViC[kLV];			// Mean value of LV current in uA on C-side
+        Float_t fLVvC[kLV];			// Mean value of LV voltage in V on C-side
+ 	Float_t fCFDtA[kCFD];			// Mean threshold on CFD in V on A-side	
+	Float_t fCFDwA[kCFD];			// Mean walk on CFD in V on A-side
+	Float_t fCFDtC[kCFD];			// Mean threshold on CFD in V on C-side
+        Float_t fCFDwC[kCFD];			// Mean walk on CFD in V on C-side
+        UInt_t fScalerMean[kScalers];  	// Mean value of T0 scaler counts from the entire run
+        UInt_t fScalerSecMean[kScalers]; 	// Mean value of T0 scaler counts per second
+	Float_t fTRM[kTRM];			// Mean temperature on TRM in degrees of Celsius
+	Float_t fDRM[kDRM];			// Mean temperature on DRM in degrees of Celsius
+	Float_t fAtten;				// Laser amplitude in MIPs
+	Int_t fMPDcentA;			// Multiplicity Discriminator central on A-side
+	Int_t fMPDcentC;                	// Multiplicity Discriminator central on C-side
+        Int_t fMPDsemiCentA;                	// Multiplicity Discriminator semi-central on A-side
+        Int_t fMPDsemiCentC;                	// Multiplicity Discriminator semi-central on C-side
+	Int_t fTVDCtop;				// T0 Vertex Unit top
+	Int_t fTVDCbottom;			// T0 Vertex Unit bottom
+	Int_t fMPDmode;                       // Multiplicity Discriminator on C-side only, A-side only, or both sides
+	TString fAliasNames[kNAliases];		// T0 data points aliases  
+	Bool_t fIsProcessed;			// status - was processing data successful
+	ClassDef(AliT0DataDCS, 2)
 
 protected:
-	Float_t     fScalerMean[24];	
 };
 
 #endif