Update VZERO reco in order to deal with high lumi data. Weighted mean on V0 A and...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Jun 2011 10:25:35 +0000 (10:25 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 10 Jun 2011 10:25:35 +0000 (10:25 +0000)
ANALYSIS/TenderSupplies/AliVZEROTenderSupply.cxx
ANALYSIS/TenderSupplies/AliVZEROTenderSupply.h
STEER/AliVVZERO.h
VZERO/AliVZERORecoParam.cxx
VZERO/AliVZERORecoParam.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROTriggerMask.cxx
VZERO/AliVZEROTriggerMask.h

index b14ed90..d8eef4a 100644 (file)
@@ -46,6 +46,7 @@ AliVZEROTenderSupply::AliVZEROTenderSupply() :
   AliTenderSupply(),
   fCalibData(NULL),
   fTimeSlewing(NULL),
+  fRecoParam(NULL),
   fLHCClockPhase(0),
   fDebug(kFALSE)
 {
@@ -59,6 +60,7 @@ AliVZEROTenderSupply::AliVZEROTenderSupply(const char *name, const AliTender *te
   AliTenderSupply(name,tender),
   fCalibData(NULL),
   fTimeSlewing(NULL),
+  fRecoParam(NULL),
   fLHCClockPhase(0),
   fDebug(kFALSE)
 {
@@ -117,9 +119,19 @@ void AliVZEROTenderSupply::ProcessEvent()
       fTimeSlewing = (TF1*)entrySlew->GetObject();
       if (fDebug) printf("AliVZEROTenderSupply::Used VZERO time slewing entry: %s\n",entrySlew->GetId().ToString().Data());
     }
+
+    AliCDBEntry *entryRecoParam = fTender->GetCDBManager()->Get("VZERO/Calib/RecoParam",fTender->GetRun());
+    if (!entryRecoParam) {
+      AliError("VZERO reco-param object is not found in OCDB !");
+      fRecoParam = NULL;
+      return;
+    } else {
+      fRecoParam = (AliVZERORecoParam*)entryRecoParam->GetObject();
+      if (fDebug) printf("AliVZEROTenderSupply::Used VZERO reco-param entry: %s\n",entryRecoParam->GetId().ToString().Data());
+    }
   }
 
-  if (!fCalibData || !fTimeSlewing) {
+  if (!fCalibData || !fTimeSlewing || !fRecoParam) {
     AliWarning("VZERO calibration objects not found!");
     return;
   }
@@ -151,6 +163,7 @@ void AliVZEROTenderSupply::ProcessEvent()
 
   {
     AliVZEROTriggerMask triggerMask;
+    triggerMask.SetRecoParam(fRecoParam);
     triggerMask.FillMasks(esdVZERO, fCalibData, fTimeSlewing);
   }
   if (fDebug) printf("Modified VZERO decision %d (%f ns) and %d (%f ns)\n",
index c1ccf56..0443cad 100644 (file)
@@ -17,6 +17,7 @@
 
 class TF1;
 class AliVZEROCalibData;
+class AliVZERORecoParam;
 
 class AliVZEROTenderSupply: public AliTenderSupply {
   
@@ -36,13 +37,14 @@ public:
 private:
   AliVZEROCalibData* fCalibData;      //! calibration data
   TF1*               fTimeSlewing;    //! Function for time slewing correction
+  AliVZERORecoParam* fRecoParam;      //! pointer to reco-param object
   Float_t            fLHCClockPhase;  //! the correction to the LHC-clock phase
   Bool_t             fDebug;          //  debug on/off
   
   AliVZEROTenderSupply(const AliVZEROTenderSupply&c);
   AliVZEROTenderSupply& operator= (const AliVZEROTenderSupply&c);
   
-  ClassDef(AliVZEROTenderSupply, 1)  // VZERO tender task
+  ClassDef(AliVZEROTenderSupply, 2)  // VZERO tender task
 };
 
 
index c30bd1d..07cb98d 100644 (file)
@@ -23,7 +23,8 @@ public:
     kTriggerBitsFilled = BIT(15),
     kDecisionFilled = BIT(16),
     kOnlineBitsFilled = BIT(17),
-    kCorrectedForSaturation = BIT(18)
+    kCorrectedForSaturation = BIT(18),
+    kRobustMeanTime = BIT(19)
   };
   enum Decision { kV0Invalid = -1, kV0Empty = 0, kV0BB, kV0BG, kV0Fake };
 
index d5eceba..ca49fab 100644 (file)
@@ -32,7 +32,18 @@ AliVZERORecoParam::AliVZERORecoParam() : AliDetectorRecoParam(),
   fStartClock(8),
   fEndClock(12),
   fNPreClocks(2),
-  fNPostClocks(1)
+  fNPostClocks(1),
+  fAdcThresHold(0.0),
+  fTimeWindowBBALow(-9.5),
+  fTimeWindowBBAUp(22.5),
+  fTimeWindowBGALow(-2.5),
+  fTimeWindowBGAUp(5.0),
+  fTimeWindowBBCLow(-2.5),
+  fTimeWindowBBCUp(22.5),
+  fTimeWindowBGCLow(-2.5),
+  fTimeWindowBGCUp(2.5),
+  fMaxResid(4.)        
+
 {
   //
   // constructor
index 6ad72eb..7cbec42 100644 (file)
@@ -23,12 +23,32 @@ class AliVZERORecoParam : public AliDetectorRecoParam
   void SetEndClock(Int_t end) {fEndClock = end; }
   void SetNPreClocks(Int_t preClocks) { fNPreClocks = preClocks; }
   void SetNPostClocks(Int_t postClocks) { fNPostClocks = postClocks; }
+  void SetAdcThresHold(Float_t val) { fAdcThresHold = val;}
+  void SetTimeWindowBBALow(Float_t val) { fTimeWindowBBALow = val; }
+  void SetTimeWindowBBAUp (Float_t val) { fTimeWindowBBAUp  = val; }
+  void SetTimeWindowBGALow(Float_t val) { fTimeWindowBGALow = val; }
+  void SetTimeWindowBGAUp (Float_t val) { fTimeWindowBGAUp  = val; }
+  void SetTimeWindowBBCLow(Float_t val) { fTimeWindowBBCLow = val; }
+  void SetTimeWindowBBCUp (Float_t val) { fTimeWindowBBCUp  = val; }
+  void SetTimeWindowBGCLow(Float_t val) { fTimeWindowBGCLow = val; }
+  void SetTimeWindowBGCUp (Float_t val) { fTimeWindowBGCUp  = val; }
+  void SetMaxResid (Float_t val) { fMaxResid  = val; }
 
   Float_t GetNSigmaPed() const { return fNSigmaPed; }
   Int_t  GetStartClock() const { return fStartClock; }
   Int_t  GetEndClock() const { return fEndClock; }
   Int_t  GetNPreClocks() const { return fNPreClocks; }
   Int_t  GetNPostClocks() const { return fNPostClocks; }
+  Float_t  GetAdcThresHold() const { return fAdcThresHold; }
+  Float_t  GetTimeWindowBBALow() const { return fTimeWindowBBALow; }
+  Float_t  GetTimeWindowBBAUp () const { return fTimeWindowBBAUp ; }
+  Float_t  GetTimeWindowBGALow() const { return fTimeWindowBGALow; }
+  Float_t  GetTimeWindowBGAUp () const { return fTimeWindowBGAUp ; }
+  Float_t  GetTimeWindowBBCLow() const { return fTimeWindowBBCLow; }
+  Float_t  GetTimeWindowBBCUp () const { return fTimeWindowBBCUp ; }
+  Float_t  GetTimeWindowBGCLow() const { return fTimeWindowBGCLow; }
+  Float_t  GetTimeWindowBGCUp () const { return fTimeWindowBGCUp ; }
+  Float_t  GetMaxResid () const { return fMaxResid; }
 
  private:
 
@@ -37,11 +57,22 @@ class AliVZERORecoParam : public AliDetectorRecoParam
   Int_t fEndClock;     // End clock for max adc search
   Int_t fNPreClocks;   // Number of pre-clocks used in adc charge sum
   Int_t fNPostClocks;  // Number of post-clocks used in adc charge sum
+  // Cuts used in the trigger mask creation
+  Float_t fAdcThresHold; // Threshold on the ADC
+  Float_t fTimeWindowBBALow;  // BBA window (lower cut)
+  Float_t fTimeWindowBBAUp;   // BBA window (upper cut)
+  Float_t fTimeWindowBGALow;  // BGA window (lower cut)
+  Float_t fTimeWindowBGAUp;   // BGA window (upper cut)
+  Float_t fTimeWindowBBCLow;  // BBC window (lower cut)
+  Float_t fTimeWindowBBCUp;   // BBC window (upper cut)
+  Float_t fTimeWindowBGCLow;  // BGC window (lower cut)
+  Float_t fTimeWindowBGCUp;   // BGC window (upper cut)
+  Float_t fMaxResid;                 // Maximum residual of a single channel time
 
   AliVZERORecoParam(const AliVZERORecoParam & param);
   AliVZERORecoParam & operator=(const AliVZERORecoParam &param);
 
-  ClassDef(AliVZERORecoParam,2) // VZERO reco parameters
+  ClassDef(AliVZERORecoParam,3) // VZERO reco parameters
 };
 
 #endif
index a78de02..cace640 100644 (file)
@@ -384,6 +384,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   // now fill the V0 decision and channel flags
   {
     AliVZEROTriggerMask triggerMask;
+    triggerMask.SetRecoParam(GetRecoParam());
     triggerMask.FillMasks(fESDVZERO, fCalibData, fTimeSlewing);
   }
 
index 029a718..ee23c57 100644 (file)
@@ -42,21 +42,9 @@ ClassImp(AliVZEROTriggerMask)
 
 AliVZEROTriggerMask::AliVZEROTriggerMask()
   :TObject(),
-   fAdcThresHold(0.0),
-   fTimeWindowBBALow(-9.5),
-   fTimeWindowBBAUp(22.5),
-   fTimeWindowBGALow(-2.5),
-   fTimeWindowBGAUp(5.0),
-   fTimeWindowFakeALow(-17.5),
-   fTimeWindowFakeAUp(-9.5),
-   fTimeWindowBBCLow(-2.5),
-   fTimeWindowBBCUp(22.5),
-   fTimeWindowBGCLow(-2.5),
-   fTimeWindowBGCUp(2.5),
-   fTimeWindowFakeCLow(-22.5),
-   fTimeWindowFakeCUp(-8.5),
    fV0ADist(0),
-   fV0CDist(0)
+   fV0CDist(0),
+   fRecoParam(NULL)
 {
   // Default constructor
   //
@@ -109,11 +97,6 @@ void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
   esdV0->SetBit(AliESDVZERO::kTriggerBitsFilled,kTRUE);
   esdV0->SetBit(AliESDVZERO::kDecisionFilled,kTRUE);
 
-  UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A
-  UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A
-  UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C
-  UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C
-
   const Float_t p1 = 2.50; // photostatistics term in the time resolution
   const Float_t p2 = 3.00; // slewing related term in the time resolution
 
@@ -121,9 +104,12 @@ void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
   Float_t timeAW = 0,timeCW = 0;
   Float_t weightA = 0,weightC = 0;
   Int_t ntimeA = 0, ntimeC = 0;
+  Double_t timesA[32], timesC[32];
+  Double_t wA[32],wC[32];
+  Int_t indA[32], indC[32];
   for (Int_t i = 0; i < 64; ++i) {
     Float_t adc = esdV0->GetAdc(i);
-    if (adc > fAdcThresHold) {
+    if (adc > GetRecoParam()->GetAdcThresHold()) {
       Float_t tdc = esdV0->GetTime(i);
       if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) {
        Float_t nphe = adc*kChargePerADC/(cal->GetGain(i)*TMath::Qe());
@@ -134,71 +120,119 @@ void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
                                      (cal->GetCalibDiscriThr(i,kTRUE)*cal->GetCalibDiscriThr(i,kTRUE)));
 
        if (i < 32) { // in V0C
+         timesC[ntimeC] = tdc;
+         wC[ntimeC] = 1.0/(timeErr*timeErr);
+         indC[ntimeC] = i;
          ntimeC++;
          timeCW += tdc/(timeErr*timeErr);
          weightC += 1.0/(timeErr*timeErr);
-
-         if (tdc > (fV0CDist + fTimeWindowBBCLow) &&
-             tdc < (fV0CDist + fTimeWindowBBCUp))
-           aBBtriggerV0C |= (1 << i);
-         if (tdc > (-fV0CDist + fTimeWindowBGCLow) &&
-             tdc < (-fV0CDist + fTimeWindowBGCUp))
-           aBGtriggerV0C |= (1 << i); 
        }
        else { // in V0A
+         timesA[ntimeA] = tdc;
+         wA[ntimeA] = 1.0/(timeErr*timeErr);
+         indA[ntimeA] = i - 32;
          ntimeA++;
          timeAW += tdc/(timeErr*timeErr);
          weightA += 1.0/(timeErr*timeErr);
-
-         Int_t shift = i - 32;
-         if (tdc > (fV0ADist + fTimeWindowBBALow) &&
-             tdc < (fV0ADist + fTimeWindowBBAUp)) 
-           aBBtriggerV0A |= (1 << shift);
-         if (tdc > (-fV0ADist + fTimeWindowBGALow) &&
-             tdc < (-fV0ADist + fTimeWindowBGAUp))
-           aBGtriggerV0A |= (1 << shift); 
        }
       }
     }
   } // end of loop over channels
 
-  esdV0->SetBBtriggerV0A(aBBtriggerV0A);
-  esdV0->SetBGtriggerV0A(aBGtriggerV0A);
-  esdV0->SetBBtriggerV0C(aBBtriggerV0C);
-  esdV0->SetBGtriggerV0C(aBGtriggerV0C);
-
   if (weightA > 0) timeAW = timeAW/weightA;
   else timeAW = AliVZEROReconstructor::kInvalidTime;
 
   if (weightC > 0) timeCW = timeCW/weightC;
   else timeCW = AliVZEROReconstructor::kInvalidTime;
 
-  esdV0->SetV0ATime(timeAW);
-  esdV0->SetV0CTime(timeCW);
-  esdV0->SetV0ATimeError((weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0);
-  esdV0->SetV0CTimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0);
+  esdV0->SetBit(AliESDVZERO::kRobustMeanTime,kTRUE);
+
+  Double_t medianTimeA = AliVZEROReconstructor::kInvalidTime;
+  if (ntimeA > 0) medianTimeA = TMath::Median(ntimeA,timesA,wA);
+  Double_t medianTimeC = AliVZEROReconstructor::kInvalidTime;
+  if (ntimeC > 0) medianTimeC = TMath::Median(ntimeC,timesC,wC);
+
+  Float_t robTimeAW = 0,robTimeCW = 0;
+  Float_t robWeightA = 0,robWeightC = 0;
+  Int_t nrobTimeA = 0, nrobTimeC = 0;
+  Int_t robIndA[32], robIndC[32];
+  for(Int_t i = 0; i < ntimeA; ++i) {
+    AliDebug(1,Form("ChannelsAResiduals %f %f %d",timesA[i]-medianTimeA,1./TMath::Sqrt(wA[i]),ntimeA));
+    if (TMath::Abs(timesA[i]-medianTimeA) < GetRecoParam()->GetMaxResid()/TMath::Sqrt(wA[i])) {
+      robIndA[nrobTimeA] = indA[i];
+      nrobTimeA++;
+      robTimeAW += timesA[i]*wA[i];
+      robWeightA += wA[i];
+    }
+  }
+  for(Int_t i = 0; i < ntimeC; ++i) {
+    AliDebug(1,Form("ChannelsCResiduals %f %f %d",timesC[i]-medianTimeC,1./TMath::Sqrt(wC[i]),ntimeC));
+    if (TMath::Abs(timesC[i]-medianTimeC) < GetRecoParam()->GetMaxResid()/TMath::Sqrt(wC[i])) {
+      robIndC[nrobTimeC] = indC[i];
+      nrobTimeC++;
+      robTimeCW += timesC[i]*wC[i];
+      robWeightC += wC[i];
+    }
+  }
+
+  if (robWeightA > 0) robTimeAW = robTimeAW/robWeightA;
+  else robTimeAW = AliVZEROReconstructor::kInvalidTime;
+
+  if (robWeightC > 0) robTimeCW = robTimeCW/robWeightC;
+  else robTimeCW = AliVZEROReconstructor::kInvalidTime;
+
+  AliDebug(1,Form("V0timesA %f %f %f %f %d",timeAW,(weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0,
+                 medianTimeA,robTimeAW,ntimeA));
+  AliDebug(1,Form("V0timesC %f %f %f %f %d",timeCW,(weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0,
+                 medianTimeC,robTimeCW,ntimeC));
+
+  esdV0->SetV0ATime(robTimeAW);
+  esdV0->SetV0CTime(robTimeCW);
+  esdV0->SetV0ATimeError((robWeightA > 0) ? (1./TMath::Sqrt(robWeightA)) : 0);
+  esdV0->SetV0CTimeError((robWeightC > 0) ? (1./TMath::Sqrt(robWeightC)) : 0);
 
   esdV0->SetV0ADecision(AliESDVZERO::kV0Empty);
   esdV0->SetV0CDecision(AliESDVZERO::kV0Empty);
 
-  if (timeAW > (fV0ADist + fTimeWindowBBALow) &&
-      timeAW < (fV0ADist + fTimeWindowBBAUp)) 
+  if (robTimeAW > (fV0ADist + GetRecoParam()->GetTimeWindowBBALow()) &&
+      robTimeAW < (fV0ADist + GetRecoParam()->GetTimeWindowBBAUp())) 
     esdV0->SetV0ADecision(AliESDVZERO::kV0BB);
-  else if (timeAW > (-fV0ADist + fTimeWindowBGALow) &&
-          timeAW < (-fV0ADist + fTimeWindowBGAUp))
+  else if (robTimeAW > (-fV0ADist + GetRecoParam()->GetTimeWindowBGALow()) &&
+          robTimeAW < (-fV0ADist + GetRecoParam()->GetTimeWindowBGAUp()))
     esdV0->SetV0ADecision(AliESDVZERO::kV0BG);
-  else if (timeAW > (fV0ADist + fTimeWindowFakeALow) &&
-          timeAW < (fV0ADist + fTimeWindowFakeAUp))
+  else if (robTimeAW > (AliVZEROReconstructor::kInvalidTime + 1e-6))
     esdV0->SetV0ADecision(AliESDVZERO::kV0Fake);
 
-  if (timeCW > (fV0CDist + fTimeWindowBBCLow) &&
-      timeCW < (fV0CDist + fTimeWindowBBCUp)) 
+  if (robTimeCW > (fV0CDist + GetRecoParam()->GetTimeWindowBBCLow()) &&
+      robTimeCW < (fV0CDist + GetRecoParam()->GetTimeWindowBBCUp())) 
     esdV0->SetV0CDecision(AliESDVZERO::kV0BB);
-  else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) &&
-          timeCW < (-fV0CDist + fTimeWindowBGCUp))
+  else if (robTimeCW > (-fV0CDist + GetRecoParam()->GetTimeWindowBGCLow()) &&
+          robTimeCW < (-fV0CDist + GetRecoParam()->GetTimeWindowBGCUp()))
     esdV0->SetV0CDecision(AliESDVZERO::kV0BG);
-  else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) &&
-          timeCW < (fV0CDist + fTimeWindowFakeCUp))
+  else if (robTimeCW > (AliVZEROReconstructor::kInvalidTime + 1e-6))
     esdV0->SetV0CDecision(AliESDVZERO::kV0Fake);
 
+  UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A
+  UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A
+  UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C
+  UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C
+
+  for(Int_t i = 0; i < nrobTimeA; ++i) {
+    if (esdV0->GetV0ADecision() == AliESDVZERO::kV0BB)
+      aBBtriggerV0A |= (1 << (robIndA[i]));
+    else if (esdV0->GetV0ADecision() == AliESDVZERO::kV0BG)
+      aBGtriggerV0A |= (1 << (robIndA[i]));
+  }
+
+  for(Int_t i = 0; i < nrobTimeC; ++i) {
+    if (esdV0->GetV0CDecision() == AliESDVZERO::kV0BB)
+      aBBtriggerV0C |= (1 << (robIndC[i]));
+    else if (esdV0->GetV0CDecision() == AliESDVZERO::kV0BG)
+      aBGtriggerV0C |= (1 << (robIndC[i]));
+  }
+
+  esdV0->SetBBtriggerV0A(aBBtriggerV0A);
+  esdV0->SetBGtriggerV0A(aBGtriggerV0A);
+  esdV0->SetBBtriggerV0C(aBBtriggerV0C);
+  esdV0->SetBGtriggerV0C(aBGtriggerV0C);
 }
