From Salvatore
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 31 Jul 2013 07:46:15 +0000 (07:46 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 31 Jul 2013 07:46:15 +0000 (07:46 +0000)
- AliAnalysisTaskSAJF: fix histogram binning and axis
- AliAnalysisTaskEmcalJetDev, AliAnalysisTaskEmcalDev: default container index parameter for the get functions
- AliAnalysisTaskEmcalJet: trigger jet filter
- AliEmcalJet: new non-streamed field to store bits containing trigger information
- AliJetTriggerSelectionTask: new task to find jet trigger candidates (loop over EMCal L1 patches over threshold and match with reconstructed jets)
- AliEMCALClusterizerFixedWindow: improve memory management (less new-delete calls)

13 files changed:
EMCAL/AliEMCALClusterizerFixedWindow.cxx
EMCAL/AliEMCALClusterizerFixedWindow.h
PWG/EMCAL/AliAnalysisTaskEmcalDev.cxx
PWG/EMCAL/AliAnalysisTaskEmcalDev.h
PWGJE/CMakelibPWGJEEMCALJetTasks.pkg
PWGJE/EMCALJetTasks/AliAnalysisTaskEmcalJet.cxx
PWGJE/EMCALJetTasks/AliAnalysisTaskEmcalJet.h
PWGJE/EMCALJetTasks/AliAnalysisTaskEmcalJetDev.h
PWGJE/EMCALJetTasks/AliEmcalJet.cxx
PWGJE/EMCALJetTasks/AliEmcalJet.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskSAJF.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskSAJF.h
PWGJE/PWGJEEMCALJetTasksLinkDef.h

index 7a2a89b..44a81ad 100644 (file)
 ClassImp(AliEMCALClusterizerFixedWindow)
 
 //__________________________________________________________________________________________
-  AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow()
-    : AliEMCALClusterizer(), 
-      fNphi(4), 
-      fNeta(4), 
-      fShiftPhi(2), 
-      fShiftEta(2),
-      fTRUshift(0),
-      fClustersArray(0)
+AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow() :
+  AliEMCALClusterizer(), 
+  fNphi(4), 
+  fNeta(4), 
+  fShiftPhi(2), 
+  fShiftEta(2),
+  fTRUshift(0),
+  fNEtaDigitsSupMod(0),
+  fNPhiDigitsSupMod(0),
+  fNTRUPhi(0),
+  fNTRUEta(0),
+  fNEtaDigits(0),
+  fNPhiDigits(0),
+  fMaxShiftPhi(0),
+  fMaxShiftEta(0),
+  fNDigitsCluster(0),
+  fNClusEtaNoShift(0),
+  fNClusPhiNoShift(0),
+  fNClusters(0),
+  fNTotalClus(0),
+  fClustersArray(0),
+  fInitialized(0)
 {
   // Constructor
 }
 
 //__________________________________________________________________________________________
-AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry)
-  : AliEMCALClusterizer(geometry), 
-    fNphi(4), 
-    fNeta(4), 
-    fShiftPhi(2), 
-    fShiftEta(2),
-    fTRUshift(0),
-    fClustersArray(0)
+AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry) :
+  AliEMCALClusterizer(geometry), 
+  fNphi(4), 
+  fNeta(4), 
+  fShiftPhi(2), 
+  fShiftEta(2),
+  fTRUshift(0),
+  fNEtaDigitsSupMod(0),
+  fNPhiDigitsSupMod(0),
+  fNTRUPhi(0),
+  fNTRUEta(0),
+  fNEtaDigits(0),
+  fNPhiDigits(0),
+  fMaxShiftPhi(0),
+  fMaxShiftEta(0),
+  fNDigitsCluster(0),
+  fNClusEtaNoShift(0),
+  fNClusPhiNoShift(0),
+  fNClusters(0),
+  fNTotalClus(0),
+  fClustersArray(0),
+  fInitialized(0)
 {
   // Constructor
 }
 
 //__________________________________________________________________________________________
-AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped)
-  : AliEMCALClusterizer(geometry, calib, caloped),
-    fNphi(4), 
-    fNeta(4), 
-    fShiftPhi(2), 
-    fShiftEta(2),
-    fTRUshift(0),
-    fClustersArray(0)
+AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped) :
+  AliEMCALClusterizer(geometry, calib, caloped),
+  fNphi(4), 
+  fNeta(4), 
+  fShiftPhi(2), 
+  fShiftEta(2),
+  fTRUshift(0),
+  fNEtaDigitsSupMod(0),
+  fNPhiDigitsSupMod(0),
+  fNTRUPhi(0),
+  fNTRUEta(0),
+  fNEtaDigits(0),
+  fNPhiDigits(0),
+  fMaxShiftPhi(0),
+  fMaxShiftEta(0),
+  fNDigitsCluster(0),
+  fNClusEtaNoShift(0),
+  fNClusPhiNoShift(0),
+  fNClusters(0),
+  fNTotalClus(0),
+  fClustersArray(0),
+  fInitialized(0)
 {
   // Constructor
 }
@@ -82,8 +124,18 @@ AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry*
 AliEMCALClusterizerFixedWindow::~AliEMCALClusterizerFixedWindow()
 {
   // Destructor
-  
-  delete fClustersArray;
+
+  if (fClustersArray) {
+    for (Int_t i = 0; i < fNTotalClus; i++) {
+      if (fClustersArray[i]) {
+       delete[] fClustersArray[i];
+       fClustersArray[i] = 0;
+      }
+      delete[] fClustersArray;
+      fClustersArray = 0;
+    }
+  }
+
 }
 
 //__________________________________________________________________________________________
