Correct handling of main trigger for multiple trigger classes

==================================================================
1) Modify trigger maker in the way that one can select which type to process (by default all on)
2) Move main trigger patch variable in AliAnalysisTaskEmcal from Pointer to Array (with size of trigger classes)
3) Add argument to the function GetMainTriggerPatch, which is a bitmap, out of which trigger classes to select the main trigger patch
4) If more than 1 trigger class is selected, we choose the highest according to the ADC
5) Consequently enum TriggerType moves from Integer to bits, and the existing part of the code is adapted

diff --git a/PWG/EMCAL/AliAnalysisTaskEmcal.cxx b/PWG/EMCAL/AliAnalysisTaskEmcal.cxx
index b7abab1265e3945bcb8b533d116b0d0a3440b3ba..8b29cd11810f6a3907747b4e9bb2cfdae8da1362 100644 (file)
--- a/PWG/EMCAL/AliAnalysisTaskEmcal.cxx
+++ b/PWG/EMCAL/AliAnalysisTaskEmcal.cxx
@@ -47,6 +47,7 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() :
   fGeneralHistograms(kFALSE),
   fInitialized(kFALSE),
   fCreateHisto(kTRUE),
+  fMainTriggerPatchSet(kFALSE),
   fCaloCellsName(),
   fCaloTriggersName(),
   fCaloTriggerPatchInfoName(),
@@ -99,7 +100,6 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() :
   fXsection(0),
   fParticleCollArray(),
   fClusterCollArray(),
-  fMainTriggerPatch(0x0),
   fTriggers(0),
   fOutput(0),
   fHistEventCount(0),
@@ -123,6 +123,7 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() :
 
   fParticleCollArray.SetOwner(kTRUE);
   fClusterCollArray.SetOwner(kTRUE);
+  memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * kNType);
 }
 
 //________________________________________________________________________
@@ -132,6 +133,7 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) :
   fGeneralHistograms(kFALSE),
   fInitialized(kFALSE),
   fCreateHisto(histo),
+  fMainTriggerPatchSet(kFALSE),
   fCaloCellsName(),
   fCaloTriggersName(),
   fCaloTriggerPatchInfoName(),
@@ -184,7 +186,6 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) :
   fXsection(0),
   fParticleCollArray(),
   fClusterCollArray(),
-  fMainTriggerPatch(0x0),
   fTriggers(0),
   fOutput(0),
   fHistEventCount(0),
@@ -208,6 +209,7 @@ AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) :
 
   fParticleCollArray.SetOwner(kTRUE);
   fClusterCollArray.SetOwner(kTRUE);
+  memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * kNType);
 
   if (fCreateHisto) {
     DefineOutput(1, TList::Class()); 
@@ -411,7 +413,7 @@ void AliAnalysisTaskEmcal::UserExec(Option_t *)
 {
   // Main loop, called for each event.
 
-  fMainTriggerPatch = NULL;
+  memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * kNType);
 
   if (!fInitialized)
     ExecOnce();
@@ -754,24 +756,24 @@ ULong_t AliAnalysisTaskEmcal::GetTriggerList()
 
   ULong_t triggers(0);
   if (nG1>0)
-    SETBIT(triggers, kG1);
+    triggers |= kG1;
   if (nG2>0)
-    SETBIT(triggers, kG2);
+    triggers |= kG2;
   if (nJ1>0)
-    SETBIT(triggers, kJ1);
+    triggers |= kJ1;
   if (nJ2>0)
-    SETBIT(triggers, kJ2);
+    triggers |= kJ2;
   return triggers;
 }
 
 //________________________________________________________________________
-Bool_t AliAnalysisTaskEmcal::HasTriggerType(TriggerType t)
+Bool_t AliAnalysisTaskEmcal::HasTriggerType(Int_t trigger)
 {
   // Check if event has a given trigger type
-  if(t == kND){
+  if(trigger & kND){
     return fTriggers == 0;
   }
-  return TESTBIT(fTriggers, int(t));
+  return (fTriggers & trigger);
 }
 
 //________________________________________________________________________
@@ -833,7 +835,7 @@ Bool_t AliAnalysisTaskEmcal::IsEventSelected()
     }
   }
 
