Trigger bit mask and multiplicity per PMT in the VZERO ESD. Related changes and class...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 25 Jun 2008 10:49:15 +0000 (10:49 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 25 Jun 2008 10:49:15 +0000 (10:49 +0000)
STEER/AliESDVZERO.cxx
STEER/AliESDVZERO.h
VZERO/AliVZEROQADataMakerRec.cxx
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROTrigger.cxx
VZERO/AliVZEROTrigger.h
VZERO/AliVZEROTriggerMask.cxx [new file with mode: 0644]
VZERO/AliVZEROTriggerMask.h [new file with mode: 0644]
VZERO/VZEROsimLinkDef.h
VZERO/libVZEROsim.pkg

index be9422e..a264b5a 100644 (file)
+#include <Riostream.h>
 #include "AliESDVZERO.h"
 
 ClassImp(AliESDVZERO)
 
-AliESDVZERO::AliESDVZERO():TObject(),
-   fMTotV0A(0),
-   fMTotV0C(0),
-   fNbPMV0A(0),
-   fNbPMV0C(0)
-
+AliESDVZERO::AliESDVZERO()
+  :TObject(),
+   fBBtriggerV0A(0),
+   fBGtriggerV0A(0),
+   fBBtriggerV0C(0),
+   fBGtriggerV0C(0)
 {   
    // Default constructor 
-   for(Int_t j=0; j<4; j++){ 
-       fMRingV0A[j] = fMRingV0C[j] = 0;   
+   for(Int_t j=0; j<64; j++){ 
+      fMultiplicity[j] = 0;   
    }
 }
 
 AliESDVZERO::AliESDVZERO(const AliESDVZERO &o)
   :TObject(o),
-   fMTotV0A(o.fMTotV0A),
-   fMTotV0C(o.fMTotV0C),
-   fNbPMV0A(o.fNbPMV0A),
-   fNbPMV0C(o.fNbPMV0C)
+   fBBtriggerV0A(o.fBBtriggerV0A),
+   fBGtriggerV0A(o.fBGtriggerV0A),
+   fBBtriggerV0C(o.fBBtriggerV0C),
+   fBGtriggerV0C(o.fBGtriggerV0C)
 {   
    // Default constructor 
-   for(Int_t j=0; j<4; j++){ 
-       fMRingV0A[j] = o.fMRingV0A[j];
-       fMRingV0C[j] = o.fMRingV0C[j];   
-   }
+   for(Int_t j=0; j<64; j++)
+       fMultiplicity[j] = o.fMultiplicity[j];
 }
 
-AliESDVZERO::AliESDVZERO(Int_t NbPMV0A, Int_t NbPMV0C, Int_t MTotV0A ,
-             Int_t MTotV0C, Int_t* MRingV0A, Int_t* MRingV0C) 
+AliESDVZERO::AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
+             UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
+             Short_t *Multiplicity)
   :TObject(),
-   fMTotV0A(MTotV0A),
-   fMTotV0C(MTotV0C),
-   fNbPMV0A(NbPMV0A),
-   fNbPMV0C(NbPMV0C)
+   fBBtriggerV0A(BBtriggerV0A),
+   fBGtriggerV0A(BGtriggerV0A),
+   fBBtriggerV0C(BBtriggerV0C),
+   fBGtriggerV0C(BGtriggerV0C)
+
 {
    // Constructor
-   for(Int_t j=0; j<4; j++){ 
-       fMRingV0A[j] = MRingV0A[j];
-       fMRingV0C[j] = MRingV0C[j]; }   
+   for(Int_t j=0; j<64; j++)
+       fMultiplicity[j] = Multiplicity[j];
 }
 
+
 AliESDVZERO& AliESDVZERO::operator=(const AliESDVZERO& o)
 {
 
-  if(this==&o)return *this;
+  if(this==&o) return *this;
   TObject::operator=(o);
   // Assignment operator
-  fMTotV0A=o.fMTotV0A;
-  fMTotV0C=o.fMTotV0C;
-  fNbPMV0A=o.fNbPMV0A;
-  fNbPMV0C=o.fNbPMV0C;
+  fBBtriggerV0A=o.fBBtriggerV0A;
+  fBGtriggerV0A=o.fBGtriggerV0A;
+  fBBtriggerV0C=o.fBBtriggerV0C;
+  fBGtriggerV0C=o.fBGtriggerV0C;
+   for(Int_t j=0; j<64; j++)
+       fMultiplicity[j] = o.fMultiplicity[j];
+  return *this;
+}
 
+Short_t AliESDVZERO::GetNbPMV0A()
+{
+  Short_t n=0;
+  for(Int_t i=32;i<64;i++) 
+    if (fMultiplicity[i]>0) n++;
+  return n;
+}
 
-  for(Int_t j=0; j<4; j++){ 
-      fMRingV0A[j] = o.fMRingV0A[j];
-      fMRingV0C[j] = o.fMRingV0C[j];   }
+Short_t AliESDVZERO::GetNbPMV0C()
+{
+  Short_t n=0;
+  for(Int_t i=0;i<32;i++) 
+    if (fMultiplicity[i]>0) n++;
+  return n;
+}
 
-  return *this;
+Int_t AliESDVZERO::GetMTotV0A()
+{
+  Int_t n=0;
+  for(Int_t i=32;i<64;i++) 
+    n+= (Int_t) fMultiplicity[i];
+  return n;
+}
+
+Int_t AliESDVZERO::GetMTotV0C()
+{
+  Int_t n=0;
+  for(Int_t i=0;i<32;i++) 
+    n+= (Int_t) fMultiplicity[i];
+  return n;
+}
+
+
+Int_t* AliESDVZERO::GetMRingV0A()
+{
+  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
+  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
+  return 0x0;
+}
+
+Int_t* AliESDVZERO::GetMRingV0C()
+{
+  cout << "AliESDVZERO::GetMRingV0C() not supported any more" << endl;
+  cout << "use Int_t AliESDVZERO::GetMRingV0C(Int_t ring)" << endl;
+  return 0x0;
 }
 
+Int_t AliESDVZERO::GetMRingV0A(Int_t ring)
+{ 
+  if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0A",4)) return -1;
+  Int_t n=0;
 
-void AliESDVZERO::Copy(TObject &obj) const {
-  
-  // this overwrites the virtual TOBject::Copy()
-  // to allow run time copying without casting
-  // in AliESDEvent
+  if (ring == 0) for(Int_t i=32;i<40;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 1) for(Int_t i=40;i<48;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 2) for(Int_t i=48;i<56;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 3) for(Int_t i=56;i<64;i++) n += (Int_t) fMultiplicity[i];
+  return n ;
+}
 
-  if(this==&obj)return;
-  AliESDVZERO *robj = dynamic_cast<AliESDVZERO*>(&obj);
-  if(!robj)return; // not an AliESDVZERO
-  *robj = *this;
+Int_t AliESDVZERO::GetMRingV0C(Int_t ring)
+{ 
+  if (OutOfRange(ring, "AliESDVZERO:::GetMRingV0C",4)) return -1;
+  Int_t n=0;
 
+  if (ring == 0) for(Int_t i=0;i<8;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 1) for(Int_t i=8;i<16;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 2) for(Int_t i=16;i<24;i++) n += (Int_t) fMultiplicity[i];
+  if (ring == 3) for(Int_t i=24;i<32;i++) n += (Int_t) fMultiplicity[i];
+  return n ;
 }
 
+Int_t AliESDVZERO::GetMultiplicity(Int_t i)
+
+{
+  if (OutOfRange(i, "AliESDVZERO::GetMultiplicity:",64)) return -1;
+  return fMultiplicity[i];
+}
+
+Bool_t AliESDVZERO::BBTriggerV0A(Int_t i)
+{
+  if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0A",32)) return kFALSE;
+  UInt_t test = 1;
+  return ( fBBtriggerV0A & (test << i) ? kTRUE : kFALSE );
+}
+
+Bool_t AliESDVZERO::BGTriggerV0A(Int_t i)
+{
+  if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0A",32)) return kFALSE;
+  UInt_t test = 1;
+  return ( fBGtriggerV0A & (test << i) ? kTRUE : kFALSE );
+}
+
+Bool_t AliESDVZERO::BBTriggerV0C(Int_t i)
+{
+  if (OutOfRange(i, "AliESDVZERO:::BBTriggerV0C",32)) return kFALSE;
+  UInt_t test = 1;
+  return ( fBBtriggerV0C & (test << i) ? kTRUE : kFALSE );
+}
+
+Bool_t AliESDVZERO::BGTriggerV0C(Int_t i)
+{
+  if (OutOfRange(i, "AliESDVZERO:::BGTriggerV0C",32)) return kFALSE;
+  UInt_t test = 1;
+  return ( fBGtriggerV0C & (test << i) ? kTRUE : kFALSE );
+}
+
+Bool_t AliESDVZERO::OutOfRange(Int_t i, const char *s, Int_t upper) const
+{
+  // checks if i is a valid index. s = name of calling method
+  if (i > upper || i < 0) {
+    cout << s << " Index " << i << " out of range" << endl;
+    return kTRUE;
+  }
+  return kFALSE;
+}
 
index 932ccf3..0cae17c 100644 (file)
@@ -8,43 +8,48 @@ class AliESDVZERO : public TObject
 public:
   AliESDVZERO();
   AliESDVZERO(const AliESDVZERO&);
-  AliESDVZERO(Int_t NbPMV0A, Int_t NbPMV0C, Int_t MTotV0A, Int_t MTotV0C, 
-              Int_t *MRingV0A, Int_t *MRingV0C);
-  virtual ~AliESDVZERO() {};
-  AliESDVZERO &operator=(const AliESDVZERO& source);
-  virtual void Copy(TObject &obj) const;
+  AliESDVZERO(UInt_t BBtriggerV0A, UInt_t BGtriggerV0A,
+             UInt_t BBtriggerV0C, UInt_t BGtriggerV0C,
+             Short_t *Multiplicity);
 
+  virtual ~AliESDVZERO() {};
   
-// Setters
-  virtual void  SetNbPMV0A(Int_t NbPMV0A)  {fNbPMV0A = NbPMV0A;}
-  virtual void  SetNbPMV0C(Int_t NbPMV0C)  {fNbPMV0C = NbPMV0C;}
-  virtual void  SetMTotV0A(Int_t MTotV0A)  {fMTotV0A = MTotV0A;}
-  virtual void  SetMTotV0C(Int_t MTotV0C)  {fMTotV0C = MTotV0C;}                                             
-  virtual void  SetMRingV0A(Int_t MRingV0A[4]){for(Int_t j=0; j<4; j++){  
-                                                fMRingV0A[j] = MRingV0A[j];} }
-  virtual void  SetMRingV0C(Int_t MRingV0C[4]){for(Int_t j=0; j<4; j++){  
-                                                fMRingV0C[j] = MRingV0C[j];} }
-  
-// Getters  
-  Short_t GetNbPMV0A()  const {return fNbPMV0A;}
-  Short_t GetNbPMV0C()  const {return fNbPMV0C;}
-  Int_t GetMTotV0A()  const {return fMTotV0A;}
-  Int_t GetMTotV0C()  const {return fMTotV0C;}
-  Int_t* GetMRingV0A() const {return (int*) fMRingV0A;}
-  Int_t* GetMRingV0C() const {return (int*) fMRingV0C;}
+  virtual void SetBBtriggerV0A(UInt_t BBtrigger) {fBBtriggerV0A=BBtrigger;}
+  virtual void SetBGtriggerV0A(UInt_t BGtrigger) {fBGtriggerV0A=BGtrigger;}
+  virtual void SetBBtriggerV0C(UInt_t BBtrigger) {fBBtriggerV0C=BBtrigger;}
+  virtual void SetBGtriggerV0C(UInt_t BGtrigger) {fBGtriggerV0C=BGtrigger;}
+  virtual void SetMultiplicity(Short_t Multiplicity[64])
+    {for(Int_t i=0;i<64;i++) fMultiplicity[i]=Multiplicity[i];}
 
-  
+  // Getters  
+  Short_t GetNbPMV0A();
+  Short_t GetNbPMV0C();
+  Int_t   GetMTotV0A();
+  Int_t   GetMTotV0C(); 
+  Int_t*  GetMRingV0A();
+  Int_t*  GetMRingV0C();
+  Int_t   GetMRingV0A(Int_t ring);
+  Int_t   GetMRingV0C(Int_t ring);
+
+  Int_t   GetMultiplicity(Int_t i);
+  Bool_t  BBTriggerV0A(Int_t i);
+  Bool_t  BGTriggerV0A(Int_t i);
+  Bool_t  BBTriggerV0C(Int_t i);
+  Bool_t  BGTriggerV0C(Int_t i);
+
+  Bool_t  OutOfRange(Int_t i, const char *s, Int_t upper) const;
+  AliESDVZERO &operator=(const AliESDVZERO& source);
     
 protected:
-  Int_t fMTotV0A;     // Total multiplicity in V0A
-  Int_t fMTotV0C;     // Total multiplicity in V0C
-  Int_t fMRingV0A[4]; // Multiplicity per ring in V0A - 4 rings
-  Int_t fMRingV0C[4]; // Multiplicity per ring in V0C - 4 rings
-  Short_t fNbPMV0A;     // Number of PMs fired in V0A - out of 32
-  Short_t fNbPMV0C;     // Number of PMs fired in V0C - out of 32
 
+  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
+
+  UShort_t fMultiplicity[64]; // multiplicity per PMT
 
-  ClassDef(AliESDVZERO,2)
+  ClassDef(AliESDVZERO,3)
 };
 
 #endif
index 5b4067f..f5b98dc 100644 (file)
@@ -76,7 +76,7 @@ void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArr
 //____________________________________________________________________________ 
 void AliVZEROQADataMakerRec::InitESDs()
 {
-  //Create histograms to controll ESD
+  //Create histograms to control ESD
  
   TH1I * h1 = new TH1I("hVZERONbPMA", "Number of PMs fired in V0A", 80, 0, 79); 
   h1->Sumw2() ;
@@ -93,6 +93,25 @@ void AliVZEROQADataMakerRec::InitESDs()
   TH1I * h4 = new TH1I("hVZEROMultC", "Multiplicity in V0C", 50, 0, 49) ; 
   h4->Sumw2() ;
   Add2ESDsList(h4, 3) ;
+
+  TH2F * h5 = new TH2F("fVzeroMult", "Vzero multiplicity",
+                        64, -0.5, 63.5,100, -0.5, 99.5);
+  h5->GetXaxis()->SetTitle("Vzero PMT");
+  h5->GetYaxis()->SetTitle("Multiplicity");
+  h5->Sumw2() ;
+  Add2ESDsList(h5, 4) ;
+  TH1F * h6 = new TH1F("fBBA","BB Vzero A", 32, -0.5,31.5);
+  h6->Sumw2();
+  Add2ESDsList(h6, 5) ;
+  TH1F * h7 = new TH1F("fBGA","BG Vzero A", 32, -0.5,31.5);
+  h7->Sumw2();
+  Add2ESDsList(h7, 6) ;
+  TH1F * h8 = new TH1F("fBBC","BB Vzero C", 32, -0.5,31.5);
+  h8->Sumw2();
+  Add2ESDsList(h8, 7) ;
+  TH1F * h9 = new TH1F("fBGC","BG Vzero C", 32, -0.5,31.5);
+  h9->Sumw2();
+  Add2ESDsList(h9, 8) ;
        
 }
 
@@ -128,6 +147,7 @@ void AliVZEROQADataMakerRec::InitESDs()
      }  
  }
 