@@ -91,7 +143,7 @@ void AliEMCALClusterizerFixedWindow::SetNphi (Int_t n)
 {
   // Set fNphi; if clusterizer already initialized gives a warning and does nothing
   
-  if (fClustersArray)
+  if (fInitialized != 0)
     AliWarning("Clusterizer already initialized. Unable to change the parameters.");
   else
     fNphi = n;
@@ -102,7 +154,7 @@ void AliEMCALClusterizerFixedWindow::SetNeta (Int_t n)
 {
   // Set fNeta; if clusterizer already initialized gives a warning and does nothing
   
-  if (fClustersArray)
+  if (fInitialized != 0)
     AliWarning("Clusterizer already initialized. Unable to change the parameters.");
   else
     fNeta = n;
@@ -113,7 +165,7 @@ void AliEMCALClusterizerFixedWindow::SetShiftPhi (Int_t s)
 {
   // Set fShiftPhi; if clusterizer already initialized gives a warning and does nothing
   
-  if (fClustersArray)
+  if (fInitialized != 0)
     AliWarning("Clusterizer already initialized. Unable to change the parameters.");
   else
     fShiftPhi = s;
@@ -124,7 +176,7 @@ void AliEMCALClusterizerFixedWindow::SetShiftEta (Int_t s)
 {
   // Set fShiftEta; if clusterizer already initialized gives a warning and does nothing
   
-  if (fClustersArray)
+  if (fInitialized != 0)
     AliWarning("Clusterizer already initialized. Unable to change the parameters.");
   else
     fShiftEta = s;
@@ -135,7 +187,7 @@ void AliEMCALClusterizerFixedWindow::SetTRUshift(Bool_t b)
 {
   // Set fTRUshift; if clusterizer already initialized gives a warning and does nothing
   
-  if (fClustersArray)
+  if (fInitialized != 0)
     AliWarning("Clusterizer already initialized. Unable to change the parameters.");
   else
     fTRUshift = b;
@@ -146,7 +198,10 @@ void AliEMCALClusterizerFixedWindow::SetTRUshift(Bool_t b)
 void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
 {
   // Steering method to perform clusterization for the current event 
-       
+  static Float_t cputime = 0;
+  static Float_t realtime = 0;
+
   if (strstr(option,"tim"))
     gBenchmark->Start("EMCALClusterizer"); 
        
@@ -198,86 +253,127 @@ void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
        
   if (strstr(option,"tim")) {
     gBenchmark->Stop("EMCALClusterizer");
-    printf("Exec took %f seconds for Clusterizing", 
-           gBenchmark->GetCpuTime("EMCALClusterizer"));
+    Printf("Exec took %f CPU time (%f real time) for clusterizing", 
+           gBenchmark->GetCpuTime("EMCALClusterizer")-cputime,gBenchmark->GetRealTime("EMCALClusterizer")-realtime);
+    cputime = gBenchmark->GetCpuTime("EMCALClusterizer");
+    realtime = gBenchmark->GetRealTime("EMCALClusterizer");
   }    
 }
 
 //__________________________________________________________________________________________
-void AliEMCALClusterizerFixedWindow::MakeClusters()
+void AliEMCALClusterizerFixedWindow::ExecOnce()
 {
-  // Make clusters
-       
-  if (fGeom == 0) 
-    AliFatal("Did not get geometry from EMCALLoader");
-       
-  fNumberOfECAClusters = 0;
-  fRecPoints->Delete();
-       
-  Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphi=0, ieta=0;
+  // Initialize clusterizer.
+  
+  fInitialized = -1;
+
+  if (!fGeom) {
+    AliError("Did not get geometry!");
+    return;
+  }
        
   // Defining geometry and clusterization parameter
-  Int_t nEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?;
-  Int_t nPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?;
+  fNEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?;
+  fNPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?;
   
-  Int_t nTRUPhi = 1;
-  Int_t nTRUEta = 1;
+  fNTRUPhi = 1;
+  fNTRUEta = 1;
   
-  Int_t nEtaDigits = nEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
-  Int_t nPhiDigits = nPhiDigitsSupMod * fGeom->GetNPhiSuperModule();    
+  fNEtaDigits = fNEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
+  fNPhiDigits = fNPhiDigitsSupMod * fGeom->GetNPhiSuperModule();    
   
   if (fTRUshift){
-    nTRUPhi = fGeom->GetNPhiSuperModule() * 3;
-    nTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
-    nEtaDigits /= nTRUEta;
-    nPhiDigits /= nTRUPhi;
+    fNTRUPhi = fGeom->GetNPhiSuperModule() * 3;
+    fNTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
+    fNEtaDigits /= fNTRUEta;
+    fNPhiDigits /= fNTRUPhi;
   }
 
   // Check if clusterizer parameter are compatible with calorimeter geometry
-  if (nEtaDigits < fNeta){
-    AliFatal(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,nEtaDigits));
+  if (fNEtaDigits < fNeta){
+    AliError(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,fNEtaDigits));
     return;
   }
-  if (nPhiDigits < fNphi){
-    AliFatal(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,nPhiDigits));
+  if (fNPhiDigits < fNphi){
+    AliError(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,fNPhiDigits));
     return;
   }
-  if (nEtaDigits % fShiftEta != 0){
-    AliFatal(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,nEtaDigits));
+  if (fNEtaDigits % fShiftEta != 0){
+    AliError(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,fNEtaDigits));
     return;
   }
-  if (nPhiDigits % fShiftPhi != 0){
-    AliFatal(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,nPhiDigits));
+  if (fNPhiDigits % fShiftPhi != 0){
+    AliError(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,fNPhiDigits));
     return;
   }
   if (fNeta % fShiftEta != 0){
-    AliFatal(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
+    AliError(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
     return;
   }
   if (fNphi % fShiftPhi != 0){
-    AliFatal(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
+    AliError(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
     return;
   }
   
-  Int_t maxiShiftPhi = fNphi / fShiftPhi;
-  Int_t maxiShiftEta = fNeta / fShiftEta;
-       
-  Int_t nDigitsCluster = fNphi * fNeta;
-  
-  Int_t nClusEtaNoShift = nEtaDigits / fNeta;
-  Int_t nClusPhiNoShift = nPhiDigits / fNphi;
+  fMaxShiftPhi = fNphi / fShiftPhi;
+  fMaxShiftEta = fNeta / fShiftEta;
   
-  Int_t nClusters =  nClusEtaNoShift * nClusPhiNoShift * nTRUEta * nTRUPhi;
-  
-  Int_t nTotalClus = nClusters * maxiShiftEta * maxiShiftPhi;
-  
-  if (!fClustersArray) {
-    fClustersArray = new AliEMCALDigit**[nTotalClus];
-    for (Int_t i = 0; i < nTotalClus; i++)
-    {
-      fClustersArray[i] = NULL;
+  fNClusEtaNoShift = fNEtaDigits / fNeta;
+  fNClusPhiNoShift = fNPhiDigits / fNphi;
+
+  fNClusters = fNClusEtaNoShift * fNClusPhiNoShift * fNTRUEta * fNTRUPhi;
+  fNTotalClus = fNClusters * fMaxShiftEta * fMaxShiftPhi;
+
+  fNDigitsCluster = fNphi * fNeta;
+
+  if (fClustersArray) {
+    for (Int_t i = 0; i < fNTotalClus; i++) {
+      if (fClustersArray[i]) {
+       delete[] fClustersArray[i];
+       fClustersArray[i] = 0;
+      }
+      delete[] fClustersArray;
+      fClustersArray = 0;
+    }
+  }
+
+  fClustersArray = new AliEMCALDigit**[fNTotalClus];
+  for (Int_t i = 0; i < fNTotalClus; i++) {
+    fClustersArray[i] = new AliEMCALDigit*[fNDigitsCluster];
+    for (Int_t j = 0; j < fNDigitsCluster; j++) {
+      fClustersArray[i][j] = 0;
     }
   }
+
+  AliDebug(1,Form("****ExecOnce*****\n"
+                 "fNphi = %d, fNeta = %d, fShiftPhi = %d, fShiftEta = %d, fTRUshift = %d\n"
+                 "fNEtaDigitsSupMod = %d, fNPhiDigitsSupMod = %d, fNTRUPhi = %d, fNTRUEta = %d, fNEtaDigits = %d, fNPhiDigits = %d\n"
+                 "fMaxShiftPhi = %d, fMaxShiftEta = %d, fNDigitsCluster = %d, fNClusEtaNoShift = %d, fNClusPhiNoShift = %d\n"
+                 "fNClusters = %d, fNTotalClus = %d\n",
+                 fNphi,fNeta,fShiftPhi,fShiftEta,fTRUshift,
+                 fNEtaDigitsSupMod,fNPhiDigitsSupMod,fNTRUPhi,fNTRUEta,fNEtaDigits,fNPhiDigits,
+                 fMaxShiftPhi,fMaxShiftEta,fNDigitsCluster,fNClusEtaNoShift,fNClusPhiNoShift,
+                 fNClusters,fNTotalClus));
+
+  fInitialized = 1;
+}
+  
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::MakeClusters()
+{
+  // Make clusters.
+
+  fNumberOfECAClusters = 0;
+  fRecPoints->Delete();
+
+  if (fInitialized == 0)
+    ExecOnce();
+
+  if (fInitialized == -1) {
+    AliError(Form("%s: error initializing the clusterizer. No clusterization will be performed.",GetName()));
+    return;
+  }
   
   // Set up TObjArray with pointers to digits to work on calibrated digits 
   TObjArray *digitsC = new TObjArray();
@@ -305,14 +401,17 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
   AliDebug(1,Form("MakeClusters: Number of digits %d  -> (e %f), ehs %f\n",
                   fDigitsArr->GetEntries(),fMinECut,ehs));
    
-  for (Int_t ishiftPhi = 0; ishiftPhi < maxiShiftPhi; ishiftPhi++){
-    Int_t nClusPhi = (nPhiDigits - fShiftPhi * ishiftPhi) / fNphi;
+  Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0;
+  Int_t iphi=0, ieta=0;  // cell eta-phi indexes in SM
+
+  for (Int_t ishiftPhi = 0; ishiftPhi < fMaxShiftPhi; ishiftPhi++){
+    Int_t nClusPhi = (fNPhiDigits - fShiftPhi * ishiftPhi) / fNphi;
     
-    for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++) {
+    for (Int_t ishiftEta = 0; ishiftEta < fMaxShiftEta; ishiftEta++) {
       
-      Int_t nClusEta = (nEtaDigits - fShiftEta * ishiftEta) / fNeta; 
+      Int_t nClusEta = (fNEtaDigits - fShiftEta * ishiftEta) / fNeta; 
       
-      Int_t iTotalClus = nClusters * (ishiftPhi * maxiShiftEta + ishiftEta);
+      Int_t iTotalClus = fNClusters * (ishiftPhi * fMaxShiftEta + ishiftEta);
       
       TIter nextdigitC(digitsC);
       while ((digit = dynamic_cast<AliEMCALDigit*>(nextdigitC()))) { // scan over the list of digitsC
@@ -320,54 +419,56 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
         fGeom->GetCellIndex (digit->GetId(), nSupMod, nModule, nIphi, nIeta);
         fGeom->GetCellPhiEtaIndexInSModule (nSupMod, nModule, nIphi, nIeta, iphi, ieta);
         
-        Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + nPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi
+        Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + fNPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi
         
-        Int_t iTRUphi = iphi_eff / nPhiDigits;
+        Int_t iTRUphi = iphi_eff / fNPhiDigits;
         
-        iphi_eff -= iTRUphi * nPhiDigits;
+        iphi_eff -= iTRUphi * fNPhiDigits;
         
         Int_t iClusPhi = iphi_eff / fNphi; 
         
         if (iphi_eff < 0 || iClusPhi >= nClusPhi) 
           continue;
         
-        Int_t ieta_eff = ieta - fShiftEta * ishiftEta + nEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta
+        Int_t ieta_eff = ieta - fShiftEta * ishiftEta + fNEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta
         
-        Int_t iTRUeta = ieta_eff / nEtaDigits;
+        Int_t iTRUeta = ieta_eff / fNEtaDigits;
         
-        ieta_eff -= iTRUeta * nEtaDigits;
+        ieta_eff -= iTRUeta * fNEtaDigits;
         
         Int_t iClusEta = ieta_eff / fNeta; 
         
         if (ieta_eff < 0 || iClusEta >= nClusEta) 
           continue;
         
-        iphi_eff += iTRUphi * nPhiDigits;
+        iphi_eff += iTRUphi * fNPhiDigits;
         iClusPhi = iphi_eff / fNphi; 
         
-        ieta_eff += iTRUeta * nEtaDigits;
+        ieta_eff += iTRUeta * fNEtaDigits;
         iClusEta = ieta_eff / fNeta; 
         
-        Int_t iCluster = iClusPhi + iClusEta * nClusPhiNoShift * nTRUPhi; 
+        Int_t iCluster = iClusPhi + iClusEta * fNClusPhiNoShift * fNTRUPhi; 
         Int_t iDigit = iphi_eff % fNphi + (ieta_eff % fNeta) * fNphi;
 
-        if (iCluster >= nClusters){
-          AliWarning(Form("iCluster out of range! iCluster = %d, nClusters = %d", iCluster, nClusters));
+        if (iCluster >= fNClusters){
+          AliError(Form("iCluster out of range! iCluster = %d, fNClusters = %d (should never happen...)", iCluster, fNClusters));
           return;
         }
         
         iCluster += iTotalClus;
-        
-        if (fClustersArray[iCluster] == NULL){
-          fNumberOfECAClusters++;
-          fClustersArray[iCluster] = new AliEMCALDigit*[nDigitsCluster];
-          for (Int_t i = 0; i < nDigitsCluster; i++){
-            fClustersArray[iCluster][i] = NULL;
-          }
+
+        if (iCluster >= fNTotalClus){
+          AliError(Form("iCluster out of range! iCluster = %d, fNTotalClus = %d (should never happen...)", iCluster, fNTotalClus));
+          return;
         }
-        
-        if (fClustersArray[iCluster][iDigit] != NULL){
-          AliWarning("Digit already added!");
+
+        if (iDigit >= fNDigitsCluster){
+          AliError(Form("iDigit out of range! iDigit = %d, fNDigitsCluster = %d (should never happen...)", iDigit, fNDigitsCluster));
+          return;
+        }
+
+        if (fClustersArray[iCluster][iDigit] != 0){
+          AliError("Digit already added! (should never happen...)");
           return;
         }
         
@@ -378,34 +479,45 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
     } // loop on eta shift
     
   } // loop on phi shift
-       
-  if(fNumberOfECAClusters >= fRecPoints->GetSize()) 
-    fRecPoints->Expand(fNumberOfECAClusters+1);
   
-  Int_t iRecPoint = 0;
-  for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++) {
-    
-    if (fClustersArray[iCluster] == NULL) 
-      continue;
+  AliEMCALRecPoint *recPoint = 0;
+  Bool_t recPointOk = kFALSE;
+  for (Int_t iCluster = 0; iCluster < fNTotalClus; iCluster++) {
+
+    if (!recPoint) {
+      if(fNumberOfECAClusters >= fRecPoints->GetSize()) fRecPoints->Expand(fNumberOfECAClusters*2+1);
 
-    (*fRecPoints)[iRecPoint] = new AliEMCALRecPoint("");
-    AliEMCALRecPoint *recPoint = dynamic_cast<AliEMCALRecPoint*> (fRecPoints->At(iRecPoint));
+      (*fRecPoints)[fNumberOfECAClusters] = new AliEMCALRecPoint("");
+      recPoint = static_cast<AliEMCALRecPoint*>(fRecPoints->At(fNumberOfECAClusters));
+    }
                
     if (recPoint) {
-      iRecPoint++;       
       recPoint->SetClusterType(AliVCluster::kEMCALClusterv1);
       recPoint->SetUniqueID(iCluster);
+      fNumberOfECAClusters++;
 
-      for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++){
-        if (fClustersArray[iCluster][iDigit] == NULL) continue;
+      for (Int_t iDigit = 0; iDigit < fNDigitsCluster; iDigit++) {
+        if (fClustersArray[iCluster][iDigit] == 0) continue;
         digit = fClustersArray[iCluster][iDigit];
         recPoint->AddDigit(*digit, digit->GetCalibAmp(), kFALSE); //Time or TimeR?
-        fClustersArray[iCluster][iDigit] = NULL;
+        fClustersArray[iCluster][iDigit] = 0;
+       recPointOk = kTRUE;
+      }
+
+      if (recPointOk) { // unset the pointer so that a new rec point will be allocated in the next iteration
+       recPoint = 0;
+       recPointOk = kFALSE;
       }
     }
-    
-    delete[] fClustersArray[iCluster];
-    fClustersArray[iCluster] = NULL;
+    else {
+      AliError("Error allocating rec points!");
+      break;
+    }
+  }
+
+  if (!recPointOk) {
+    fRecPoints->RemoveLast();
+    fNumberOfECAClusters--;
   }
 
   delete digitsC;
index 0b499b9..e5a595b 100644 (file)
@@ -36,19 +36,34 @@ class AliEMCALClusterizerFixedWindow : public AliEMCALClusterizer {
   void                    SetTRUshift(Bool_t b);
   
 protected:
-       virtual void MakeClusters(); 
+  void MakeClusters(); 
+  void ExecOnce(); 
   
   Int_t                   fNphi;                // Fixed window number of cells in phi direction
   Int_t                   fNeta;                // Fixed window number of cells in eta direction
   Int_t                   fShiftPhi;            // Shifting number of cells in phi direction
   Int_t                   fShiftEta;            // Shifting number of cells in eta direction
   Bool_t                  fTRUshift;            // Allows shifting inside a TRU (true) of through the whole calorimeter (false)
+  Int_t                   fNEtaDigitsSupMod;    //!Number of digits per SM in eta 
+  Int_t                   fNPhiDigitsSupMod;    //!Number of digits per SM in phi
+  Int_t                   fNTRUPhi;             //!Number of TRUs in phi
+  Int_t                   fNTRUEta;             //!Number of TRUs in eta
+  Int_t                   fNEtaDigits;          //!Total number of digits in eta 
+  Int_t                   fNPhiDigits;          //!Total number of digits in phi
+  Int_t                   fMaxShiftPhi;         //!Max shift index in phi
+  Int_t                   fMaxShiftEta;         //!Max shift index in eta
+  Int_t                   fNDigitsCluster;      //!Digits per cluster
+  Int_t                   fNClusEtaNoShift;     //!Max number of clusters in eta
+  Int_t                   fNClusPhiNoShift;     //!Max number of clusters in phi
+  Int_t                   fNClusters;           //!fNClusEtaNoShift x fNClusPhiNoShift
+  Int_t                   fNTotalClus;          //!Maximum total number of clusters
   AliEMCALDigit        ***fClustersArray;       //!Temporary array that contains clusters
+  Int_t                   fInitialized;         //!Initialized clusterizer
        
 private:
   AliEMCALClusterizerFixedWindow(const AliEMCALClusterizerFixedWindow &);                 // not implemented
   AliEMCALClusterizerFixedWindow & operator = (const AliEMCALClusterizerFixedWindow &);   // not implemented
 
-  ClassDef(AliEMCALClusterizerFixedWindow,4)   // Clusterizer implementation version 1
+  ClassDef(AliEMCALClusterizerFixedWindow,4)   // Clusterizer implementation fixed windows
 };
 #endif // AliEMCALCLUSTERIZERFIXEDWINDOW_H
index cc23759..4b201a8 100644 (file)
@@ -369,10 +369,12 @@ void AliAnalysisTaskEmcalDev::ExecOnce()
     cont->SetParticleArray(InputEvent());
   }
 
-  fTracks = GetParticleArray(0);
-  if(!fTracks && fParticleCollArray.GetEntriesFast()>0) {
-    AliError(Form("%s: Could not retrieve first track branch!", GetName()));
-    return;
+  if (fParticleCollArray.GetEntriesFast()>0) {
+    fTracks = GetParticleArray(0);
+    if(!fTracks) {
+      AliError(Form("%s: Could not retrieve first track branch!", GetName()));
+      return;
+    }
   }
 
   //Load all requested cluster branches - each container knows name already
@@ -380,11 +382,13 @@ void AliAnalysisTaskEmcalDev::ExecOnce()
     AliClusterContainer *cont = static_cast<AliClusterContainer*>(fClusterCollArray.At(i));
     cont->SetClusterArray(InputEvent());
   }
-  if(fClusterCollArray.GetEntriesFast()>0)
+
+  if(fClusterCollArray.GetEntriesFast()>0) {
     fCaloClusters = GetClusterArray(0);
-  if(!fCaloClusters && fClusterCollArray.GetEntriesFast()>0) {
-    AliError(Form("%s: Could not retrieve first cluster branch!", GetName()));
-    return;
+    if(!fCaloClusters) {
+      AliError(Form("%s: Could not retrieve first cluster branch!", GetName()));
+      return;
+    }
   }
 
   if (!fCaloCellsName.IsNull() && !fCaloCells) {
@@ -585,7 +589,7 @@ Bool_t AliAnalysisTaskEmcalDev::RetrieveEventObjects()
   if (fBeamType == kAA || fBeamType == kpA ) {
     AliCentrality *aliCent = InputEvent()->GetCentrality();
     if (aliCent) {
-      fCent = aliCent->GetCentralityPercentile(fCentEst.Data()); 
+      fCent = aliCent->GetCentralityPercentile(fCentEst.Data());
       if(fNcentBins==4) {
        if      (fCent >=  0 && fCent <   10) fCentBin = 0;
        else if (fCent >= 10 && fCent <   30) fCentBin = 1;
@@ -603,10 +607,6 @@ Bool_t AliAnalysisTaskEmcalDev::RetrieveEventObjects()
          AliWarning(Form("%s: fCentBin too large: cent = %f fCentBin = %d. Assuming 99", GetName(),fCent,fCentBin));
          fCentBin = fNcentBins-1;
        }
-       if(fCentBin>=fNcentBins) {
-         AliWarning(Form("%s: fCentBin too large: cent = %f fCentBin = %d. Assuming 99", GetName(),fCent,fCentBin));
-         fCentBin = fNcentBins-1;
-       }
       }
     } else {
       AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName()));
index 3a025d9..57472b1 100644 (file)
@@ -77,20 +77,20 @@ class AliAnalysisTaskEmcalDev : public AliAnalysisTaskSE {
   void                        AddClusterContainer(const char *n);
 
 
-  AliParticleContainer       *GetParticleContainer(const Int_t i)   const;
-  AliClusterContainer        *GetClusterContainer(const Int_t i)    const;
-  void                        RemoveParticleContainer(Int_t i)                      { fParticleCollArray.RemoveAt(i);} 
-  void                        RemoveClusterContainer(Int_t i)                       { fClusterCollArray.RemoveAt(i);} 
+  AliParticleContainer       *GetParticleContainer(const Int_t i=0)   const;
+  AliClusterContainer        *GetClusterContainer(const Int_t i=0)    const;
+  void                        RemoveParticleContainer(Int_t i=0)                      { fParticleCollArray.RemoveAt(i);} 
+  void                        RemoveClusterContainer(Int_t i=0)                       { fClusterCollArray.RemoveAt(i);} 
 
 
-  TClonesArray               *GetParticleArray(const Int_t i)       const;
-  TClonesArray               *GetClusterArray(const Int_t i)        const;
+  TClonesArray               *GetParticleArray(const Int_t i=0)       const;
+  TClonesArray               *GetClusterArray(const Int_t i=0)        const;
 
-  AliVParticle               *GetAcceptParticleFromArray(Int_t p, Int_t c) const;
-  AliVCluster                *GetAcceptClusterFromArray(Int_t cl, Int_t c) const;
+  AliVParticle               *GetAcceptParticleFromArray(Int_t p, Int_t c=0) const;
+  AliVCluster                *GetAcceptClusterFromArray(Int_t cl, Int_t c=0) const;
 
-  Int_t                       GetNParticles(Int_t i) const;
-  Int_t                       GetNClusters(Int_t i)  const;
+  Int_t                       GetNParticles(Int_t i=0) const;
+  Int_t                       GetNClusters(Int_t i=0)  const;
 
  protected:
   Bool_t                      AcceptCluster(AliVCluster        *clus,  Int_t c = 0)  const;
index 092c8ac..7a0abdd 100644 (file)
@@ -53,6 +53,7 @@ set ( SRCS
  EMCALJetTasks/AliRhoParameter.cxx
  EMCALJetTasks/AliLocalRhoParameter.cxx
  EMCALJetTasks/AliEmcalJetFinder.cxx
+ EMCALJetTasks/AliJetTriggerSelectionTask.cxx
  EMCALJetTasks/UserTasks/AliAnalysisTaskCLQA.cxx
  EMCALJetTasks/UserTasks/AliAnalysisTaskChargedJetsPA.cxx
  EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalBadCells.cxx
index db2b53d..8326a69 100644 (file)
@@ -45,6 +45,7 @@ AliAnalysisTaskEmcalJet::AliAnalysisTaskEmcalJet() :
   fLeadingHadronType(0),
   fNLeadingJets(1),
   fJetBitMap(0),
+  fJetTrigger(0),
   fJets(0),
   fRho(0),
   fRhoVal(0)
@@ -73,6 +74,7 @@ AliAnalysisTaskEmcalJet::AliAnalysisTaskEmcalJet(const char *name, Bool_t histo)
   fLeadingHadronType(0),
   fNLeadingJets(1),
   fJetBitMap(0),
+  fJetTrigger(0),
   fJets(0),
   fRho(0),
   fRhoVal(0)
@@ -160,6 +162,9 @@ Bool_t AliAnalysisTaskEmcalJet::AcceptJet(AliEmcalJet *jet) const
   if (fJetMinPhi < 0) // if limits are given in (-pi, pi) range
     jetPhi -= TMath::Pi() * 2;
 
+  if (fJetTrigger != 0 && !jet->IsTriggerJet(fJetTrigger))
+    return kFALSE;
+
   return (Bool_t)(jetEta > fJetMinEta && jetEta < fJetMaxEta && jetPhi > fJetMinPhi && jetPhi < fJetMaxPhi);
 }
 
index 56007d3..8b3d7d4 100644 (file)
@@ -11,6 +11,7 @@ class AliRhoParameter;
 class AliVCluster;
 class AliVParticle;
 
+#include "AliVEvent.h"
 #include "AliAnalysisTaskEmcal.h"
 
 class AliAnalysisTaskEmcalJet : public AliAnalysisTaskEmcal {
@@ -35,6 +36,7 @@ class AliAnalysisTaskEmcalJet : public AliAnalysisTaskEmcal {
   void                        SetLeadingHadronType(Int_t t)                        { fLeadingHadronType = t             ; }
   void                        SetNLeadingJets(Int_t t)                             { fNLeadingJets   = t                ; }
   void                        SetJetBitMap(UInt_t m)                               { fJetBitMap      = m                ; }
+  void                        SetJetTrigger(UInt_t t=AliVEvent::kEMCEJE)           { fJetTrigger     = t                ; }
  
  protected:
   Float_t*                    GenerateFixedBinArray(Int_t n, Float_t min, Float_t max) const;
@@ -66,6 +68,7 @@ class AliAnalysisTaskEmcalJet : public AliAnalysisTaskEmcal {
   Int_t                       fLeadingHadronType;          // 0 = charged, 1 = neutral, 2 = both
   Int_t                       fNLeadingJets;               // how many jets are to be considered the leading jet(s)
   UInt_t                      fJetBitMap;                  // bit map of accepted jets
+  UInt_t                      fJetTrigger;                 // jet trigger
   TClonesArray               *fJets;                       //!jets
   AliRhoParameter            *fRho;                        //!event rho
   Double_t                    fRhoVal;                     //!event rho value
@@ -74,6 +77,6 @@ class AliAnalysisTaskEmcalJet : public AliAnalysisTaskEmcal {
   AliAnalysisTaskEmcalJet(const AliAnalysisTaskEmcalJet&);            // not implemented
   AliAnalysisTaskEmcalJet &operator=(const AliAnalysisTaskEmcalJet&); // not implemented
 
-  ClassDef(AliAnalysisTaskEmcalJet, 7) // EMCAL Jet base analysis task
+  ClassDef(AliAnalysisTaskEmcalJet, 8) // EMCAL Jet base analysis task
 };
 #endif
index 319d28c..a7d9ed4 100644 (file)
@@ -43,12 +43,12 @@ class AliAnalysisTaskEmcalJetDev : public AliAnalysisTaskEmcalDev {
   void                        AddJetContainer(const char *n, TString defaultCutType = "", Float_t jetRadius = 0.4);
   void                        RemoveJetContainer(Int_t i)          { fJetCollArray.RemoveAt(i);} 
 
-  AliJetContainer            *GetJetContainer(Int_t i)                const;
-  TClonesArray               *GetJetArray(Int_t i)                    const;
-  AliEmcalJet                *GetJetFromArray(Int_t j, Int_t c)       const;
-  AliEmcalJet                *GetAcceptJetFromArray(Int_t j, Int_t c) const;
-  Int_t                       GetNJets(Int_t i)                       const;
-  Double_t                    GetRhoVal(Int_t i)                      const;
+  AliJetContainer            *GetJetContainer(Int_t i=0)                const;
+  TClonesArray               *GetJetArray(Int_t i=0)                    const;
+  AliEmcalJet                *GetJetFromArray(Int_t j, Int_t c=0)       const;
+  AliEmcalJet                *GetAcceptJetFromArray(Int_t j, Int_t c=0) const;
+  Int_t                       GetNJets(Int_t i=0)                       const;
+  Double_t                    GetRhoVal(Int_t i=0)                      const;
 
  protected:
   Float_t*                    GenerateFixedBinArray(Int_t n, Float_t min, Float_t max) const;
index c9bfb3c..830ca57 100644 (file)
@@ -33,7 +33,8 @@ AliEmcalJet::AliEmcalJet() :
   fMatched(2),
   fMatchingType(0),
   fPtSub(0),
-  fPtVectSub(0)
+  fPtVectSub(0),
+  fTriggers(0)
 {
   // Constructor.
 
@@ -68,7 +69,8 @@ AliEmcalJet::AliEmcalJet(Double_t px, Double_t py, Double_t pz) :
   fMatched(2),
   fMatchingType(0),
   fPtSub(0),
-  fPtVectSub(0)
+  fPtVectSub(0),
+  fTriggers(0)
 {    
   // Constructor.
 
@@ -109,7 +111,8 @@ AliEmcalJet::AliEmcalJet(Double_t pt, Double_t eta, Double_t phi, Double_t m) :
   fMatched(2),
   fMatchingType(0),
   fPtSub(0),
-  fPtVectSub(0)
+  fPtVectSub(0),
+  fTriggers(0)
 {
   // Constructor.
 
@@ -147,7 +150,8 @@ AliEmcalJet::AliEmcalJet(const AliEmcalJet &jet) :
   fMatched(jet.fMatched),
   fMatchingType(jet.fMatchingType),
   fPtSub(jet.fPtSub),
-  fPtVectSub(jet.fPtVectSub)
+  fPtVectSub(jet.fPtVectSub),
+  fTriggers(jet.fTriggers)
 {
   // Copy constructor.
 
@@ -190,6 +194,7 @@ AliEmcalJet &AliEmcalJet::operator=(const AliEmcalJet &jet)
     fMatched            = jet.fMatched;
     fPtSub              = jet.fPtSub;
     fPtVectSub          = jet.fPtVectSub;
+    fTriggers           = jet.fTriggers;
   }
 
   return *this;
index ed06d04..03983e7 100644 (file)
@@ -10,6 +10,7 @@
 
 #include "AliVParticle.h"
 #include "AliVCluster.h"
+#include "AliVEvent.h"
 
 class AliEmcalJet : public AliVParticle
 {
@@ -102,7 +103,12 @@ class AliEmcalJet : public AliVParticle
   void              SetNEmc(Int_t n)                                { fNEmc           = n;      }
   void              SetPtEmc(Double_t pt)                           { fPtEmc          = pt;     }
   void              SetPtSub(Double_t ps)                           { fPtSub          = ps;     } 
-  void              SetPtSubVect(Double_t ps)                       { fPtVectSub      = ps;     } 
+  void              SetPtSubVect(Double_t ps)                       { fPtVectSub      = ps;     }
+
+  // Trigger
+  Bool_t            IsTriggerJet(UInt_t trigger=AliVEvent::kEMCEJE) const   { return (Bool_t)((fTriggers & trigger) != 0); }
+  void              SetTrigger(UInt_t trigger)                              { fTriggers  = trigger;                        }
+  void              AddTrigger(UInt_t trigger)                              { fTriggers |= trigger;                        }
 
   // Matching
   void              SetClosestJet(AliEmcalJet *j, Double_t d)       { fClosestJets[0] = j; fClosestJetsDist[0] = d    ; }
@@ -143,6 +149,7 @@ class AliEmcalJet : public AliVParticle
   UShort_t          fMatchingType;        //!          matching type
   Double_t          fPtSub;               //!          background subtracted pt (not stored set from outside) 
   Double_t          fPtVectSub;           //!          background vector subtracted pt (not stored set from outside) 
+  UInt_t            fTriggers;            //!          triggers that the jet might have fired (AliVEvent::EOfflineTriggerTypes)
 
   ClassDef(AliEmcalJet,9) // Emcal jet class in cylindrical coordinates
 };
index c90bc46..f3eab00 100644 (file)
@@ -6,6 +6,7 @@
 
 #include <TClonesArray.h>
 #include <TH2F.h>
+#include <TH3F.h>
 #include <THnSparse.h>
 #include <TList.h>
 #include <TLorentzVector.h>
@@ -23,6 +24,7 @@ ClassImp(AliAnalysisTaskSAJF)
 //________________________________________________________________________
 AliAnalysisTaskSAJF::AliAnalysisTaskSAJF() : 
   AliAnalysisTaskEmcalJet("AliAnalysisTaskSAJF", kTRUE),
+  fHistoType(1),
   fHistJetObservables(0)
 
 {
@@ -33,6 +35,22 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF() :
     fHistClustersJetPt[i] = 0;
     fHistTracksPtDist[i] = 0;
     fHistClustersPtDist[i] = 0;
+
+    fHistJetPtEtaPhi[i] = 0;
+    fHistJetPtArea[i] = 0;
+    fHistJetPtEP[i] = 0;
+    fHistJetPtNEF[i] = 0;
+    fHistJetPtZ[i] = 0;
+    fHistJetPtLeadingPartPt[i] = 0;
+    fHistJetCorrPtEtaPhi[i] = 0;
+    fHistJetCorrPtArea[i] = 0;
+    fHistJetCorrPtEP[i] = 0;
+    fHistJetCorrPtNEF[i] = 0;
+    fHistJetCorrPtZ[i] = 0;
+    fHistJetCorrPtLeadingPartPt[i] = 0;
+    fHistJetPtCorrPt[i] = 0;
+    fHistJetPtMCPt[i] = 0;
+    fHistJetMCPtCorrPt[i] = 0;
   }
 
   SetMakeGeneralHistograms(kTRUE);
@@ -41,6 +59,7 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF() :
 //________________________________________________________________________
 AliAnalysisTaskSAJF::AliAnalysisTaskSAJF(const char *name) : 
   AliAnalysisTaskEmcalJet(name, kTRUE),
+  fHistoType(1),
   fHistJetObservables(0)
 {
   // Standard constructor.
@@ -50,19 +69,31 @@ AliAnalysisTaskSAJF::AliAnalysisTaskSAJF(const char *name) :
     fHistClustersJetPt[i] = 0;
     fHistTracksPtDist[i] = 0;
     fHistClustersPtDist[i] = 0;
+
+    fHistJetPtEtaPhi[i] = 0;
+    fHistJetPtArea[i] = 0;
+    fHistJetPtEP[i] = 0;
+    fHistJetPtNEF[i] = 0;
+    fHistJetPtZ[i] = 0;
+    fHistJetPtLeadingPartPt[i] = 0;
+    fHistJetCorrPtEtaPhi[i] = 0;
+    fHistJetCorrPtArea[i] = 0;
+    fHistJetCorrPtEP[i] = 0;
+    fHistJetCorrPtNEF[i] = 0;
+    fHistJetCorrPtZ[i] = 0;
+    fHistJetCorrPtLeadingPartPt[i] = 0;
+    fHistJetPtCorrPt[i] = 0;
+    fHistJetPtMCPt[i] = 0;
+    fHistJetMCPtCorrPt[i] = 0;
   }
 
   SetMakeGeneralHistograms(kTRUE);
 }
 
 //________________________________________________________________________
-void AliAnalysisTaskSAJF::UserCreateOutputObjects()
+void AliAnalysisTaskSAJF::AllocateTHnSparse()
 {
-  // Create user output.
-
-  AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
-
-  TString title[20]= {""};
+    TString title[20]= {""};
   Int_t nbins[20]  = {0};
   Double_t min[20] = {0.};
   Double_t max[20] = {0.};
@@ -70,68 +101,68 @@ void AliAnalysisTaskSAJF::UserCreateOutputObjects()
 
   if (fForceBeamType != kpp) {
     title[dim] = "Centrality (%)";
-    nbins[dim] = 101;
-    min[dim] = 0;
-    max[dim] = 101;
+    nbins[dim] = 22;
+    min[dim] = -5;
+    max[dim] = 105;
     dim++;
     
     title[dim] = "#phi_{jet} - #psi_{RP}";
-    nbins[dim] = fNbins/2;
-    min[dim] = -TMath::Pi()/2;
-    max[dim] = TMath::Pi()*5/2;
+    nbins[dim] = 100;
+    min[dim] = 0;
+    max[dim] = TMath::Pi();
     dim++;
   }
 
   title[dim] = "#eta";
-  nbins[dim] = fNbins/2;
+  nbins[dim] = 100;
   min[dim] = -1;
   max[dim] = 1;
   dim++;
 
   title[dim] = "#phi_{jet} (rad)";
-  nbins[dim] = fNbins/2+1;
+  nbins[dim] = 201;
   min[dim] = 0;
   max[dim] = 2*TMath::Pi()*nbins[dim]/(nbins[dim]-1);
   dim++;
 
   title[dim] = "p_{T} (GeV/c)";
   nbins[dim] = fNbins;
-  min[dim] = 0;
-  max[dim] = 250;
+  min[dim] = fMinBinPt;
+  max[dim] = fMaxBinPt;
   dim++;
 
   if (fIsEmbedded) {
     title[dim] = "p_{T}^{MC} (GeV/c)";
     nbins[dim] = fNbins;
-    min[dim] = 0;
-    max[dim] = 250;
+    min[dim] = fMinBinPt;
+    max[dim] = fMaxBinPt;
     dim++;
   }
 
   if (!fRhoName.IsNull()) {
     title[dim] = "p_{T}^{corr} (GeV/c)";
     nbins[dim] = fNbins*2;
-    min[dim] = -250;
-    max[dim] = 250;
+    min[dim] = -fMaxBinPt;
+    max[dim] = fMaxBinPt;
     dim++;
   }
 
   title[dim] = "A_{jet}";
-  nbins[dim] = fNbins/2;
+  nbins[dim] = 150;
   min[dim] = 0;
-  max[dim] = 1;
+  max[dim] = 1.5;
   dim++;
 
   title[dim] = "NEF";
-  nbins[dim] = fNbins/2;
+  nbins[dim] = 102;
   min[dim] = 0;
-  max[dim] = 1.25;
+  max[dim] = 1.02;
   dim++;
 
   title[dim] = "Z";
-  nbins[dim] = fNbins/2;
+  nbins[dim] = 102;
   min[dim] = 0;
-  max[dim] = 1.25;
+  max[dim] = 1.02;
   dim++;
 
   title[dim] = "No. of constituents";
@@ -141,15 +172,162 @@ void AliAnalysisTaskSAJF::UserCreateOutputObjects()
   dim++;
 
   title[dim] = "p_{T,particle}^{leading} (GeV/c)";
-  nbins[dim] = fNbins/2;
+  nbins[dim] = 120;
   min[dim] = 0;
-  max[dim] = 125;
+  max[dim] = 120;
   dim++;
 
   fHistJetObservables = new THnSparseD("fHistJetObservables","fHistJetObservables",dim,nbins,min,max);
   fOutput->Add(fHistJetObservables);
   for (Int_t i = 0; i < dim; i++)
     fHistJetObservables->GetAxis(i)->SetTitle(title[i]);
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskSAJF::AllocateTHX()
+{
+  for (Int_t i = 0; i < 4; i++) {
+    TString histname;
+
+    histname = "fHistJetPtEtaPhi_";
+    histname += i;
+    fHistJetPtEtaPhi[i] = new TH3F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 20, -1, 1, 41, 0, 2*TMath::Pi()*41/40);
+    fHistJetPtEtaPhi[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+    fHistJetPtEtaPhi[i]->GetYaxis()->SetTitle("#eta");
+    fHistJetPtEtaPhi[i]->GetZaxis()->SetTitle("#phi_{jet} (rad)");
+    fOutput->Add(fHistJetPtEtaPhi[i]);
+      
+    histname = "fHistJetPtArea_";
+    histname += i;
+    fHistJetPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 150, 0, 1.5);
+    fHistJetPtArea[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+    fHistJetPtArea[i]->GetYaxis()->SetTitle("A_{jet}");
+    fHistJetPtArea[i]->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJetPtArea[i]);
+
+    histname = "fHistJetPtEP_";
+    histname += i;
+    fHistJetPtEP[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 100, 0, TMath::Pi());
+    fHistJetPtEP[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+    fHistJetPtEP[i]->GetYaxis()->SetTitle("#phi_{jet} - #psi_{RP}");
+    fHistJetPtEP[i]->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJetPtEP[i]);
+
+    histname = "fHistJetPtNEF_";
+    histname += i;
+    fHistJetPtNEF[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 102, 0, 1.02);
+    fHistJetPtNEF[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+    fHistJetPtNEF[i]->GetYaxis()->SetTitle("NEF");
+    fHistJetPtNEF[i]->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJetPtNEF[i]);
+
+    histname = "fHistJetPtZ_";
+    histname += i;
+    fHistJetPtZ[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 102, 0, 1.02);
+    fHistJetPtZ[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+    fHistJetPtZ[i]->GetYaxis()->SetTitle("z");
+    fHistJetPtZ[i]->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJetPtZ[i]);
+
+    histname = "fHistJetPtLeadingPartPt_";
+    histname += i;
+    fHistJetPtLeadingPartPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 120, 0, 120);
+    fHistJetPtLeadingPartPt[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+    fHistJetPtLeadingPartPt[i]->GetYaxis()->SetTitle("p_{T,particle}^{leading} (GeV/c)");
+    fHistJetPtLeadingPartPt[i]->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJetPtLeadingPartPt[i]);
+
+    if (!fRhoName.IsNull()) {
+      histname = "fHistJetCorrPtEtaPhi_";
+      histname += i;
+      fHistJetCorrPtEtaPhi[i] = new TH3F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 20, -1, 1, 41, 0, 2*TMath::Pi()*201/200);
+      fHistJetCorrPtEtaPhi[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+      fHistJetCorrPtEtaPhi[i]->GetYaxis()->SetTitle("#eta");
+      fHistJetCorrPtEtaPhi[i]->GetZaxis()->SetTitle("#phi_{jet} (rad)");
+      fOutput->Add(fHistJetCorrPtEtaPhi[i]);
+      
+      histname = "fHistJetCorrPtArea_";
+      histname += i;
+      fHistJetCorrPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 150, 0, 1.5);
+      fHistJetCorrPtArea[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+      fHistJetCorrPtArea[i]->GetYaxis()->SetTitle("A_{jet}");
+      fHistJetCorrPtArea[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetCorrPtArea[i]);
+
+      histname = "fHistJetCorrPtEP_";
+      histname += i;
+      fHistJetCorrPtEP[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 100, 0, TMath::Pi());
+      fHistJetCorrPtEP[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+      fHistJetCorrPtEP[i]->GetYaxis()->SetTitle("#phi_{jet} - #psi_{RP}");
+      fHistJetCorrPtEP[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetCorrPtEP[i]);
+
+      histname = "fHistJetCorrPtNEF_";
+      histname += i;
+      fHistJetCorrPtNEF[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 102, 0, 1.02);
+      fHistJetCorrPtNEF[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+      fHistJetCorrPtNEF[i]->GetYaxis()->SetTitle("NEF");
+      fHistJetCorrPtNEF[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetCorrPtNEF[i]);
+
+      histname = "fHistJetCorrPtZ_";
+      histname += i;
+      fHistJetCorrPtZ[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 102, 0, 1.02);
+      fHistJetCorrPtZ[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+      fHistJetCorrPtZ[i]->GetYaxis()->SetTitle("z");
+      fHistJetCorrPtZ[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetCorrPtZ[i]);
+
+      histname = "fHistJetCorrPtLeadingPartPt_";
+      histname += i;
+      fHistJetCorrPtLeadingPartPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 120, 0, 120);
+      fHistJetCorrPtLeadingPartPt[i]->GetXaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+      fHistJetCorrPtLeadingPartPt[i]->GetYaxis()->SetTitle("p_{T,particle}^{leading} (GeV/c)");
+      fHistJetCorrPtLeadingPartPt[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetCorrPtLeadingPartPt[i]);
+
+      histname = "fHistJetPtCorrPt_";
+      histname += i;
+      fHistJetPtCorrPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins*2, -fMaxBinPt, fMaxBinPt);
+      fHistJetPtCorrPt[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+      fHistJetPtCorrPt[i]->GetYaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+      fHistJetPtCorrPt[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetPtCorrPt[i]);
+
+      if (fIsEmbedded) {
+       histname = "fHistJetMCPtCorrPt_";
+       histname += i;
+       fHistJetMCPtCorrPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins*2, -fMaxBinPt, fMaxBinPt);
+       fHistJetMCPtCorrPt[i]->GetXaxis()->SetTitle("p_{T}^{MC} (GeV/c)");
+       fHistJetMCPtCorrPt[i]->GetYaxis()->SetTitle("p_{T}^{corr} (GeV/c)");
+       fHistJetMCPtCorrPt[i]->GetZaxis()->SetTitle("counts");
+       fOutput->Add(fHistJetMCPtCorrPt[i]);
+      }
+    }
+
+    if (fIsEmbedded) {
+      histname = "fHistJetPtMCPt_";
+      histname += i;
+      fHistJetPtMCPt[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
+      fHistJetPtMCPt[i]->GetXaxis()->SetTitle("p_{T} (GeV/c)");
+      fHistJetPtMCPt[i]->GetYaxis()->SetTitle("p_{T}^{MC} (GeV/c)");
+      fHistJetPtMCPt[i]->GetZaxis()->SetTitle("counts");
+      fOutput->Add(fHistJetPtMCPt[i]);
+    }
+  }
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskSAJF::UserCreateOutputObjects()
+{
+  // Create user output.
+
+  AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
+
+  if (fHistoType == 0)
+    AllocateTHX();
+  else
+    AllocateTHnSparse();
 
   for (Int_t i = 0; i < 4; i++) {
     TString histname;
@@ -221,7 +399,11 @@ Bool_t AliAnalysisTaskSAJF::FillHistograms()
     Float_t corrPt = jet->Pt() - fRhoVal * jet->Area();
 
     // Fill THnSparse
-    FillJetHisto(fCent, fEPV0, jet->Eta(), jet->Phi(), jet->Pt(), jet->MCPt(), corrPt, jet->Area(), 
+    Double_t ep = jet->Phi() - fEPV0;
+    while (ep < 0) ep += TMath::Pi();
+    while (ep >= TMath::Pi()) ep -= TMath::Pi();
+
+    FillJetHisto(fCent, ep, jet->Eta(), jet->Phi(), jet->Pt(), jet->MCPt(), corrPt, jet->Area(), 
                 jet->NEF(), ptLeading/jet->Pt(), jet->GetNumberOfConstituents(), ptLeading);
 
     if (fTracks) {
@@ -258,37 +440,61 @@ Bool_t AliAnalysisTaskSAJF::FillHistograms()
 void AliAnalysisTaskSAJF::FillJetHisto(Double_t cent, Double_t ep, Double_t eta, Double_t phi, Double_t pt, Double_t MCpt, Double_t corrpt, Double_t area, 
                                       Double_t NEF, Double_t z, Int_t n, Double_t leadingpt)
 {
-  Double_t contents[20]={0};
-
-  for (Int_t i = 0; i < fHistJetObservables->GetNdimensions(); i++) {
-    TString title(fHistJetObservables->GetAxis(i)->GetTitle());
-    if (title=="Centrality (%)")
-      contents[i] = cent;
-    else if (title=="#phi_{jet} - #psi_{RP}")
-      contents[i] = phi - ep;
-    else if (title=="#eta")
-      contents[i] = eta;
-    else if (title=="#phi_{jet} (rad)")
-      contents[i] = phi;
-    else if (title=="p_{T} (GeV/c)")
-      contents[i] = pt;
-    else if (title=="p_{T}^{MC} (GeV/c)")
-      contents[i] = MCpt;
-    else if (title=="p_{T}^{corr} (GeV/c)")
-      contents[i] = corrpt;
-    else if (title=="A_{jet}")
-      contents[i] = area;
-    else if (title=="NEF")
-      contents[i] = NEF;
-    else if (title=="Z")
-      contents[i] = z;
-    else if (title=="No. of constituents")
-      contents[i] = n;
-    else if (title=="p_{T,particle}^{leading} (GeV/c)")
-      contents[i] = leadingpt;
-    else 
-      AliWarning(Form("Unable to fill dimension %s!",title.Data()));
+  if (fHistoType == 0) {
+    fHistJetPtEtaPhi[fCentBin]->Fill(pt,eta,phi);
+    fHistJetPtArea[fCentBin]->Fill(pt,area);
+    fHistJetPtEP[fCentBin]->Fill(pt,ep);
+    fHistJetPtNEF[fCentBin]->Fill(pt,NEF);
+    fHistJetPtZ[fCentBin]->Fill(pt,z);
+    fHistJetPtLeadingPartPt[fCentBin]->Fill(pt,leadingpt);
+    if (!fRhoName.IsNull()) {
+      fHistJetCorrPtEtaPhi[fCentBin]->Fill(corrpt,eta,phi);
+      fHistJetCorrPtArea[fCentBin]->Fill(corrpt,area);
+      fHistJetCorrPtEP[fCentBin]->Fill(corrpt,ep);
+      fHistJetCorrPtNEF[fCentBin]->Fill(corrpt,NEF);
+      fHistJetCorrPtZ[fCentBin]->Fill(corrpt,z);
+      fHistJetCorrPtLeadingPartPt[fCentBin]->Fill(corrpt,leadingpt);
+      fHistJetPtCorrPt[fCentBin]->Fill(pt,corrpt);
+      if (fIsEmbedded)
+       fHistJetMCPtCorrPt[fCentBin]->Fill(MCpt,corrpt);
+    }
+    if (fIsEmbedded)
+      fHistJetPtMCPt[fCentBin]->Fill(pt,MCpt);
   }
+  else {
+    Double_t contents[20]={0};
+
+    for (Int_t i = 0; i < fHistJetObservables->GetNdimensions(); i++) {
+      TString title(fHistJetObservables->GetAxis(i)->GetTitle());
+      if (title=="Centrality (%)")
+       contents[i] = cent;
+      else if (title=="#phi_{jet} - #psi_{RP}")
+       contents[i] = ep;
+      else if (title=="#eta")
+       contents[i] = eta;
+      else if (title=="#phi_{jet} (rad)")
+       contents[i] = phi;
+      else if (title=="p_{T} (GeV/c)")
+       contents[i] = pt;
+      else if (title=="p_{T}^{MC} (GeV/c)")
+       contents[i] = MCpt;
+      else if (title=="p_{T}^{corr} (GeV/c)")
+       contents[i] = corrpt;
+      else if (title=="A_{jet}")
+       contents[i] = area;
+      else if (title=="NEF")
+       contents[i] = NEF;
+      else if (title=="Z")
+       contents[i] = z;
+      else if (title=="No. of constituents")
+       contents[i] = n;
+      else if (title=="p_{T,particle}^{leading} (GeV/c)")
+       contents[i] = leadingpt;
+      else 
+       AliWarning(Form("Unable to fill dimension %s!",title.Data()));
+    }
 
-  fHistJetObservables->Fill(contents);
+    fHistJetObservables->Fill(contents);
+  }
 }
index 46a7b38..d9ce489 100644 (file)
@@ -3,11 +3,11 @@
 
 // $Id$
 
-#include <TH3F.h>
-
 class TH2;
 class THnSparse;
 
+#include <TH3F.h>
+
 #include "AliAnalysisTaskEmcalJet.h"
 
 class AliAnalysisTaskSAJF : public AliAnalysisTaskEmcalJet {
@@ -19,22 +19,47 @@ class AliAnalysisTaskSAJF : public AliAnalysisTaskEmcalJet {
 
   void                        UserCreateOutputObjects();
 
+  void                        SetHistoType(Int_t t) { fHistoType = t; }
+
  protected:
-  Bool_t                      FillHistograms()                                              ;
+  void                        AllocateTHX();
+  void                        AllocateTHnSparse();
+
+  Bool_t                      FillHistograms();
   void                        FillJetHisto(Double_t cent, Double_t ep, Double_t eta, Double_t phi, Double_t pt, Double_t MCpt, Double_t corrpt, Double_t area, 
                                           Double_t NEF, Double_t z, Int_t n, Double_t leadingpt);
 
+  Int_t                       fHistoType;                      // histogram type (0=TH2, 1=THnSparse)
+
   // Inclusive jets histograms
-  THnSparse                  *fHistJetObservables;         //!Jet-wise observables
-  TH2                        *fHistTracksJetPt[4];         //!Track pt vs. jet pt
-  TH2                        *fHistClustersJetPt[4];       //!Cluster pt vs. jet pt
-  TH2                        *fHistTracksPtDist[4];        //!Track pt vs. distance form jet axis
-  TH2                        *fHistClustersPtDist[4];      //!Cluster pt vs. distance form jet axis
+  THnSparse                  *fHistJetObservables;             //!Jet-wise observables
+
+  // TH2/TH3 versions
+  TH3                        *fHistJetPtEtaPhi[4];             //!Jet Pt vs. Eta vs. Phi
+  TH2                        *fHistJetPtArea[4];               //!Jet Pt vs. Area
+  TH2                        *fHistJetPtEP[4];                 //!Jet Pt vs. event plane
+  TH2                        *fHistJetPtNEF[4];                //!Jet Pt vs. neutral energy fraction
+  TH2                        *fHistJetPtZ[4];                  //!Jet Pt vs. z
+  TH2                        *fHistJetPtLeadingPartPt[4];      //!Jet Pt vs. leading particle pt
+  TH3                        *fHistJetCorrPtEtaPhi[4];         //!Jet corrPt vs. Eta vs. Phi
+  TH2                        *fHistJetCorrPtArea[4];           //!Jet corrPt vs. Area
+  TH2                        *fHistJetCorrPtEP[4];             //!Jet corrPt vs. event plane
+  TH2                        *fHistJetCorrPtNEF[4];            //!Jet corrPt vs. neutral energy fraction
+  TH2                        *fHistJetCorrPtZ[4];              //!Jet corrPt vs. z
+  TH2                        *fHistJetCorrPtLeadingPartPt[4];  //!Jet corrPt vs. leading particle pt
+  TH2                        *fHistJetPtCorrPt[4];             //!Jet Pt vs. corrPt
+  TH2                        *fHistJetPtMCPt[4];               //!Jet Pt vs. MCPt
+  TH2                        *fHistJetMCPtCorrPt[4];           //!Jet MCPt vs. corrPt
+
+  TH2                        *fHistTracksJetPt[4];             //!Track pt vs. jet pt
+  TH2                        *fHistClustersJetPt[4];           //!Cluster pt vs. jet pt
+  TH2                        *fHistTracksPtDist[4];            //!Track pt vs. distance form jet axis
+  TH2                        *fHistClustersPtDist[4];          //!Cluster pt vs. distance form jet axis
 
  private:
   AliAnalysisTaskSAJF(const AliAnalysisTaskSAJF&);            // not implemented
   AliAnalysisTaskSAJF &operator=(const AliAnalysisTaskSAJF&); // not implemented
 
-  ClassDef(AliAnalysisTaskSAJF, 15) // jet analysis task
+  ClassDef(AliAnalysisTaskSAJF, 16) // jet analysis task
 };
 #endif
index b37b1f3..07dd352 100644 (file)
@@ -31,6 +31,7 @@
 #pragma link C++ class AliRhoParameter+;
 #pragma link C++ class AliLocalRhoParameter+;
 #pragma link C++ class AliEmcalJetFinder+;
+#pragma link C++ class AliJetTriggerSelectionTask+;
 
 // user tasks
 #pragma link C++ class AliAnalysisTaskCLQA+;