-  if (fTriggerTypeSel != kND) {
+  if (!(fTriggerTypeSel & kND)) {
     if (!HasTriggerType(fTriggerTypeSel)) {
       if (fGeneralHistograms) fHistEventRejection->Fill("trigTypeSel",1);
       return kFALSE;
@@ -1069,6 +1071,8 @@ Bool_t AliAnalysisTaskEmcal::RetrieveEventObjects()
   }
 
   fTriggers = GetTriggerList();
+  fMainTriggerPatchSet = kFALSE;
+  memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * (kNType - 1));
 
   return kTRUE;
 }
@@ -1234,12 +1238,18 @@ Int_t AliAnalysisTaskEmcal::GetNClusters(Int_t i) const
 }
 
 //________________________________________________________________________
-AliEmcalTriggerPatchInfo* AliAnalysisTaskEmcal::GetMainTriggerPatch() 
+AliEmcalTriggerPatchInfo* AliAnalysisTaskEmcal::GetMainTriggerPatch(Int_t types)
 {
   //get main trigger match; if not known yet, look for it and cache
+  //
+  // In order to be able to select more than one class at the same time (i.e. low and
+  // high threshold trigger), the argument must be a bit string, however using the enum
+  // of trigger classes in order to define the selection
 
-  if (fMainTriggerPatch) 
-    return fMainTriggerPatch;
+  // Get from cache (if already set)
+  if(fMainTriggerPatchSet){
+    return ApplyMainTriggerSelection(types);
+  }
 
   if (!fTriggerPatchInfo) {
     AliError(Form("%s: fTriggerPatchInfo not available",GetName()));
@@ -1249,18 +1259,67 @@ AliEmcalTriggerPatchInfo* AliAnalysisTaskEmcal::GetMainTriggerPatch()
   //number of patches in event
   Int_t nPatch = fTriggerPatchInfo->GetEntries();
 
-  //extract main trigger patch
+  //extract main trigger patch(es)
   AliEmcalTriggerPatchInfo *patch;
   for (Int_t iPatch = 0; iPatch < nPatch; iPatch++) {
-    
+
     patch = (AliEmcalTriggerPatchInfo*)fTriggerPatchInfo->At( iPatch );
     if (patch->IsMainTrigger()) {
-      fMainTriggerPatch = patch;
-      break;
+      if(patch->IsJetHigh()) fMainTriggerPatch[kPosJ1] = patch;
+      if(patch->IsJetLow()) fMainTriggerPatch[kPosJ2] = patch;
+      if(patch->IsGammaHigh()) fMainTriggerPatch[kPosG1] = patch;
+      if(patch->IsGammaLow()) fMainTriggerPatch[kPosG2] = patch;
+      if(patch->IsLevel0()) fMainTriggerPatch[kPosL0] = patch;
+    }
+  }
+  fMainTriggerPatchSet = kTRUE;
+
+  return ApplyMainTriggerSelection(types);
+}
+
+AliEmcalTriggerPatchInfo *AliAnalysisTaskEmcal::ApplyMainTriggerSelection(Int_t selectionBitmap) const {
+  //
+  // Select main trigger patch for a given combination of trigger classes
+  // If the bitmap contains only one class, the selection is trivial
+  // If the bitmap contains many classes, the selection takes the highest of the patchess according to the
+  // ADC Amplitude
+  //
+  AliEmcalTriggerPatchInfo *highest(NULL);
+  if(selectionBitmap & kJ1){
+    highest = fMainTriggerPatch[kPosJ1];
+  }
+  if(selectionBitmap & kJ2){
+    if(!highest) highest = fMainTriggerPatch[kPosJ2];
+    else{
+      if(fMainTriggerPatch[kPosJ2] && fMainTriggerPatch[kPosJ2]->GetADCAmp() > highest->GetADCAmp())
+        highest = fMainTriggerPatch[kPosJ2];
+    }
+  }
+
+  if(selectionBitmap & kG1){
+    if(!highest) highest = fMainTriggerPatch[kPosG1];
+    else{
+      if(fMainTriggerPatch[kPosG1] && fMainTriggerPatch[kPosG1]->GetADCAmp() > highest->GetADCAmp())
+        highest = fMainTriggerPatch[kPosG1];
+    }
+  }
+
+  if(selectionBitmap & kG2){
+    if(!highest) highest = fMainTriggerPatch[kPosG2];
+    else{
+      if(fMainTriggerPatch[kPosG2] && fMainTriggerPatch[kPosG2]->GetADCAmp() > highest->GetADCAmp())
+        highest = fMainTriggerPatch[kPosG2];
+    }
+  }
+  if(selectionBitmap & kL0){
+    if(!highest) highest = fMainTriggerPatch[kPosL0];
+    else{
+      if(fMainTriggerPatch[kPosL0] && fMainTriggerPatch[kPosL0]->GetADCAmp() > highest->GetADCAmp())
+        highest = fMainTriggerPatch[kPosL0];
     }
   }
 
-  return fMainTriggerPatch;
+  return highest;
 }
 
 //________________________________________________________________________

diff --git a/PWG/EMCAL/AliAnalysisTaskEmcal.h b/PWG/EMCAL/AliAnalysisTaskEmcal.h
index 817396dd65f43242608c33ce2de4fcc755aee938..722abbe1905938e4c231ab263bd6de7920970107 100644 (file)
--- a/PWG/EMCAL/AliAnalysisTaskEmcal.h
+++ b/PWG/EMCAL/AliAnalysisTaskEmcal.h
@@ -37,12 +37,20 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   };
 
   enum TriggerType {
-    kND       = -1,  //not defined
-    kJ1       = 0,
-    kJ2       = 1,
-    kG1                  = 2,
-    kG2          = 3,
-    kNType    = 4
+    kND       = BIT(31),  //not defined := Sign bit of int
+    kJ1       = BIT(0),
+    kJ2       = BIT(1),
+    kG1                    = BIT(2),
+    kG2            = BIT(3),
+    kL0       = BIT(4)
+  };
+  enum MainTriggers{
+    kPosJ1    = 0,
+    kPosJ2    = 1,
+    kPosG1             = 2,
+    kPosG2       = 3,
+    kPosL0    = 4,
+    kNType    = 5
   };
 
   AliAnalysisTaskEmcal();
