SDD DA: possibility of excluding first and last time bin

diff --git a/ITS/AliITSOnlineSDD.cxx b/ITS/AliITSOnlineSDD.cxx
index 893f8dac443993201f710dc916a8e29e01fdc306..796efeab737cb27f9e09ece6b7bb31e1369e73f8 100644 (file)
--- a/ITS/AliITSOnlineSDD.cxx
+++ b/ITS/AliITSOnlineSDD.cxx
@@ -24,14 +24,18 @@
 
 ClassImp(AliITSOnlineSDD)
 //______________________________________________________________________
-  AliITSOnlineSDD::AliITSOnlineSDD():TObject(),fModuleId(0),fSide(0)
+  AliITSOnlineSDD::AliITSOnlineSDD():TObject(),fModuleId(0),fSide(0),fFirstGoodTB(0),fLastGoodTB(0)
 {
   // default constructor
+  SetFirstGoodTB();
+  SetLastGoodTB();
 }
 //______________________________________________________________________
-  AliITSOnlineSDD::AliITSOnlineSDD(Int_t mod, Int_t sid):TObject(),fModuleId(0),fSide(0)
+  AliITSOnlineSDD::AliITSOnlineSDD(Int_t mod, Int_t sid):TObject(),fModuleId(0),fSide(0),fFirstGoodTB(0),fLastGoodTB(0)
 {
   // standard constructor
   SetModule(mod);
   SetDetectorSide(sid);
+  SetFirstGoodTB();
+  SetLastGoodTB();
 }

diff --git a/ITS/AliITSOnlineSDD.h b/ITS/AliITSOnlineSDD.h
index 2c1eda829d4525224c324d34ef4c5eb2b93d6366..d4c7049fc1a08d50419f1f776cdf28eeb56d3644 100644 (file)
--- a/ITS/AliITSOnlineSDD.h
+++ b/ITS/AliITSOnlineSDD.h
@@ -20,15 +20,21 @@ class AliITSOnlineSDD : public TObject {
 
   void SetModule(Int_t mod){fModuleId=mod;}
   void SetDetectorSide(Int_t sid){fSide=sid;}
+  void SetFirstGoodTB(Int_t itb=1){fFirstGoodTB=itb;}
+  void SetLastGoodTB(Int_t itb=254){fLastGoodTB=itb;}
 
   Int_t GetModuleId() const {return fModuleId;}
   Int_t GetDetectorSide() const {return fSide;}
+  Int_t GetFirstGoodTB() const {return fFirstGoodTB;}
+  Int_t GetLastGoodTB() const {return fLastGoodTB;}
 
  protected:
   static const Int_t fgkNAnodes = 256; // number of anodes in each half-module
-  Int_t fModuleId; // module number from 0 to 255
-  Int_t fSide;     // detector side (0-1)
+  Int_t fModuleId;    // module number from 0 to 255
+  Int_t fSide;        // detector side (0-1)
+  Int_t fFirstGoodTB; // first good time bin (to exclude time bin 0)
+  Int_t fLastGoodTB;  // last good time bin (to exclude time bin 255)
 
-  ClassDef(AliITSOnlineSDD,1);
+  ClassDef(AliITSOnlineSDD,2);
 };
 #endif