+
 //____________________________________________________________________________
 void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 {
@@ -140,6 +160,18 @@ void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
       GetESDsData(1)->Fill(esdVZERO->GetNbPMV0C());  
       GetESDsData(2)->Fill(esdVZERO->GetMTotV0A());
       GetESDsData(3)->Fill(esdVZERO->GetMTotV0C());  
+      for(Int_t i=0;i<64;i++) 
+       GetESDsData(4)->Fill((Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i));
+      for(Int_t i=0;i<32;i++) { 
+       if (esdVZERO->BBTriggerV0A(i)) 
+         GetESDsData(5)->Fill((Float_t) i);
+       if (esdVZERO->BGTriggerV0A(i)) 
+         GetESDsData(6)->Fill((Float_t) i);
+       if (esdVZERO->BBTriggerV0C(i)) 
+         GetESDsData(7)->Fill((Float_t) i);
+       if (esdVZERO->BGTriggerV0C(i)) 
+         GetESDsData(8)->Fill((Float_t) i);
+      }
   }
 
 }
index d0d22b8..9643f8b 100644 (file)
@@ -26,6 +26,7 @@
 #include "AliVZEROReconstructor.h"
 #include "AliVZERORawStream.h"
 #include "AliESDEvent.h"
+#include "AliVZEROTriggerMask.h"
 
 ClassImp(AliVZEROReconstructor)
 
