Major update of the reconstruction. All the code from the ANALYSIS/AliTriggerAnalysis...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 29 Apr 2010 13:44:34 +0000 (13:44 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 29 Apr 2010 13:44:34 +0000 (13:44 +0000)
STEER/AliESDVZERO.cxx
STEER/AliESDVZERO.h
VZERO/AliVZEROConst.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h
VZERO/AliVZEROTriggerMask.cxx
VZERO/AliVZEROTriggerMask.h

index 5a77f33..e625361 100644 (file)
@@ -9,7 +9,13 @@ AliESDVZERO::AliESDVZERO()
    fBBtriggerV0A(0),
    fBGtriggerV0A(0),
    fBBtriggerV0C(0),
-   fBGtriggerV0C(0)
+   fBGtriggerV0C(0),
+   fV0ATime(-1024),
+   fV0CTime(-1024),
+   fV0ATimeError(0),
+   fV0CTimeError(0),
+   fV0ADecision(kV0Invalid),
+   fV0CDecision(kV0Invalid)
 {   
    // Default constructor 
    for(Int_t j=0; j<64; j++){ 
@@ -28,7 +34,13 @@ AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
    fBBtriggerV0A(o.fBBtriggerV0A),
    fBGtriggerV0A(o.fBGtriggerV0A),
    fBBtriggerV0C(o.fBBtriggerV0C),
-   fBGtriggerV0C(o.fBGtriggerV0C)
+   fBGtriggerV0C(o.fBGtriggerV0C),
+   fV0ATime(o.fV0ATime),
+   fV0CTime(o.fV0CTime),
+   fV0ATimeError(o.fV0ATimeError),
+   fV0CTimeError(o.fV0CTimeError),
+   fV0ADecision(o.fV0ADecision),
+   fV0CDecision(o.fV0CDecision)
 {   
    // Default constructor 
    for(Int_t j=0; j<64; j++) {
@@ -50,8 +62,13 @@ AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
    fBBtriggerV0A(BBtriggerV0A),
    fBGtriggerV0A(BGtriggerV0A),
    fBBtriggerV0C(BBtriggerV0C),
-   fBGtriggerV0C(BGtriggerV0C)
-
+   fBGtriggerV0C(BGtriggerV0C),
+   fV0ATime(-1024),
+   fV0CTime(-1024),
+   fV0ATimeError(0),
+   fV0CTimeError(0),
+   fV0ADecision(kV0Invalid),
+   fV0CDecision(kV0Invalid)
 {
    // Constructor
    for(Int_t j=0; j<64; j++) {
@@ -75,6 +92,14 @@ AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
   fBGtriggerV0A=o.fBGtriggerV0A;
   fBBtriggerV0C=o.fBBtriggerV0C;
   fBGtriggerV0C=o.fBGtriggerV0C;
+
+  fV0ATime = o.fV0ATime;
+  fV0CTime = o.fV0CTime;
+  fV0ATimeError = o.fV0ATimeError;
+  fV0CTimeError = o.fV0CTimeError;
+  fV0ADecision = o.fV0ADecision;
+  fV0CDecision = o.fV0CDecision;
+
    for(Int_t j=0; j<64; j++) {
        fMultiplicity[j] = o.fMultiplicity[j];
        fAdc[j]    = o.fAdc[j];
index 43e6927..26251c9 100644 (file)
@@ -14,6 +14,13 @@ public:
              Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag);
 
   virtual ~AliESDVZERO() {};
+
+  enum {
+    kCorrectedLeadingTime = BIT(14),
+    kTriggerBitsFilled = BIT(15),
+    kDecisionFilled = BIT(16)
+  };
+  enum Decision { kV0Invalid = -1, kV0Empty = 0, kV0BB, kV0BG, kV0Fake };
   
   // Setters
   virtual void SetBBtriggerV0A(UInt_t BBtrigger) {fBBtriggerV0A=BBtrigger;}
@@ -32,6 +39,14 @@ public:
     {for(Int_t i=0;i<64;i++) fBBFlag[i]=BBFlag[i];} 
   virtual void SetBGFlag(Bool_t BGFlag[64])
     {for(Int_t i=0;i<64;i++) fBGFlag[i]=BGFlag[i];}   
+
+  void SetV0ATime(Float_t time) {fV0ATime = time;}
+  void SetV0CTime(Float_t time) {fV0CTime = time;}
+  void SetV0ATimeError(Float_t err) {fV0ATimeError = err;}
+  void SetV0CTimeError(Float_t err) {fV0CTimeError = err;}
+
+  void SetV0ADecision(Decision des) {fV0ADecision = des;}
+  void SetV0CDecision(Decision des) {fV0CDecision = des;}
          
   // Getters  
   Short_t  GetNbPMV0A();
@@ -61,6 +76,14 @@ public:
   Bool_t   BGTriggerV0C(Int_t i);  
   Bool_t   GetBBFlag(Int_t i);
   Bool_t   GetBGFlag(Int_t i);
+
+  Float_t  GetV0ATime() const { return fV0ATime; }
+  Float_t  GetV0CTime() const { return fV0CTime; }
+  Float_t  GetV0ATimeError() const { return fV0ATimeError; }
+  Float_t  GetV0CTimeError() const { return fV0CTimeError; }
+
+  Decision GetV0ADecision() const { return fV0ADecision; }
+  Decision GetV0CDecision() const { return fV0CDecision; }
   
   Bool_t OutOfRange(Int_t i, const char *s, Int_t upper) const;
   AliESDVZERO &operator=(const AliESDVZERO& source);
@@ -78,8 +101,16 @@ protected:
   Float_t fWidth[64];        //  time width for each channel
   Bool_t  fBBFlag[64];       //  BB Flags from Online V0 Electronics
   Bool_t  fBGFlag[64];       //  BG Flags from Online V0 Electronics
-  
-  ClassDef(AliESDVZERO,7)
+
+  Float_t fV0ATime;          // Average time in V0A
+  Float_t fV0CTime;          // Average time in V0C
+  Float_t fV0ATimeError;     // Error in the average time in V0A
+  Float_t fV0CTimeError;     // Error in the average time in V0C
+
+  Decision fV0ADecision;     // V0A final decision based on average time of channels
+  Decision fV0CDecision;     // V0C final decision based on average time of channels
+
+  ClassDef(AliESDVZERO,8)
 };
 
 #endif
index 60f0881..f706ffc 100644 (file)
@@ -3,7 +3,7 @@
 
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. */
 
-const Float_t kIntTimeRes = 0.5; // intrinsic time resolution of the scintillator
+const Float_t kIntTimeRes = 0.39; // intrinsic time resolution of the scintillator
 const Float_t kV0CDelayCables = 8.1; // delay cables on the C side (in ns)
 const Float_t kV0Offset = 1461.4; // general V0 offset between the TDCs and the trigger
 const Float_t kADCTimeOffset = -189.0; // ADC sampling clock offset (in ns)
index 214779c..ff0806d 100644 (file)
@@ -21,6 +21,9 @@
 ///                                                                          //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <TH1F.h>
+#include <TF1.h>
+
 #include "AliRunLoader.h"
 #include "AliRawReader.h"
 #include "AliGRPObject.h"
@@ -29,6 +32,7 @@
 #include "AliCDBEntry.h"
 #include "AliVZEROReconstructor.h"
 #include "AliVZERORawStream.h"
+#include "AliVZEROConst.h"
 #include "AliESDEvent.h"
 #include "AliVZEROTriggerMask.h"
 #include "AliESDfriend.h"
@@ -36,6 +40,7 @@
 #include "AliVZEROdigit.h"
 #include "AliVZEROCalibData.h"
 #include "AliRunInfo.h"
+#include "AliCTPTimeParams.h"
 
 ClassImp(AliVZEROReconstructor)
 
@@ -44,7 +49,8 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
                         fESDVZERO(0x0),
                         fESD(0x0),
                         fESDVZEROfriend(0x0),
-                        fCalibData(GetCalibData()),
+                        fCalibData(NULL),
+                        fTimeSlewing(NULL),
                         fCollisionMode(0),
                         fBeamEnergy(0.),
                         fDigitsArray(0)
@@ -52,8 +58,30 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
   // Default constructor  
   // Get calibration data
   
-  // fCalibData = GetCalibData(); 
-
+  fCalibData = GetCalibData();
+
+  AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
+  if (!entry) AliFatal("CTP timing parameters are not found in OCDB !");
+  AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject();
+  Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0;
+
+  AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeDelays");
+  if (!entry2) AliFatal("VZERO time delays are not found in OCDB !");
+  TH1F *delays = (TH1F*)entry2->GetObject();
+
+  AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing");
+  if (!entry3) AliFatal("VZERO time slewing function is not found in OCDB !");
+  fTimeSlewing = (TF1*)entry3->GetObject();
+
+  for(Int_t i = 0 ; i < 64; ++i) {
+    Int_t board = AliVZEROCalibData::GetBoardNumber(i);
+    fTimeOffset[i] = (((Float_t)fCalibData->GetTriggerCountOffset(board)-
+                       (Float_t)fCalibData->GetRollOver(board))*25.0+
+                      fCalibData->GetTimeOffset(i)+
+                      l1Delay+
+                      delays->GetBinContent(i+1)+
+                      kV0Offset);
+  }
 }
 
 
@@ -237,7 +265,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   for (Int_t i=0; i<64; i++){
        adc[i]    = 0.0;
        mult[i]   = 0.0;
-       time[i]   = 0.0;
+       time[i]   = kInvalidTime;
        width[i]  = 0.0;
        BBFlag[i] = kFALSE;
        BGFlag[i] = kFALSE;
@@ -258,7 +286,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
        Int_t k = pmNumber+64*integrator;
         Float_t  pedestal    = fCalibData->GetPedestal(k);
         adc[pmNumber]   =  digit->ADC() - pedestal; 
-        time[pmNumber]  =  digit->Time();
+        time[pmNumber]  =  CorrectLeadingTime(pmNumber,digit->Time(),adc[pmNumber]);
        width[pmNumber] =  digit->Width();
        BBFlag[pmNumber]=  digit->BBFlag();
        BGFlag[pmNumber]=  digit->BGFlag();
@@ -271,6 +299,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
     } // end of loop over digits
   } // end of loop over events in digits tree
          
+  fESDVZERO->SetBit(AliESDVZERO::kCorrectedLeadingTime,kTRUE);
   fESDVZERO->SetMultiplicity(mult);
   fESDVZERO->SetADC(adc);
   fESDVZERO->SetTime(time);
@@ -278,21 +307,12 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   fESDVZERO->SetBBFlag(BBFlag);
   fESDVZERO->SetBGFlag(BGFlag);
 
-  // now get the trigger mask
-
-  AliVZEROTriggerMask *TriggerMask = new AliVZEROTriggerMask();
-  TriggerMask->SetAdcThreshold(10.0/2.0);
-  TriggerMask->SetTimeWindowWidthBBA(50);
-  TriggerMask->SetTimeWindowWidthBGA(20);
-  TriggerMask->SetTimeWindowWidthBBC(50);
-  TriggerMask->SetTimeWindowWidthBGC(20);
-  TriggerMask->FillMasks(digitsTree, fDigitsArray);
+  // now fill the V0 decision and channel flags
+  {
+    AliVZEROTriggerMask triggerMask;
+    triggerMask.FillMasks(fESDVZERO, fCalibData, fTimeSlewing);
+  }
 
-  fESDVZERO->SetBBtriggerV0A(TriggerMask->GetBBtriggerV0A());
-  fESDVZERO->SetBGtriggerV0A(TriggerMask->GetBGtriggerV0A());
-  fESDVZERO->SetBBtriggerV0C(TriggerMask->GetBBtriggerV0C());
-  fESDVZERO->SetBGtriggerV0C(TriggerMask->GetBGtriggerV0C());
-  
   if (esd) { 
      AliDebug(1, Form("Writing VZERO data to ESD tree"));
      esd->SetVZEROData(fESDVZERO);
@@ -374,17 +394,6 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const
 
   entry = man->Get("VZERO/Calib/Data");
 
-//   if(!entry){
-//     AliWarning("Load of calibration data from default storage failed!");
-//     AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
-//     Int_t runNumber = man->GetRun();
-//     entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
-//       ->Get("VZERO/Calib/Data",runNumber);
-//     
-//   }
-
-  // Retrieval of data in directory VZERO/Calib/Data:
-
   AliVZEROCalibData *calibdata = 0;
 
   if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
@@ -393,3 +402,23 @@ AliVZEROCalibData* AliVZEROReconstructor::GetCalibData() const
   return calibdata;
 }
 
+Float_t AliVZEROReconstructor::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
+{
+  // Correct the leading time
+  // for slewing effect and
+  // misalignment of the channels
+  if (time < 1e-6) return kInvalidTime;
+
+  // Channel alignment and general offset subtraction
+  if (i < 32) time -= kV0CDelayCables;
+  time -= fTimeOffset[i];
+
+  // In case of pathological signals
+  if (adc < 1e-6) return time;
+
+  // Slewing correction
+  Float_t thr = fCalibData->GetDiscriThr(i);
+  time -= fTimeSlewing->Eval(adc/thr);
+
+  return time;
+}
index 6070033..41f81c9 100644 (file)
@@ -19,6 +19,7 @@
 #include "AliESDVZERO.h"
 #include "AliVZERORecoParam.h"
 
+class TF1;
 class AliVZEROCalibData;
 class AliESDEvent;
 class AliESDVZEROfriend;
@@ -51,9 +52,10 @@ public:
   void GetCollisionMode();
   
   AliVZEROCalibData *GetCalibData() const; 
+  Float_t            CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const;
 
   enum {kInvalidADC   =  -1024,
-        kInvalidTime  =  -1};
+        kInvalidTime  =  -1024};
 
 protected:
   AliESDVZERO*        fESDVZERO;       // ESD output object  
@@ -65,13 +67,15 @@ private:
   AliVZEROReconstructor& operator = (const AliVZEROReconstructor& reconstructor);
   
   AliVZEROCalibData* fCalibData;      //! calibration data
+  Float_t            fTimeOffset[64]; //! HPTDC time offsets channel by channel
+  TF1*               fTimeSlewing;    //! Function for time slewing correction
 
   Int_t              fCollisionMode;  // =0->p-p, =1->A-A
   Float_t            fBeamEnergy;     // beam energy
 
   mutable TClonesArray *fDigitsArray; // clones-array for ConvertDigits() and FillESD()
 
-  ClassDef(AliVZEROReconstructor, 1)  // class for the VZERO reconstruction
+  ClassDef(AliVZEROReconstructor, 2)  // class for the VZERO reconstruction
 };
 
 #endif
index c4c9d49..a8f7e97 100644 (file)
 #include <TGeoManager.h>
 #include <TGeoMatrix.h>
 #include <TGeoPhysicalNode.h>
-#include <TTree.h>
-#include <TClonesArray.h>
+#include <TF1.h>
+#include <TMath.h>
 
 #include <AliGeomManager.h>
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliCDBEntry.h"
 #include "AliLog.h"
 #include "AliVZEROTriggerMask.h"
-#include "AliVZEROdigit.h"
+#include "AliVZEROConst.h"
+#include "AliVZEROCalibData.h"
+#include "AliESDVZERO.h"
+#include "AliVZEROReconstructor.h"
 
 //______________________________________________________________________
 ClassImp(AliVZEROTriggerMask)
@@ -43,17 +43,29 @@ ClassImp(AliVZEROTriggerMask)
 AliVZEROTriggerMask::AliVZEROTriggerMask()
   :TObject(),
    fAdcThresHold(0.0),
-   fTimeWindowWidthBBA(50.0),
-   fTimeWindowWidthBGA(20.0),
-   fTimeWindowWidthBBC(50.0),
-   fTimeWindowWidthBGC(20.0),
-   fBBtriggerV0A(0),
-   fBGtriggerV0A(0),
-   fBBtriggerV0C(0),
-   fBGtriggerV0C(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)
 {
-   SetAdcThreshold();
+  // Default constructor
+  //
+  Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
+  Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));
+
+  // distance in time units from nominal vertex to V0
+  fV0ADist = zV0A/TMath::Ccgs()*1e9;
+  fV0CDist = zV0C/TMath::Ccgs()*1e9;
 }
 
 //________________________________________________________________________________