index 5088458..56750a9 100644 (file)
@@ -7,10 +7,12 @@
 ///_________________________________________________________________________   
 
 #include <TObject.h>
+
 class TTree;
 class TClonesArray;
 class AliESDVZERO;
 class AliVZEROCalibData;
+class AliVZERORecoParam;
 
 class AliVZEROTriggerMask : public TObject
 {
@@ -23,38 +25,25 @@ class AliVZEROTriggerMask : public TObject
                  TF1 *slewing);
    Double_t GetZPosition(const char* symname);
 
-   void            SetAdcThreshold(Float_t thr) 
-     {fAdcThresHold=thr;}
-   void            SetTimeWindowBBA(Float_t wlow,Float_t wup)
-     {fTimeWindowBBALow=wlow; fTimeWindowBBAUp=wup;}
-   void            SetTimeWindowBBC(Float_t wlow,Float_t wup)
-     {fTimeWindowBBCLow=wlow; fTimeWindowBBCUp=wup;}
-   void            SetTimeWindowBGA(Float_t wlow,Float_t wup) 
-     {fTimeWindowBGALow=wlow; fTimeWindowBGAUp=wup;}
-   void            SetTimeWindowBGC(Float_t wlow,Float_t wup) 
-     {fTimeWindowBGCLow=wlow; fTimeWindowBGCUp=wup;}
+   void SetRecoParam(const AliVZERORecoParam *param) { fRecoParam = param; }
+   const AliVZERORecoParam* GetRecoParam() const
+   {
+     if (!fRecoParam) {
+       AliFatal("Reco-param object is not set!");
+       return NULL;
+     }
+     return fRecoParam;
+   }
 
 private:
-
-   Float_t fAdcThresHold; // Threshold on the ADC
-   Float_t fTimeWindowBBALow;  // BBA window (lower cut)
-   Float_t fTimeWindowBBAUp;   // BBA window (upper cut)
-   Float_t fTimeWindowBGALow;  // BGA window (lower cut)
-   Float_t fTimeWindowBGAUp;   // BGA window (upper cut)
-   Float_t fTimeWindowFakeALow;// Fake V0A window (lower cut)
-   Float_t fTimeWindowFakeAUp; // Fake V0A window (upper cut)
-   Float_t fTimeWindowBBCLow;  // BBC window (lower cut)
-   Float_t fTimeWindowBBCUp;   // BBC window (upper cut)
-   Float_t fTimeWindowBGCLow;  // BGC window (lower cut)
-   Float_t fTimeWindowBGCUp;   // BGC window (upper cut)
-   Float_t fTimeWindowFakeCLow;// Fake V0C window (lower cut)
-   Float_t fTimeWindowFakeCUp; // Fake V0C window (upper cut)
+   AliVZEROTriggerMask(const AliVZEROTriggerMask& mask);
+   AliVZEROTriggerMask& operator = (const AliVZEROTriggerMask& mask);
 
    Float_t fV0ADist;     // Z position of V0A
    Float_t fV0CDist;     // Z position of V0C
+   const AliVZERORecoParam* fRecoParam; //! Pointer to VZERO reco-param object
 
-
-   ClassDef( AliVZEROTriggerMask, 2 )  // VZERO Trigger Detector class
+   ClassDef( AliVZEROTriggerMask, 3 )  // VZERO Trigger Detector class
 };
 
 #endif // ALIVZEROTRIGGERMASK_H