@@ -73,13 +74,6 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
 {
 // converts to digits
 
-//  retrieval of calibration information 
-//  Float_t     adc_pedestal[128],adc_sigma[128];
-//  for(Int_t  i=0; i<128; i++){ adc_pedestal[i] = fCalibData->GetPedestal(i); 
-//                               adc_sigma[i]    = fCalibData->GetSigma(i);                            
-//                               printf(" i = %d pedestal = %f sigma = %f \n\n", 
-//                                        i, adc_pedestal[i], adc_sigma[i] );} 
-              
   if (!digitsTree) {
     AliError("No digits tree!");
     return;
@@ -92,14 +86,10 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
   AliVZERORawStream rawStream(rawReader);
   if (rawStream.Next()) {
     for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
-        Int_t adc;
-        if(!rawStream.GetIntegratorFlag(iChannel,10))
-           {adc = rawStream.GetADC(iChannel) - Int_t(fCalibData->GetPedestal(iChannel));} //even integrator
-       else 
-          {adc = rawStream.GetADC(iChannel) - Int_t(fCalibData->GetPedestal(iChannel+64));} // odd
-        Int_t time = rawStream.GetTime(iChannel);
-        if (adc >=0) new ((*digitsArray)[digitsArray->GetEntriesFast()])
-                     AliVZEROdigit(iChannel,adc,time);
+    Int_t adc = rawStream.GetADC(iChannel);  
+    Int_t time = rawStream.GetTime(iChannel);
+    new ((*digitsArray)[digitsArray->GetEntriesFast()])
+      AliVZEROdigit(iChannel,adc,time);
     }
   }
 
@@ -116,34 +106,23 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
     AliError("No digits tree!");
     return;
   }