@@ -62,8 +74,10 @@ Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
 //
   Double_t *tr;
   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
-  if (!pne) return 0;
-
+  if (!pne) {
+    AliFatalClass(Form("TGeoPNEntry with symbolic name %s does not exist!",symname));
+    return 0;
+  }
 
   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
   if(pnode){
@@ -72,7 +86,7 @@ Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
   }else{
           const char* path = pne->GetTitle();
           if(!gGeoManager->cd(path)){
-                  AliErrorClass(Form("Volume path %s not valid!",path));
+                  AliFatalClass(Form("Volume path %s not valid!",path));
                   return 0;
           }
          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
@@ -84,57 +98,106 @@ Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
 //________________________________________________________________________________
 
 
-void AliVZEROTriggerMask::FillMasks(TTree* vzeroDigitsTree,
-                               TClonesArray* const vzeroDigits)
+void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
+                                   AliVZEROCalibData *cal,
+                                   TF1 *slewing)
 {
-// Fill up the trigger mask word using the TDC 
-
-  const Double_t lightSpeed = 2.9979245800; // cm/100 ps
-  Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
-  Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));
-
-  // distance in time units from nominal vertex to V0
-  Float_t v0aDist = zV0A/lightSpeed; // 100 of picoseconds
-  Float_t v0cDist = zV0C/lightSpeed; // 100 of picoseconds
-  Float_t bunchSeparation = 1000.0; // 100 of picoseconds
-
-  // mask
-  UInt_t one=1;
-  // loop over vzero entries
-  Int_t nEntries = (Int_t)vzeroDigitsTree->GetEntries();
-  for (Int_t e=0; e<nEntries; e++) {
-    vzeroDigitsTree->GetEvent(e);
-
-    Int_t nDigits = vzeroDigits->GetEntriesFast();
-    
-    for (Int_t d=0; d<nDigits; d++) {
-      //      vzeroDigitsTree->GetEvent(d);
-      AliVZEROdigit* digit = (AliVZEROdigit*)vzeroDigits->At(d);
-      
-      Int_t   pmNumber   = digit->PMNumber();
-      Float_t adc        = digit->ADC();
-      Float_t tdc        = digit->Time()*10.0; // in 100 of picoseconds
-
-      if (adc>fAdcThresHold) {
-       if (pmNumber<32) { // in V0C
-         if (tdc>(v0cDist-fTimeWindowWidthBBC/2.0) &&
-             tdc<(v0cDist+fTimeWindowWidthBBC/2.0))
-           fBBtriggerV0C+=(one<<pmNumber);
-         if (tdc>(bunchSeparation-v0cDist-fTimeWindowWidthBGC/2.0) &&
-             tdc<(bunchSeparation-v0cDist+fTimeWindowWidthBGC/2.0))
-          fBGtriggerV0C+=(one<<pmNumber); 
+  // Fill up the trigger mask word
+  // using the TDC data (already corrected for
+  // slewing and misalignment between channels)
+
+  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.19; // photostatistics term in the time resolution
+  const Float_t p2 = 1.31; // slewing related term in the time resolution
+
+  // loop over vzero channels
+  Float_t timeAW = 0,timeCW = 0;
+  Float_t weightA = 0,weightC = 0;
+  Int_t ntimeA = 0, ntimeC = 0;
+  for (Int_t i = 0; i < 64; ++i) {
+    Float_t adc = esdV0->GetAdc(i);
+    if (adc > fAdcThresHold) {
+      Float_t tdc = esdV0->GetTime(i);
+      if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) {
+       Float_t nphe = adc*kChargePerADC/(cal->GetGain(i)*TMath::Qe());
+       Float_t timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
+                                     p1*p1/nphe+
+                                     p2*p2*(slewing->GetParameter(0)*slewing->GetParameter(1))*(slewing->GetParameter(0)*slewing->GetParameter(1))*
+                                     TMath::Power(adc/cal->GetDiscriThr(i),2.*(slewing->GetParameter(1)-1.)));
+
+       if (i < 32) { // in V0C
+         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); 
        }
-       if (pmNumber>31) { // in V0A
-         Int_t shift = pmNumber-32;
-         if (tdc>(v0aDist-fTimeWindowWidthBBA/2.0) &&
-             tdc<(v0aDist+fTimeWindowWidthBBA/2.0)) 
-           fBBtriggerV0A+=(one<<shift);
-         if (tdc>(bunchSeparation-v0aDist-fTimeWindowWidthBGA/2.0) &&
-             tdc<(bunchSeparation-v0aDist+fTimeWindowWidthBGA/2.0))
-           fBGtriggerV0A+=(one<<shift); 
+       else { // in V0A
+         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 digits
-  } // end of loop over events in digits tree
+    }
+  } // 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->SetV0ATimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0);
+
+  esdV0->SetV0ADecision(AliESDVZERO::kV0Empty);
+  esdV0->SetV0CDecision(AliESDVZERO::kV0Empty);
+
+  if (timeAW > (fV0ADist + fTimeWindowBBALow) &&
+      timeAW < (fV0ADist + fTimeWindowBBAUp)) 
+    esdV0->SetV0ADecision(AliESDVZERO::kV0BB);
+  else if (timeAW > (-fV0ADist + fTimeWindowBGALow) &&
+          timeAW < (-fV0ADist + fTimeWindowBGAUp))
+    esdV0->SetV0ADecision(AliESDVZERO::kV0BG);
+  else if (timeAW > (fV0ADist + fTimeWindowFakeALow) &&
+          timeAW < (fV0ADist + fTimeWindowFakeAUp))
+    esdV0->SetV0ADecision(AliESDVZERO::kV0Fake);
+
+  if (timeCW > (fV0CDist + fTimeWindowBBCLow) &&
+      timeCW < (fV0CDist + fTimeWindowBBCUp)) 
+    esdV0->SetV0CDecision(AliESDVZERO::kV0BB);
+  else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) &&
+          timeCW < (-fV0CDist + fTimeWindowBGCUp))
+    esdV0->SetV0CDecision(AliESDVZERO::kV0BG);
+  else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) &&
+          timeCW < (fV0CDist + fTimeWindowFakeCUp))
+    esdV0->SetV0CDecision(AliESDVZERO::kV0Fake);
+
 }