@@ -103,9 +111,10 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   TClonesArray               *GetClusterArray(Int_t i=0)                         const;
   Int_t                       GetNParticles(Int_t i=0)                           const;
   Int_t                       GetNClusters(Int_t i=0)                            const;
-  AliEmcalTriggerPatchInfo   *GetMainTriggerPatch();
-  Bool_t                                         HasTriggerType(TriggerType);
-  ULong_t                                        GetTriggerList();
+  AliEmcalTriggerPatchInfo   *GetMainTriggerPatch(Int_t triggersel = kJ1 | kJ2);
+  AliEmcalTriggerPatchInfo   *ApplyMainTriggerSelection(Int_t selectionBitmap) const;
+  Bool_t                                                   HasTriggerType(Int_t triggersel);
+  ULong_t                                                GetTriggerList();
   Bool_t                      PythiaInfoFromFile(const char* currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard);
   void                        UserCreateOutputObjects();
   void                        UserExec(Option_t *option);
@@ -123,6 +132,7 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   Bool_t                      fGeneralHistograms;          // whether or not it should fill some general histograms
   Bool_t                      fInitialized;                // whether or not the task has been already initialized
   Bool_t                      fCreateHisto;                // whether or not create histograms
+  Bool_t                      fMainTriggerPatchSet;        // Internal variable indicating whether the array of main trigger patches is initialised
   TString                     fCaloCellsName;              // name of calo cell collection
   TString                     fCaloTriggersName;           // name of calo triggers collection
   TString                     fCaloTriggerPatchInfoName;   // trigger patch info array name
@@ -138,7 +148,7 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   AliAnalysisUtils           *fAliAnalysisUtils;           //! vertex selection (optional)
   UInt_t                      fOffTrigger;                 // offline trigger for event selection
   TString                     fTrigClass;                  // trigger class name for event selection