-  
+
   TClonesArray* digitsArray = NULL;
   TBranch* digitBranch = digitsTree->GetBranch("VZERODigit");
   digitBranch->SetAddress(&digitsArray);
 
-  Int_t   nbPMV0A = 0;
-  Int_t   nbPMV0C = 0;
-  Int_t   mTotV0A = 0;
-  Int_t   mTotV0C = 0;
-  Float_t adcV0A  = 0.0;
-  Float_t adcV0C  = 0.0;
-  Float_t multV0A[4];
-  Float_t multV0C[4];
-  Int_t   mRingV0A[4];
-  Int_t   mRingV0C[4];
-  
+  const Float_t mip0=110.0;
+  Short_t Multiplicity[64];
+  Float_t mult[64];  
   Int_t   adc[64]; 
   Float_t mip[64];
   for (Int_t i=0; i<64; i++){
        adc[i] = 0;
-       mip[i] = 110.0;}
-  for (Int_t j=0; j<4; j++){
-       multV0A[j]  = 0.0;
-       multV0C[j]  = 0.0;
-       mRingV0A[j] = 0;
-       mRingV0C[j] = 0;}
+       mip[i] = mip0;
+       mult[i]= 0.0;
+  }
      
-  // loop over VZERO entries
+  // loop over VZERO entries to get multiplicity
   Int_t nEntries = (Int_t)digitsTree->GetEntries();
   for (Int_t e=0; e<nEntries; e++) {
     digitsTree->GetEvent(e);
@@ -155,47 +134,32 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
       Int_t  pmNumber      = digit->PMNumber();  
       adc[pmNumber] = digit->ADC(); 
       // cut of ADC at MIP/2
-      if  (adc[pmNumber] > (mip[pmNumber]/2)) { 
-        if (pmNumber<=31) {
-          if (pmNumber<=7) multV0C[0]=multV0C[0]+ float(adc[pmNumber])/mip[pmNumber];
-         if (pmNumber>=8  && pmNumber<=15) multV0C[1]=multV0C[1]+ float(adc[pmNumber])/mip[pmNumber];
-         if (pmNumber>=16 && pmNumber<=23) multV0C[2]=multV0C[2]+ float(adc[pmNumber])/mip[pmNumber];
-         if (pmNumber>=24 && pmNumber<=31) multV0C[3]=multV0C[3]+ float(adc[pmNumber])/mip[pmNumber];
-          adcV0C = adcV0C + float(adc[pmNumber])/mip[pmNumber];
-         nbPMV0C++;
-        }      
-        if (pmNumber>=32 ) {
-          if (pmNumber>=32 && pmNumber<=39) multV0A[0]=multV0A[0]+ float(adc[pmNumber])/mip[pmNumber];
-         if (pmNumber>=40 && pmNumber<=47) multV0A[1]=multV0A[1]+ float(adc[pmNumber])/mip[pmNumber];
-         if (pmNumber>=48 && pmNumber<=55) multV0A[2]=multV0A[2]+ float(adc[pmNumber])/mip[pmNumber];
-         if (pmNumber>=56 && pmNumber<=63) multV0A[3]=multV0A[3]+ float(adc[pmNumber])/mip[pmNumber];
-          adcV0A = adcV0A + float(adc[pmNumber])/mip[pmNumber];
-         nbPMV0A++;
-        }
-      }
+      if  (adc[pmNumber] > (mip[pmNumber]/2)) 
+       mult[pmNumber] += float(adc[pmNumber])/mip[pmNumber];
     } // end of loop over digits