index 8e506d3..5088458 100644 (file)
@@ -9,6 +9,8 @@
 #include <TObject.h>
 class TTree;
 class TClonesArray;
+class AliESDVZERO;
+class AliVZEROCalibData;
 
 class AliVZEROTriggerMask : public TObject
 {
@@ -16,40 +18,43 @@ class AliVZEROTriggerMask : public TObject
                    AliVZEROTriggerMask();   // constructor
    virtual        ~AliVZEROTriggerMask(){}  // destructor
 
-   void FillMasks(TTree* vzeroDigitsTree,
-                 TClonesArray* const vzeroDigits);
+   void FillMasks(AliESDVZERO *esdV0,
+                 AliVZEROCalibData *cal,
+                 TF1 *slewing);
    Double_t GetZPosition(const char* symname);
 
-   void            SetAdcThreshold(Float_t t=55.0) 
-     {fAdcThresHold=t;}
-   void            SetTimeWindowWidthBBA(Float_t w=50.0)
-     {fTimeWindowWidthBBA=w;}
-   void            SetTimeWindowWidthBBC(Float_t w=50.0)
-     {fTimeWindowWidthBBC=w;}
-   void            SetTimeWindowWidthBGA(Float_t w=20.0) 
-     {fTimeWindowWidthBGA=w;}
-   void            SetTimeWindowWidthBGC(Float_t w=20.0) 
-     {fTimeWindowWidthBGC=w;}
-
-   UInt_t GetBBtriggerV0A() const { return fBBtriggerV0A;}
-   UInt_t GetBGtriggerV0A() const { return fBGtriggerV0A;}
-   UInt_t GetBBtriggerV0C() const { return fBBtriggerV0C;}
-   UInt_t GetBGtriggerV0C() const { return fBGtriggerV0C;}
+   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;}
 
 private:
 
    Float_t fAdcThresHold; // Threshold on the ADC
-   Float_t fTimeWindowWidthBBA; // size of the BBA window
-   Float_t fTimeWindowWidthBGA; // size of the BGA window
-   Float_t fTimeWindowWidthBBC; // size of the BBC window
-   Float_t fTimeWindowWidthBGC; // size of the BGC window
-   UInt_t fBBtriggerV0A; // bit mask for Beam-Beam trigger in V0A
-   UInt_t fBGtriggerV0A; // bit mask for Beam-Gas trigger in V0A
-   UInt_t fBBtriggerV0C; // bit mask for Beam-Beam trigger in V0C
-   UInt_t fBGtriggerV0C; // bit mask for Beam-Gas trigger in V0C
-
-
-   ClassDef( AliVZEROTriggerMask, 1 )  // VZERO Trigger Detector class
+   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)
+
+   Float_t fV0ADist;     // Z position of V0A
+   Float_t fV0CDist;     // Z position of V0C
+
+
+   ClassDef( AliVZEROTriggerMask, 2 )  // VZERO Trigger Detector class
 };
 
 #endif // ALIVZEROTRIGGERMASK_H