-  TriggerType                 fTriggerTypeSel;             // trigger type to select based on trigger patches
+  Int_t                       fTriggerTypeSel;             // trigger type to select based on trigger patches
   Int_t                       fNbins;                      // no. of pt bins
   Double_t                    fMinBinPt;                   // min pt in histograms
   Double_t                    fMaxBinPt;                   // max pt in histograms
@@ -176,7 +186,7 @@ class AliAnalysisTaskEmcal : public AliAnalysisTaskSE {
   Float_t                     fXsection;                   //!x-section from pythia header
   TObjArray                   fParticleCollArray;          // particle/track collection array
   TObjArray                   fClusterCollArray;           // cluster collection array
-  AliEmcalTriggerPatchInfo   *fMainTriggerPatch;           // main trigger patch, will be cached after calling GetMainTriggerPatch() first time
+  AliEmcalTriggerPatchInfo   *fMainTriggerPatch[kNType];   // main trigger patch, will be cached after calling GetMainTriggerPatch() first time
   ULong_t                     fTriggers;                   // list of fired triggers
 
   TList                      *fOutput;                     //!output list

diff --git a/PWG/EMCAL/AliEmcalTriggerMaker.cxx b/PWG/EMCAL/AliEmcalTriggerMaker.cxx
index b3303c35f731ffff8a5124d285b1c0c695114977..e5207e70a0f1b5646f26cd90d114a2e2108db53f 100644 (file)
--- a/PWG/EMCAL/AliEmcalTriggerMaker.cxx
+++ b/PWG/EMCAL/AliEmcalTriggerMaker.cxx
@@ -39,6 +39,9 @@ AliEmcalTriggerMaker::AliEmcalTriggerMaker() :
   fQAHistos(NULL)
 {
   // Constructor.
+  fRunTriggerType[kTMEMCalJet] = kTRUE;
+  fRunTriggerType[kTMEMCalGamma] = kTRUE;
+  fRunTriggerType[kTMEMCalLevel0] = kTRUE;
   memset(fThresholdConstants, 0, sizeof(Int_t) * 12);
   memset(fPatchADCSimple, 0, sizeof(Int_t) * kPatchCols * kPatchRows);
   memset(fPatchADC, 0, sizeof(Int_t) * kPatchCols * kPatchRows);
@@ -268,39 +271,45 @@ Bool_t AliEmcalTriggerMaker::Run()
     Bool_t isOfflineSimple=0;
     while (NextTrigger(isOfflineSimple)) {
       // process jet
-      trigger = ProcessPatch(kTMEMCalJet, isOfflineSimple);
-      // save main jet triggers in event
-      if (trigger != 0) {
-        // check if more energetic than others for main patch marking
-        if (!isOfflineSimple) {
-          if (triggerMainJet == 0 || (triggerMainJet->GetPatchE() < trigger->GetPatchE()))
-            triggerMainJet = trigger;
-        } else {
-          if (triggerMainJetSimple == 0 || (triggerMainJetSimple->GetPatchE() < trigger->GetPatchE()))
-            triggerMainJetSimple = trigger;
+      if(fRunTriggerType[kTMEMCalJet]){
+        trigger = ProcessPatch(kTMEMCalJet, isOfflineSimple);
+        // save main jet triggers in event
+        if (trigger != 0) {
+          // check if more energetic than others for main patch marking
+          if (!isOfflineSimple) {
+            if (triggerMainJet == 0 || (triggerMainJet->GetPatchE() < trigger->GetPatchE()))
+              triggerMainJet = trigger;
+          } else {
+            if (triggerMainJetSimple == 0 || (triggerMainJetSimple->GetPatchE() < trigger->GetPatchE()))
+              triggerMainJetSimple = trigger;
+          }
         }
       }
       
       // process gamma
-      trigger = ProcessPatch(kTMEMCalGamma, isOfflineSimple);
-      // save main gamma triggers in event
-      if (trigger != 0) {
-        // check if more energetic than others for main patch marking
-        if (!isOfflineSimple) {
-          if (triggerMainGamma == 0 || (triggerMainGamma->GetPatchE() < trigger->GetPatchE()))
-            triggerMainGamma = trigger;
-        } else {
-          if (triggerMainGammaSimple == 0 || (triggerMainGammaSimple->GetPatchE() < trigger->GetPatchE()))
-            triggerMainGammaSimple = trigger;
+      if(fRunTriggerType[kTMEMCalGamma]){
+        trigger = ProcessPatch(kTMEMCalGamma, isOfflineSimple);
+        // save main gamma triggers in event
+        if (trigger != 0) {
+          // check if more energetic than others for main patch marking
+          if (!isOfflineSimple) {
+            if (triggerMainGamma == 0 || (triggerMainGamma->GetPatchE() < trigger->GetPatchE()))
+              triggerMainGamma = trigger;
+          } else {
+            if (triggerMainGammaSimple == 0 || (triggerMainGammaSimple->GetPatchE() < trigger->GetPatchE()))
+              triggerMainGammaSimple = trigger;
+          }
         }
       }
 
       // level 0 triggers
-      trigger = ProcessPatch(kTMEMCalLevel0, isOfflineSimple);
-      // save main level0 trigger in the event
-      if (trigger) {
-        if (!triggerMainLevel0 || (triggerMainLevel0->GetPatchE() < trigger->GetPatchE()))
-          triggerMainLevel0 = trigger;
+      if(fRunTriggerType[kTMEMCalLevel0]){
+        trigger = ProcessPatch(kTMEMCalLevel0, isOfflineSimple);
+        // save main level0 trigger in the event
+        if (trigger) {
+          if (!triggerMainLevel0 || (triggerMainLevel0->GetPatchE() < trigger->GetPatchE()))
+            triggerMainLevel0 = trigger;
+        }
       }
     } // triggers
     

diff --git a/PWG/EMCAL/AliEmcalTriggerMaker.h b/PWG/EMCAL/AliEmcalTriggerMaker.h
index 084d1e45d504e0fd443910d7b74b0bf09f374b4a..c0231d96c5402d196416f8b8fb4e266d28133a9b 100644 (file)
--- a/PWG/EMCAL/AliEmcalTriggerMaker.h
+++ b/PWG/EMCAL/AliEmcalTriggerMaker.h
@@ -32,6 +32,8 @@ class AliEmcalTriggerMaker : public AliAnalysisTaskEmcal {
   void SetTriggerThresholdGammaHigh( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[3][0] = a; fThresholdConstants[1][1] = b; fThresholdConstants[1][2] = c; }
   void SetV0InName(const char *name) { fV0InName      = name; }
 
+  void SetRunTriggerType(TriggerMakerTriggerType_t type, Bool_t doTrigger = kTRUE) { fRunTriggerType[type] = doTrigger; }
+
   Bool_t IsEJE(Int_t tBits) const { if( tBits & ( 1 << (kTriggerTypeEnd + kL1JetLow) | 1 << (kTriggerTypeEnd + kL1JetHigh) | 1 << (kL1JetLow) | 1 << (kL1JetHigh) )) return kTRUE; else return kFALSE; }
   Bool_t IsEGA(Int_t tBits) const { if( tBits & ( 1 << (kTriggerTypeEnd + kL1GammaLow) | 1 << (kTriggerTypeEnd + kL1GammaHigh) | 1 << (kL1GammaLow) | 1 << (kL1GammaHigh) )) return kTRUE; else return kFALSE; }
   Bool_t IsLevel0(Int_t tBits) const { if( tBits & (1 << (kTriggerTypeEnd + kL0) | (1 << kL0))) return kTRUE; return kFALSE; }
@@ -60,6 +62,7 @@ class AliEmcalTriggerMaker : public AliAnalysisTaskEmcal {
   Double_t                   fPatchADCSimple[kPatchCols][kPatchRows];   //!patch map for simple offline trigger
   Int_t                      fPatchADC[kPatchCols][kPatchRows];         //!ADC values map
   Int_t                      fITrigger;                 //!trigger counter
+  Bool_t                     fRunTriggerType[3];        // Run patch maker for a given trigger type
   Bool_t                     fDoQA;                     // Fill QA histograms
   THistManager              *fQAHistos;                 //! Histograms for QA