-    
   } // end of loop over events in digits tree
   
-  mTotV0A = int(adcV0A + 0.5);
-  mTotV0C = int(adcV0C + 0.5);
-  for (Int_t j=0; j<4; j++){       
-       mRingV0A[j] = int(multV0A[j] + 0.5);
-       mRingV0C[j] = int(multV0C[j] + 0.5);}
-     
-  AliDebug(1,Form("VZERO multiplicities : %d (V0A) %d (V0C)", mTotV0A, mTotV0C));
-  AliDebug(1,Form("Number of PMs fired  : %d (V0A) %d (V0C)", nbPMV0A, nbPMV0C));
-
-  fESDVZERO->SetNbPMV0A(nbPMV0A);
-  fESDVZERO->SetNbPMV0C(nbPMV0C);
-  fESDVZERO->SetMTotV0A(mTotV0A);
-  fESDVZERO->SetMTotV0C(mTotV0C);
-  fESDVZERO->SetMRingV0A(mRingV0A);
-  fESDVZERO->SetMRingV0C(mRingV0C);
+  for (Int_t j=0; j<64; j++) Multiplicity[j] = short(mult[j]+0.5);       
+  fESDVZERO->SetMultiplicity(Multiplicity);
+
+  // now get the trigger mask
+
+  AliVZEROTriggerMask *TriggerMask = new AliVZEROTriggerMask();
+  TriggerMask->SetAdcThreshold(mip0/2.0);
+  TriggerMask->SetTimeWindowWidthBBA(50);
+  TriggerMask->SetTimeWindowWidthBGA(20);
+  TriggerMask->SetTimeWindowWidthBBC(50);
+  TriggerMask->SetTimeWindowWidthBGC(20);
+  TriggerMask->FillMasks(digitsTree,digitsArray);
+
+  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);
+    AliDebug(1, Form("Writing VZERO data to ESD tree"));
+    esd->SetVZEROData(fESDVZERO);
   }
 }
 