diff --git a/ITS/AliITSOnlineSDDBase.cxx b/ITS/AliITSOnlineSDDBase.cxx
index 9ad836fa4d20be6e2406e9d5d8ad35efdb027bdf..b046ff585a405cf5f0204b8ef21c2317b95191e9 100644 (file)
--- a/ITS/AliITSOnlineSDDBase.cxx
+++ b/ITS/AliITSOnlineSDDBase.cxx
@@ -79,27 +79,26 @@ void  AliITSOnlineSDDBase::ValidateAnodes(){
 void AliITSOnlineSDDBase::AddEvent(TH2F* hrawd){
   // 
   fNEvents++;
-  Float_t tbmax=(Float_t)hrawd->GetNbinsX();
+  const Int_t nTimeBins=fLastGoodTB-fFirstGoodTB+1;
   Float_t sum[fgkNAnodes];
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     Float_t sumQ=0.;
     sum[ian]=0.;
-    for(Int_t itb=0;itb<tbmax;itb++){
+    for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
       sum[ian]+=hrawd->GetBinContent(itb+1,ian+1);
       sumQ+=TMath::Power(hrawd->GetBinContent(itb+1,ian+1),2);      
     }
-    sum[ian]/=tbmax;
-    sumQ/=tbmax;
+    sum[ian]/=(Float_t)nTimeBins;
+    sumQ/=(Float_t)nTimeBins;
     fSumBaseline[ian]+=sum[ian];
     fSumRawNoise[ian]+=sumQ;
     if(fNEvents==1) ValidateAnodes();
   }
 
 
-  const Int_t kTbmax=int(tbmax);
-  Float_t *cmnEven = new Float_t[kTbmax];
-  Float_t *cmnOdd  = new Float_t[kTbmax];
-  for(Int_t itb=0;itb<tbmax;itb++){
+  Float_t *cmnEven = new Float_t[nTimeBins];
+  Float_t *cmnOdd  = new Float_t[nTimeBins];
+  for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
     Float_t sumEven=0., sumOdd=0.;
     Int_t countEven=0,countOdd=0;
     for(Int_t ian=0;ian<fgkNAnodes;ian+=2){
@@ -112,13 +111,13 @@ void AliITSOnlineSDDBase::AddEvent(TH2F* hrawd){
       sumOdd+=hrawd->GetBinContent(itb+1,ian+1)-sum[ian];
       countOdd++;
     }
-    cmnEven[itb]=sumEven/countEven;
-    cmnOdd[itb]=sumOdd/countOdd;
+    if(countEven>0) cmnEven[itb]=sumEven/countEven;
+    if(countOdd>0) cmnOdd[itb]=sumOdd/countOdd;
   }
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     Float_t num=0.,den=0.;
     if(!fGoodAnode[ian]) continue;
-    for(Int_t itb=0;itb<tbmax;itb++){
+    for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
       Float_t cmnCoef=cmnOdd[itb];
       if(ian%2==0) cmnCoef=cmnEven[itb];
       num+=(hrawd->GetBinContent(itb+1,ian+1)-sum[ian])*cmnCoef;

diff --git a/ITS/AliITSOnlineSDDCMN.cxx b/ITS/AliITSOnlineSDDCMN.cxx
index 34927692ed5a5372b9cb32669c4fbf54c78d86c7..4d8e5d61104084bba65f0514e3b6f77163bd8164 100644 (file)
--- a/ITS/AliITSOnlineSDDCMN.cxx
+++ b/ITS/AliITSOnlineSDDCMN.cxx
@@ -103,9 +103,9 @@ void  AliITSOnlineSDDCMN::ValidateAnodes(){
 void AliITSOnlineSDDCMN::AddEvent(TH2F* hrawd){
   // 
   fNEvents++;
-  Float_t tbmax=(Float_t)hrawd->GetNbinsX();
+  const Int_t nTimeBins=fLastGoodTB-fFirstGoodTB+1;
   TH2F* hcorrd=new TH2F("hcorrd","",hrawd->GetNbinsX(),hrawd->GetXaxis()->GetXmin(),hrawd->GetXaxis()->GetXmax(),hrawd->GetNbinsY(),hrawd->GetYaxis()->GetXmin(),hrawd->GetYaxis()->GetXmax());
-  for(Int_t itb=0;itb<tbmax;itb++){
+  for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
     Float_t sumEven=0., sumOdd=0.;
     Int_t countEven=0, countOdd=0;
     for(Int_t ian=0;ian<fgkNAnodes;ian+=2){
@@ -131,10 +131,10 @@ void AliITSOnlineSDDCMN::AddEvent(TH2F* hrawd){
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     if(!fGoodAnode[ian]) continue;
     Float_t sumQ=0.;
-     for(Int_t itb=0;itb<tbmax;itb++){
+    for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
       sumQ+=TMath::Power(hcorrd->GetBinContent(itb+1,ian+1)-fBaseline[ian],2);      
     }
-    fSumCorrNoise[ian]+=TMath::Sqrt(sumQ/tbmax);
+    fSumCorrNoise[ian]+=TMath::Sqrt(sumQ/(Float_t)nTimeBins);
   }
   delete hcorrd;
 }

diff --git a/ITS/AliITSOnlineSDDTP.cxx b/ITS/AliITSOnlineSDDTP.cxx
index e9db3256f9e2753bcd2729cdd5aee568738423c0..0743fdce66fac2fb8a6b5d89c14246ae85504950 100644 (file)
--- a/ITS/AliITSOnlineSDDTP.cxx
+++ b/ITS/AliITSOnlineSDDTP.cxx
@@ -30,18 +30,20 @@
 ClassImp(AliITSOnlineSDDTP)
 
 //______________________________________________________________________
-AliITSOnlineSDDTP::AliITSOnlineSDDTP():AliITSOnlineSDD(),fNEvents(0),fDAC(0.),fNSigmaGain(0.)
+AliITSOnlineSDDTP::AliITSOnlineSDDTP():AliITSOnlineSDD(),fDAC(0.),fNSigmaGain(0.),fNSigmaNoise(0.)
 {
   // default constructor
   Reset();
   SetNSigmaGain();
+  SetNSigmaNoise();
 }
 //______________________________________________________________________
-AliITSOnlineSDDTP::AliITSOnlineSDDTP(Int_t mod, Int_t sid, Float_t xDAC):AliITSOnlineSDD(mod,sid),fNEvents(0),fDAC(xDAC),fNSigmaGain(0.)
+AliITSOnlineSDDTP::AliITSOnlineSDDTP(Int_t mod, Int_t sid, Float_t xDAC):AliITSOnlineSDD(mod,sid),fDAC(xDAC),fNSigmaGain(0.),fNSigmaNoise(0.)
 {
   // standard constructor
   Reset();
   SetNSigmaGain();
+  SetNSigmaNoise();
 }
 //______________________________________________________________________
 AliITSOnlineSDDTP::~AliITSOnlineSDDTP(){
@@ -50,8 +52,8 @@ AliITSOnlineSDDTP::~AliITSOnlineSDDTP(){
 //______________________________________________________________________
 void AliITSOnlineSDDTP::Reset(){
   //
-  fNEvents=0;
   for(Int_t i=0;i<fgkNAnodes;i++){
+    fNEvents[i]=0;
     fGoodAnode[i]=1;
     fBaseline[i]=0.;
     fCMN[i]=0.;
@@ -66,21 +68,22 @@ void AliITSOnlineSDDTP::Reset(){
 //______________________________________________________________________
 void AliITSOnlineSDDTP::AddEvent(TH2F* hrawd){
   // 
-  fNEvents++;
-  Double_t tbmax=(Double_t)hrawd->GetNbinsX();
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     Float_t auxmax=0.;
     Int_t auxtb=0;
     if(!fGoodAnode[ian]) continue;
-    for(Int_t itb=0;itb<tbmax;itb++){
+    for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
       Float_t cnt=hrawd->GetBinContent(itb+1,ian+1);
       if(cnt>auxmax){ 
        auxmax=cnt;
        auxtb=itb;
       }
     }
-    fSumTPPeak[ian]+=auxmax-fBaseline[ian];
-    fTPPos[ian]+=auxtb;
+    if(auxmax>fBaseline[ian]+fNSigmaNoise*fRawNoise[ian]){
+      fSumTPPeak[ian]+=auxmax-fBaseline[ian];
+      fTPPos[ian]+=auxtb;
+      fNEvents[ian]++;
+    }
   }
 }
 //______________________________________________________________________
@@ -142,6 +145,7 @@ void AliITSOnlineSDDTP::StatGain(Float_t &mean, Float_t  &rms){
   Int_t cnt=0;
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     if(!fGoodAnode[ian]) continue;
+    if(fNEvents[ian]==0) continue;
     sum+=GetChannelGain(ian);
     sumq+=TMath::Power(GetChannelGain(ian),2);
     cnt++;

diff --git a/ITS/AliITSOnlineSDDTP.h b/ITS/AliITSOnlineSDDTP.h
index 0056cceb10a8bcdc26ba0272194903561684fbfe..3b5af13f1272c2c3e6658c706d04cbcc4411b2bc 100644 (file)
--- a/ITS/AliITSOnlineSDDTP.h
+++ b/ITS/AliITSOnlineSDDTP.h
@@ -24,15 +24,20 @@ class AliITSOnlineSDDTP : public AliITSOnlineSDD {
   void ReadBaselines();
 
   void SetNSigmaGain(Float_t sig=3.){fNSigmaGain=sig;}
+  void SetNSigmaNoise(Float_t sig=10.){fNSigmaNoise=sig;}
   Bool_t IsModuleGood()const;
   Bool_t IsAnodeGood(Int_t iAnode)const{ return fGoodAnode[iAnode];}
   Float_t GetAnodeBaseline(Int_t iAnode) const{ return fBaseline[iAnode];}
   Float_t GetAnodeRawNoise(Int_t iAnode) const{ return fRawNoise[iAnode];}
   Float_t GetAnodeCommonMode(Int_t iAnode) const{ return fCMN[iAnode];}
   Float_t GetAnodeCorrNoise(Int_t iAnode) const{return fCorrNoise[iAnode];}
-  Int_t GetNEvents() const {return fNEvents;}
+  Float_t GetTimeBinTPPeak(Int_t iAnode) const{    
+    if(fNEvents[iAnode]>0) return fTPPos[iAnode]/fNEvents[iAnode];
+    else return 0;
+  }
+  Int_t GetNEvents(Int_t iAnode) const {return fNEvents[iAnode];}
   Float_t GetChannelGain(Int_t iAnode)const{
-    if(fNEvents>0) return fSumTPPeak[iAnode]/fNEvents/fDAC;
+    if(fNEvents[iAnode]>0) return fSumTPPeak[iAnode]/fNEvents[iAnode]/fDAC;
     else return 0;
   }
   void StatGain(Float_t &mean, Float_t  &rms);
@@ -42,7 +47,7 @@ class AliITSOnlineSDDTP : public AliITSOnlineSDD {
  protected:
 
  private:
-  Int_t fNEvents;                  // number of events
+  Int_t fNEvents[fgkNAnodes];      // number of TP events for given anode
   Float_t fDAC;                    // Pascal Test Pulse amplitude (DAC units)
   Bool_t fGoodAnode[fgkNAnodes];   // array of anode quality (1 good, 0 bad) 
   Float_t fBaseline[fgkNAnodes];   // array of anode baselines
@@ -52,7 +57,7 @@ class AliITSOnlineSDDTP : public AliITSOnlineSDD {
   Float_t fSumTPPeak[fgkNAnodes];  // test pulse amplitude summed over events
   Float_t fTPPos[fgkNAnodes];      // test pulse position
   Float_t fNSigmaGain;             // Cut value for gain (n*sigma)
-
-  ClassDef(AliITSOnlineSDDTP,2);
+  Float_t fNSigmaNoise;            // Threshold for TP signal identification
+  ClassDef(AliITSOnlineSDDTP,3);
 };
 #endif