index 98c4e38..293d9ba 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliRunLoader.h"
 
 #include "AliVZEROTrigger.h"
+#include "AliVZEROTriggerMask.h"
 
 //______________________________________________________________________
 ClassImp(AliVZEROTrigger)
@@ -33,19 +34,21 @@ ClassImp(AliVZEROTrigger)
 ////////////////////////////////////////////////////////////////////////
 
 //______________________________________________________________________
+
 AliVZEROTrigger::AliVZEROTrigger()
   :AliTriggerDetector(),
    fAdcThresHold(0.0),
-   fTimeWindowWidth(50.0)
+   fTimeWindowWidthBBA(50.0),
+   fTimeWindowWidthBGA(20.0),
+   fTimeWindowWidthBBC(50.0),
+   fTimeWindowWidthBGC(20.0)
    
 {
    SetName("VZERO");
    CreateInputs();
 
    SetAdcThreshold();
-   SetTimeWindowWidth();
 }
-
 //______________________________________________________________________
 void AliVZEROTrigger::CreateInputs()
 {
@@ -58,7 +61,6 @@ void AliVZEROTrigger::CreateInputs()
    fInputs.AddLast( new AliTriggerInput( "VZERO_RIGHT","VZERO", 0 ) );
    fInputs.AddLast( new AliTriggerInput( "VZERO_AND",  "VZERO", 0 ) );
    fInputs.AddLast( new AliTriggerInput( "VZERO_OR",   "VZERO", 0 ) );
-
    fInputs.AddLast( new AliTriggerInput( "VZERO_BEAMGAS", "VZERO", 0 ) );
 }
 
@@ -69,7 +71,8 @@ void AliVZEROTrigger::Trigger()
   //  ********** Get run loader for the current event **********
   AliRunLoader* runLoader = gAlice->GetRunLoader();
 
-  AliVZEROLoader* loader = (AliVZEROLoader* )runLoader->GetLoader( "VZEROLoader" );
+  AliVZEROLoader* loader = 
+    (AliVZEROLoader* )runLoader->GetLoader( "VZEROLoader" );
 
   loader->LoadDigits("READ");
   TTree* vzeroDigitsTree = loader->TreeD();
@@ -79,68 +82,23 @@ void AliVZEROTrigger::Trigger()
   TBranch* digitBranch = vzeroDigitsTree->GetBranch("VZERODigit");
   digitBranch->SetAddress(&vzeroDigits);
 
-  // number of hits in left/right
-  Int_t nLeftDig  = 0;
-  Int_t nRightDig = 0;
-  
-  // first time 
-  Float_t firstTimeLeft  = 9999.0;
-  Float_t firstTimeRight = 9999.0;
-  Float_t TimeHalfWidth  = fTimeWindowWidth/2.0;
-  // 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(); // in 100 of picoseconds
-      
-      if (PMNumber<=31 && adc>fAdcThresHold) {
-       if (tdc>(29.0-TimeHalfWidth) && tdc<(29.0+TimeHalfWidth)) nRightDig++;
-       if (tdc<firstTimeRight) firstTimeRight = tdc;
-      }      
-      if (PMNumber>=32 && adc>fAdcThresHold) {
-       if (tdc>(112.0-TimeHalfWidth) && tdc<(112.0+TimeHalfWidth)) nLeftDig++;
-       if (tdc<firstTimeLeft) firstTimeLeft = tdc;
-      }        
-      
-    } // end of loop over digits
-  } // end of loop over events in digits tree
-  
-  // Beam gas trigger set from the time difference. The time it takes
-  // to travel between the two counters is ~14.3 ns = 143 * 100 ps.
-  //  NB: this should be defined
-  // from time windows relative to the time of the bunch crossing!
-  // beam gas comming from the left ...
-
-  if (TMath::Abs(TMath::Abs(firstTimeLeft - firstTimeRight)-143) < 20) // time window of 2 ns
-    SetInput( "VZERO_BEAMGAS" );
+  AliVZEROTriggerMask *TriggerMask = new AliVZEROTriggerMask();
+  TriggerMask->SetAdcThreshold(fAdcThresHold);
+  TriggerMask->SetTimeWindowWidthBBA(fTimeWindowWidthBBA);
+  TriggerMask->SetTimeWindowWidthBGA(fTimeWindowWidthBGA);
+  TriggerMask->SetTimeWindowWidthBBC(fTimeWindowWidthBBC);
+  TriggerMask->SetTimeWindowWidthBGC(fTimeWindowWidthBGC);
+  TriggerMask->FillMasks(vzeroDigitsTree,vzeroDigits);
+
+  if ( (TriggerMask->GetBGtriggerV0A()>0) ||
+       (TriggerMask->GetBGtriggerV0C()>0)) SetInput( "VZERO_BEAMGAS" );
+  if (TriggerMask->GetBBtriggerV0A()>0)  SetInput( "VZERO_LEFT" );
+  if (TriggerMask->GetBBtriggerV0C()>0)  SetInput( "VZERO_RIGHT" );
+  if ( (TriggerMask->GetBBtriggerV0A()>0) ||
+       (TriggerMask->GetBBtriggerV0C()>0)) SetInput( "VZERO_OR" );
+  if ( (TriggerMask->GetBBtriggerV0A()>0) &&
+       (TriggerMask->GetBBtriggerV0C()>0)) SetInput( "VZERO_AND" );
 
-  if (nLeftDig > 0)
-      SetInput( "VZERO_LEFT" );
-
-  if (nRightDig > 0)
-      SetInput( "VZERO_RIGHT" );
-  
-  if (nLeftDig>0 || nRightDig>0) {
-      SetInput( "VZERO_OR" );
-
-    if (nLeftDig>0 && nRightDig>0) {
-        SetInput( "VZERO_AND" );   
-    }
-  }
-  
-  AliDebug(1,Form("VZERO PMs fired: %d (left) %d (right)", nLeftDig, nRightDig));
   return;
 }
 
-
index b090719..f3e4bd4 100644 (file)
@@ -25,15 +25,28 @@ class AliVZEROTrigger : public AliTriggerDetector
    virtual void    Trigger();
 
    void            SetAdcThreshold(Float_t t=55.0) 
-     {fAdcThresHold=t; AliDebug(1,Form("ADC threshold set to %0.2f", fAdcThresHold));}
+     {fAdcThresHold=t; 
+     AliDebug(1,Form("ADC threshold set to %0.2f", fAdcThresHold));}
    
-   void            SetTimeWindowWidth(Float_t w=50.0) {fTimeWindowWidth=w;}
-
+   void            SetTimeWindowWidth(Float_t w=50.0) 
+     {fTimeWindowWidthBBA=fTimeWindowWidthBGA
+       =fTimeWindowWidthBBC=fTimeWindowWidthBGC=w;}
+   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;}
 
 private:
 
    Float_t fAdcThresHold;
-   Float_t fTimeWindowWidth; // 
+   Float_t fTimeWindowWidthBBA; // 
+   Float_t fTimeWindowWidthBGA; // 
+   Float_t fTimeWindowWidthBBC; // 
+   Float_t fTimeWindowWidthBGC; // 
 
    ClassDef( AliVZEROTrigger, 1 )  // VZERO Trigger Detector class
 };
diff --git a/VZERO/AliVZEROTriggerMask.cxx b/VZERO/AliVZEROTriggerMask.cxx
new file mode 100644 (file)
index 0000000..578552c
--- /dev/null
@@ -0,0 +1,129 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+#include <Riostream.h>
+#include <TGeoManager.h>
+#include <TGeoMatrix.h>
+#include <TGeoPhysicalNode.h>
+#include <AliGeomManager.h>
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliCDBEntry.h"
+#include "AliLog.h"
+#include "AliVZEROTriggerMask.h"
+#include "AliVZEROdigit.h"
+
+//______________________________________________________________________
+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)
+   
+{
+   SetAdcThreshold();
+}
+
+//________________________________________________________________________________
+Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
+// Get the global z coordinate of the given V0 alignable volume
+//
+  Double_t *tr;
+  TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
+  if (!pne) return 0;
+
+
+  TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
+  if(pnode){
+          TGeoHMatrix* hm = pnode->GetMatrix();
+           tr = hm->GetTranslation();
+  }else{
+          const char* path = pne->GetTitle();
+          if(!gGeoManager->cd(path)){
+                  AliErrorClass(Form("Volume path %s not valid!",path));
+                  return 0;
+          }
+         tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
+  }
+  return tr[2];
+
+}
+
+//________________________________________________________________________________
+
+
+void AliVZEROTriggerMask::FillMasks(TTree* vzeroDigitsTree,
+                               TClonesArray* vzeroDigits)
+{
+  const Double_t LightSpeed = 2.9979245800; // cm/100 ps
+  Float_t Z_V0A = TMath::Abs(GetZPosition("VZERO/V0A"));
+  Float_t Z_V0C = TMath::Abs(GetZPosition("VZERO/V0C"));
+
+  // distance in time units from nominal vertex to V0
+  Float_t v0a_dist = Z_V0A/LightSpeed; // 100 of picoseconds
+  Float_t v0c_dist = Z_V0C/LightSpeed; // 100 of picoseconds
+  Float_t bunch_separation = 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(); // in 100 of picoseconds
+
+      if (adc>fAdcThresHold) {
+       if (PMNumber<32) { // in V0C
+         if (tdc>(v0c_dist-fTimeWindowWidthBBC/2.0) &&
+             tdc<(v0c_dist+fTimeWindowWidthBBC/2.0))
+           fBBtriggerV0C+=(one<<PMNumber);
+         if (tdc>(bunch_separation-v0c_dist-fTimeWindowWidthBGC/2.0) &&
+             tdc<(bunch_separation-v0c_dist+fTimeWindowWidthBGC/2.0))
+          fBGtriggerV0C+=(one<<PMNumber); 
+       }
+       if (PMNumber>31) { // in V0A
+         Int_t shift = PMNumber-32;
+         if (tdc>(v0a_dist-fTimeWindowWidthBBA/2.0) &&
+             tdc<(v0a_dist+fTimeWindowWidthBBA/2.0)) 
+           fBBtriggerV0A+=(one<<shift);
+         if (tdc>(bunch_separation-v0a_dist-fTimeWindowWidthBGA/2.0) &&
+             tdc<(bunch_separation-v0a_dist+fTimeWindowWidthBGA/2.0))
+           fBGtriggerV0A+=(one<<shift); 
+       }
+      }
+    } // end of loop over digits
+  } // end of loop over events in digits tree
+}
diff --git a/VZERO/AliVZEROTriggerMask.h b/VZERO/AliVZEROTriggerMask.h
new file mode 100644 (file)
index 0000000..05e79ad
--- /dev/null
@@ -0,0 +1,55 @@
+#ifndef ALIVZEROTriggerMask_H
+#define ALIVZEROTriggerMask_H
+
+///_________________________________________________________________________
+///
+///  Auxiliary classs to compute the  VZERO Trigger
+///_________________________________________________________________________   
+
+#include <TObject.h>
+#include <TTree.h>
+#include <TClonesArray.h>
+
+class AliVZEROTriggerMask : public TObject
+{
+ public:
+                   AliVZEROTriggerMask();   // constructor
+   virtual        ~AliVZEROTriggerMask(){}  // destructor
+
+   void FillMasks(TTree* vzeroDigitsTree,
+                 TClonesArray* vzeroDigits);
+   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() { return fBBtriggerV0A;}
+   UInt_t GetBGtriggerV0A() { return fBGtriggerV0A;}
+   UInt_t GetBBtriggerV0C() { return fBBtriggerV0C;}
+   UInt_t GetBGtriggerV0C() { return fBGtriggerV0C;}
+
+private:
+
+   Float_t fAdcThresHold;
+   Float_t fTimeWindowWidthBBA; // 
+   Float_t fTimeWindowWidthBGA; // 
+   Float_t fTimeWindowWidthBBC; // 
+   Float_t fTimeWindowWidthBGC; // 
+   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
+};
+
+#endif // AliVZEROTriggerMask_H
index 5b58506..e7bc438 100755 (executable)
@@ -17,6 +17,7 @@
 #pragma link C++ class  AliVZERODigitizer+;
 #pragma link C++ class  AliVZEROBuffer+;
 #pragma link C++ class  AliVZEROTrigger+;
+#pragma link C++ class  AliVZEROTriggerMask+;
 #pragma link C++ class  AliVZEROQADataMakerSim+;
 
 #endif
index 81bec28..85feef0 100644 (file)
@@ -13,6 +13,7 @@ AliVZEROhit.cxx \
 AliVZERODigitizer.cxx \
 AliVZEROBuffer.cxx \
 AliVZEROTrigger.cxx \
+AliVZEROTriggerMask.cxx \
 AliVZEROQADataMakerSim.cxx
 
 HDRS:= $(SRCS:.cxx=.h)