updates from Salvatore
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 10 Mar 2013 19:33:50 +0000 (19:33 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 10 Mar 2013 19:33:50 +0000 (19:33 +0000)
PWGJE/EMCALJetTasks/AliJetConstituentTagCopier.cxx
PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx
PWGJE/EMCALJetTasks/AliJetEmbeddingFromAODTask.h
PWGJE/EMCALJetTasks/AliJetEmbeddingFromPYTHIATask.cxx
PWGJE/EMCALJetTasks/AliJetModelBaseTask.cxx
PWGJE/EMCALJetTasks/AliJetModelBaseTask.h
PWGJE/EMCALJetTasks/AliJetResponseMaker.cxx
PWGJE/EMCALJetTasks/AliJetResponseMaker.h
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskSAQA.cxx
PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskSAQA.h
PWGJE/EMCALJetTasks/macros/AddTaskJetEmbeddingFromPYTHIA.C

index a34b999..a1986f0 100644 (file)
@@ -8,6 +8,7 @@
 
 #include <TClonesArray.h>
 #include <TMath.h>
+#include <TLorentzVector.h>
 
 #include "AliNamedArrayI.h"
 #include "AliVCluster.h"
@@ -64,7 +65,7 @@ void AliJetConstituentTagCopier::ExecOnce()
   if (!fMCParticlesMap) {
     fMCParticlesMap = dynamic_cast<AliNamedArrayI*>(InputEvent()->FindListObject(fMCParticlesName + "_Map"));
     // this is needed to map the MC labels with the indexes of the MC particle collection
-      // if teh map is not given, the MC labels are assumed to be consistent with the indexes (which is not the case if AliEmcalMCTrackSelector is used)
+    // if teh map is not given, the MC labels are assumed to be consistent with the indexes (which is not the case if AliEmcalMCTrackSelector is used)
     if (!fMCParticlesMap) {
       AliWarning(Form("%s: Could not retrieve map for MC particles %s! Will assume MC labels consistent with indexes...", GetName(), fMCParticlesName.Data())); 
       fMCParticlesMap = new AliNamedArrayI("tracksMap",9999);
@@ -104,6 +105,7 @@ Bool_t AliJetConstituentTagCopier::Run()
 //________________________________________________________________________
 void AliJetConstituentTagCopier::DoClusterLoop(TClonesArray *array)
 {
+  Double_t totalEnergy = 0;
   for (Int_t i = 0; i < array->GetEntries(); i++) {
     AliVCluster *cluster = static_cast<AliVCluster*>(array->At(i));
     if (!cluster) {
@@ -114,6 +116,11 @@ void AliJetConstituentTagCopier::DoClusterLoop(TClonesArray *array)
       continue;
     Int_t mcLabel = cluster->GetLabel();
     if (mcLabel > 0) {
+      TLorentzVector vect;
+      cluster->GetMomentum(vect, fVertex);
+      AliDebug(2, Form("Cluster %d, pt = %f, eta = %f, phi = %f, label = %d",
+                      i, cluster->E(), vect.Eta(), vect.Phi(), mcLabel));
+      totalEnergy += cluster->E();
       Int_t index = -1;
       if (mcLabel < fMCParticlesMap->GetSize())
        index = fMCParticlesMap->At(mcLabel);
@@ -123,11 +130,16 @@ void AliJetConstituentTagCopier::DoClusterLoop(TClonesArray *array)
       if (!part) {
        AliError(Form("%s: Could not get MC particle %d", GetName(), index));
        continue;
-      }
+      }      
+      AliDebug(2, Form("Matched with particle %d, pt = %f, eta = %f, phi = %f", 
+                      index, part->E(), part->Eta(), part->Phi()));
       UInt_t bits = (UInt_t)part->TestBits(TObject::kBitMask);
       cluster->SetBit(bits);
     }
   }
+
+  AliDebug(2, Form("Total energy of MC clusters = %f", 
+                  totalEnergy));
 }
 
 //________________________________________________________________________
@@ -153,7 +165,7 @@ void AliJetConstituentTagCopier::DoTrackLoop(TClonesArray *array)
        AliError(Form("%s: Could not get MC particle %d", GetName(), index));
        continue;
       }
-      AliDebug(2, Form("Track %d, pt = %f, eta = %f, phi = %f, label = %d is matched with particle %d, pt = %f, eta = %f, phi = %f", 
+      AliDebug(3, Form("Track %d, pt = %f, eta = %f, phi = %f, label = %d is matched with particle %d, pt = %f, eta = %f, phi = %f", 
                       i, track->Pt(), track->Eta(), track->Phi(), mcLabel, index, part->Pt(), part->Eta(), part->Phi()));
       UInt_t bits = (UInt_t)part->TestBits(TObject::kBitMask);
       track->SetBit(bits);
index cecbefd..f9a78c5 100644 (file)
@@ -6,6 +6,10 @@
 
 #include "AliJetEmbeddingFromAODTask.h"
 
+// C++ standard library
+#include <vector>
+
+// ROOT
 #include <TFile.h>
 #include <TTree.h>
 #include <TClonesArray.h>
@@ -17,7 +21,9 @@
 #include <TStreamerInfo.h>
 #include <TRandom.h>
 #include <TSystem.h>
+#include <TLorentzVector.h>
 
+// AliRoot
 #include "AliVEvent.h"
 #include "AliAODTrack.h"
 #include "AliESDtrack.h"
@@ -30,6 +36,7 @@
 #include "AliVHeader.h"
 #include "AliVVertex.h"
 #include "AliAODHeader.h"
+#include "AliFJWrapper.h"
 #include "AliLog.h"
 #include "AliInputEventHandler.h"
 
@@ -51,10 +58,19 @@ AliJetEmbeddingFromAODTask::AliJetEmbeddingFromAODTask() :
   fMaxCentrality(10),
   fTriggerMask(AliVEvent::kAny),
   fZVertexCut(10),
+  fJetMinPt(0),
+  fJetMinEta(-0.5),
+  fJetMaxEta(0.5),
+  fJetMinPhi(-999),
+  fJetMaxPhi(999),
+  fJetRadius(0.4),
+  fJetType(0),
+  fJetAlgo(1),
+  fJetParticleLevel(kTRUE),
   fIncludeNoITS(kTRUE),
   fUseNegativeLabels(kTRUE),
   fTrackEfficiency(1),
-  fIsMC(kFALSE),
+  fIsAODMC(kFALSE),
   fTotalFiles(2050),
   fAttempts(5),
   fEsdTreeMode(kFALSE),
@@ -104,10 +120,19 @@ AliJetEmbeddingFromAODTask::AliJetEmbeddingFromAODTask(const char *name, Bool_t
   fMaxCentrality(10),
   fTriggerMask(AliVEvent::kAny),
   fZVertexCut(10),
+  fJetMinPt(0),
+  fJetMinEta(-0.5),
+  fJetMaxEta(0.5),
+  fJetMinPhi(-999),
+  fJetMaxPhi(999),
+  fJetRadius(0.4),
+  fJetType(0),
+  fJetAlgo(1),
+  fJetParticleLevel(kTRUE),
   fIncludeNoITS(kTRUE),
   fUseNegativeLabels(kTRUE),
   fTrackEfficiency(1),
-  fIsMC(kFALSE),
+  fIsAODMC(kFALSE),
   fTotalFiles(2050),
   fAttempts(5),
   fEsdTreeMode(kFALSE),
@@ -276,7 +301,7 @@ Bool_t AliJetEmbeddingFromAODTask::OpenNextFile()
   else
     fCurrentAODEntry = 0;
 
-  AliDebug(2,Form("Will start embedding from entry %d", fCurrentAODEntry));
+  AliDebug(3,Form("Will start embedding from entry %d", fCurrentAODEntry));
   
   if (fHistFileMatching)
     fHistFileMatching->Fill(fCurrentFileID, fCurrentAODFileID-1);
@@ -300,6 +325,11 @@ TFile* AliJetEmbeddingFromAODTask::GetNextFile()
   TObjString *objFileName = static_cast<TObjString*>(fFileList->At(fCurrentAODFileID));
   TString fileName(objFileName->GetString());
 
+  if (fileName.BeginsWith("alien://") && !gGrid) {
+    AliInfo("Trying to connect to AliEn ...");
+    TGrid::Connect("alien://");
+  }
+
   TString baseFileName(fileName);
   if (baseFileName.Contains(".zip#")) {
     Ssiz_t pos = baseFileName.Last('#');
@@ -346,37 +376,70 @@ Bool_t AliJetEmbeddingFromAODTask::GetNextEntry()
 //________________________________________________________________________
 Bool_t AliJetEmbeddingFromAODTask::IsAODEventSelected()
 {
+  // AOD event selection.
+  
   if (!fEsdTreeMode && fAODHeader) {
     AliAODHeader *aodHeader = static_cast<AliAODHeader*>(fAODHeader);
 
+    // Trigger selection
     if (fTriggerMask != AliVEvent::kAny) {
       UInt_t offlineTrigger = aodHeader->GetOfflineTrigger();
       
       if ((offlineTrigger & fTriggerMask) == 0) {
-       AliDebug(2,Form("Event rejected due to physics selection. Event trigger mask: %d, trigger mask selection: %d.", offlineTrigger, fTriggerMask));
+       AliDebug(2,Form("Event rejected due to physics selection. Event trigger mask: %d, trigger mask selection: %d.", 
+                       offlineTrigger, fTriggerMask));
        return kFALSE;
       }
     }
     
+    // Centrality selection
     if (fMinCentrality >= 0) {
       AliCentrality *cent = aodHeader->GetCentralityP();
       Float_t centVal = cent->GetCentralityPercentile("V0M");
       if (centVal < fMinCentrality || centVal >= fMaxCentrality) {
-       AliDebug(2,Form("Event rejected due to centrality selection. Event centrality: %f, centrality range selection: %f to %f", centVal, fMinCentrality, fMaxCentrality));
+       AliDebug(2,Form("Event rejected due to centrality selection. Event centrality: %f, centrality range selection: %f to %f", 
+                       centVal, fMinCentrality, fMaxCentrality));
        return kFALSE;
       }
     }
   }
 
+  // Vertex selection
   if (fAODVertex) {
     Double_t vert[3]={0};
     ((AliVVertex*)fAODVertex->At(0))->GetXYZ(vert);
     if (TMath::Abs(vert[2]) > fZVertexCut) {
-      AliDebug(2,Form("Event rejected due to Z vertex selection. Event Z vertex: %f, Z vertex cut: %f", vert[2], fZVertexCut));
+      AliDebug(2,Form("Event rejected due to Z vertex selection. Event Z vertex: %f, Z vertex cut: %f", 
+                     vert[2], fZVertexCut));
       return kFALSE;
     }
   }
 
+  // Jet selection
+  if (fJetMinPt > 0) {
+    TLorentzVector jet;
+
+    if (fJetParticleLevel) {
+      if (fAODMCParticles)
+       jet = GetLeadingJet(fAODMCParticles);
+      else {
+       AliWarning("Particle level jets selected, but not MC particles found. The jet event selection will be skipped.");
+       return kTRUE;
+      }
+    }
+    else {
+      if (fAODTracks || fAODClusters) 
+       jet = GetLeadingJet(fAODTracks, fAODClusters);
+      else {
+       AliWarning("Detector level jets selected, but not tracks or clusters found. The jet event selection will be skipped.");
+       return kTRUE;
+      }
+    }
+    
+    if (jet.Pt() < fJetMinPt)
+      return kFALSE;
+  }
+
   return kTRUE;
 }
 
@@ -401,7 +464,7 @@ void AliJetEmbeddingFromAODTask::Run()
       CopyMCParticles();
 
     if (fAODMCParticles) {
-      AliDebug(2, Form("%d MC particles will be processed for embedding.", fAODMCParticles->GetEntriesFast()));
+      AliDebug(3, Form("%d MC particles will be processed for embedding.", fAODMCParticles->GetEntriesFast()));
       for (Int_t i = 0; i < fAODMCParticles->GetEntriesFast(); i++) {
        AliAODMCParticle *part = static_cast<AliAODMCParticle*>(fAODMCParticles->At(i));
        if (!part) {
@@ -430,10 +493,10 @@ void AliJetEmbeddingFromAODTask::Run()
     if (fCopyArray && fTracks)
       CopyTracks();
 
-    AliDebug(2, Form("Start embedding with %d tracks.", fOutTracks->GetEntriesFast()));
+    AliDebug(3, Form("Start embedding with %d tracks.", fOutTracks->GetEntriesFast()));
 
     if (fAODTracks) {
-      AliDebug(2, Form("%d tracks will be processed for embedding.", fAODTracks->GetEntriesFast()));
+      AliDebug(3, Form("%d tracks will be processed for embedding.", fAODTracks->GetEntriesFast()));
       for (Int_t i = 0; i < fAODTracks->GetEntriesFast(); i++) {
        AliVTrack *track = static_cast<AliVTrack*>(fAODTracks->At(i));
        if (!track) {
@@ -496,20 +559,18 @@ void AliJetEmbeddingFromAODTask::Run()
          if (fTrackEfficiency < r) {
            AliDebug(3, "Track not embedded because of artificial inefiiciency.");
            continue;
-       }
+         }
        }
        
        Int_t label = 0;
-       if (fIsMC) {
+       if (fIsAODMC) {
          if (fUseNegativeLabels)
            label = track->GetLabel();
          else 
            label = TMath::Abs(track->GetLabel());
          
-         if (label == 0) {
-           AliDebug(2,Form("%s: Track %d with label==0", GetName(), i));
-           label = 99999;
-         }
+         if (label == 0) 
+           AliWarning(Form("%s: Track %d with label==0", GetName(), i));
        }
 
        AddTrack(track->Pt(), track->Eta(), track->Phi(), type, track->GetTrackEtaOnEMCal(), track->GetTrackPhiOnEMCal(), isEmc, label);
@@ -539,6 +600,13 @@ void AliJetEmbeddingFromAODTask::Run()
            vect.Phi() < fPhiMin || vect.Phi() > fPhiMax)
          continue;
 
+       Int_t label = 0;
+       if (fIsAODMC) {
+         label = clus->GetLabel();
+         if (label <= 0) 
+           AliDebug(3,Form("%s: Clus %d with label<=0", GetName(), i));
+       }
+
        AddCluster(clus->E(), vect.Eta(), vect.Phi(), clus->GetLabel());
       }
     }
@@ -546,6 +614,7 @@ void AliJetEmbeddingFromAODTask::Run()
 
   if (fOutCaloCells) {
 
+    Double_t totalEnergy = 0;
     Int_t totalCells = 0;
 
     if (fCaloCells)
@@ -567,11 +636,108 @@ void AliJetEmbeddingFromAODTask::Run()
        Double_t amp = -1;
        
        fAODCaloCells->GetCell(i, cellNum, amp, time, mclabel, efrac);
-       AliDebug(3,Form("Adding cell with amplitude %f, absolute ID %d, time %f", amp, cellNum, time));
+
+       if (fIsAODMC) {
+         if (mclabel <= 0) 
+           AliDebug(3,Form("%s: Cell %d with label<=0", GetName(), i));
+       }
+       else {
+         mclabel = 0;
+       }
+
+       AliDebug(2,Form("Adding cell with amplitude %f, absolute ID %d, time %f, mc label %d", amp, cellNum, time, mclabel));
        AddCell(amp, cellNum, time, mclabel);
+       totalEnergy += amp;
       }
     }
 
-    AliDebug(2,Form("Added cells = %d, total cells = %d", fAddedCells, totalCells));
+    AliDebug(2,Form("Added cells = %d (energy = %f), total cells = %d", fAddedCells, totalEnergy, totalCells));
   }
 }
+
+//________________________________________________________________________
+TLorentzVector AliJetEmbeddingFromAODTask::GetLeadingJet(TClonesArray *tracks, TClonesArray *clusters)
+{
+  TString name("kt");
+  fastjet::JetAlgorithm jalgo(fastjet::kt_algorithm);
+  if (fJetAlgo == 1) {
+    name  = "antikt";
+    jalgo = fastjet::antikt_algorithm;
+  }
+
+  // setup fj wrapper
+  AliFJWrapper fjw(name, name);
+  fjw.SetAreaType(fastjet::active_area_explicit_ghosts);
+  fjw.SetGhostArea(1);  // set a very large ghost area to speed up jet finding
+  fjw.SetR(fJetRadius);
+  fjw.SetAlgorithm(jalgo);  
+  fjw.SetMaxRap(1);
+  fjw.Clear();
+
+  if (tracks) {
+    const Int_t Ntracks = tracks->GetEntries();
+    for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
+      AliVParticle *t = static_cast<AliVParticle*>(tracks->At(iTracks));
+      if (!t)
+        continue;
+      
+      if ((fJetType == 1 && t->Charge() == 0) ||
+         (fJetType == 2 && t->Charge() != 0))
+       continue;
+
+      // TODO: Minimum track pt
+
+      if (t->Pt() <= 0)
+       continue;
+
+      fjw.AddInputVector(t->Px(), t->Py(), t->Pz(), t->P(), iTracks + 100);  
+    }
+  }
+
+  if (clusters && fJetType != 1) {
+    Double_t vert[3]={0};
+    if (fAODVertex) 
+      ((AliVVertex*)fAODVertex->At(0))->GetXYZ(vert);
+
+    const Int_t Nclus = clusters->GetEntries();
+    for (Int_t iClus = 0; iClus < Nclus; ++iClus) {
+      AliVCluster *c = static_cast<AliVCluster*>(clusters->At(iClus));
+      if (!c)
+       continue;
+
+      if (!c->IsEMCAL())
+       continue;
+      
+      TLorentzVector nP;
+      c->GetMomentum(nP, vert);
+
+      // TODO: Minimum cluster et
+
+      if (nP.Pt() <= 0)
+       continue;
+
+      fjw.AddInputVector(nP.Px(), nP.Py(), nP.Pz(), nP.P(), -iClus - 100);
+    }
+  }
+  
+  // run jet finder
+  fjw.Run();
+
+  std::vector<fastjet::PseudoJet> jets_incl = fjw.GetInclusiveJets();
+  AliDebug(1,Form("%d jets found", (Int_t)jets_incl.size()));
+
+  TLorentzVector jet;
+
+  Int_t njets = jets_incl.size();
+
+  if (njets > 0) {
+    std::vector<fastjet::PseudoJet> jets_incl_sorted = fastjet::sorted_by_pt(jets_incl);
+    for (Int_t i = 0; i < njets; i++) {
+      jet.SetPxPyPzE(jets_incl_sorted[i].px(), jets_incl_sorted[i].py(), jets_incl_sorted[i].pz(), jets_incl_sorted[i].E());
+      if (jet.Eta() > fJetMinEta && jet.Eta() < fJetMaxEta && jet.Phi() > fJetMinPhi && jet.Phi() < fJetMaxPhi)
+       break;
+    }
+  }
+
+  return jet;
+}
index 05249c7..57a2019 100644 (file)
@@ -11,6 +11,7 @@ class AliVCaloCells;
 class AliVHeader;
 class TH2;
 class TH1;
+class TLorentzVector;
 
 #include "AliJetModelBaseTask.h"
 
@@ -39,7 +40,12 @@ class AliJetEmbeddingFromAODTask : public AliJetModelBaseTask {
   void           SetTotalFiles(Int_t n)                            { fTotalFiles         = n     ; }
   void           SetAttempts(Int_t n)                              { fAttempts           = n     ; }
   void           SetRandomAccess(Bool_t r=kTRUE)                   { fRandomAccess       = r     ; }
-  void           SetMC(Bool_t a)                                   { fIsMC               = a     ; }
+  void           SetAODMC(Bool_t a)                                { fIsAODMC            = a     ; }
+  void           SetJetMinPt(Double_t pt)                          { fJetMinPt           = pt    ; }
+  void           SetJetEtaRange(Double_t emi, Double_t ema)        { fJetMinEta = emi; fJetMaxEta = ema; }
+  void           SetJetPhiRange(Double_t pmi, Double_t pma)        { fJetMinPhi = pmi; fJetMaxPhi = pma; }
+  void           SetJetType(Byte_t t)                              { fJetType            = t     ; }
+  void           SetJetAlgo(Byte_t t)                              { fJetAlgo            = t     ; }
 
  protected:
   Bool_t          ExecOnce()            ;// intialize task
@@ -48,6 +54,7 @@ class AliJetEmbeddingFromAODTask : public AliJetModelBaseTask {
   virtual Bool_t  OpenNextFile()        ;// open next file
   virtual Bool_t  GetNextEntry()        ;// get next entry in current tree
   virtual Bool_t  IsAODEventSelected()  ;// AOD event trigger/centrality selection
+  TLorentzVector  GetLeadingJet(TClonesArray *tracks, TClonesArray *clusters=0);  // get the leading jet
 
   TObjArray     *fFileList            ;//  List of AOD files 
   Bool_t         fRandomAccess        ;//  Random access to file number and event
@@ -62,11 +69,20 @@ class AliJetEmbeddingFromAODTask : public AliJetModelBaseTask {
   Double_t       fMaxCentrality       ;//  Maximum centrality
   UInt_t         fTriggerMask         ;//  Trigger selection mask
   Double_t       fZVertexCut          ;//  Z vertex cut
+  Double_t       fJetMinPt            ;//  Select events with a minimum jet pt
+  Double_t       fJetMinEta           ;//  Min eta for jets
+  Double_t       fJetMaxEta           ;//  Max eta for jets
+  Double_t       fJetMinPhi           ;//  Min phi for jets
+  Double_t       fJetMaxPhi           ;//  Max phi for jets
+  Double_t       fJetRadius           ;//  Jet radius
+  Byte_t         fJetType             ;//  Jet type (0=full, 1=charged, 2=neutral)
+  Byte_t         fJetAlgo             ;//  Jet algorithm (0=kT, 1=anti-kT)
+  Bool_t         fJetParticleLevel    ;//  Trigger, look at particle level jets
   Int_t          fAODfilterBits[2]    ;//  AOD track filter bit map
   Bool_t         fIncludeNoITS        ;//  True = includes tracks with failed ITS refit
   Bool_t         fUseNegativeLabels   ;//  Whether or not should use negative MC labels
   Double_t       fTrackEfficiency     ;//  Track efficiency
-  Bool_t         fIsMC                ;//  Whether the embedding AOD is MC or not
+  Bool_t         fIsAODMC             ;//  Whether the embedding AOD is MC or not
   Int_t          fTotalFiles          ;//  Total number of files per pt hard bin
   Int_t          fAttempts            ;//  Attempts to be tried before giving up in opening the next file
   Bool_t         fEsdTreeMode         ;//! True = embed from ESD (must be a skimmed ESD!)
@@ -91,6 +107,6 @@ class AliJetEmbeddingFromAODTask : public AliJetModelBaseTask {
   AliJetEmbeddingFromAODTask(const AliJetEmbeddingFromAODTask&);            // not implemented
   AliJetEmbeddingFromAODTask &operator=(const AliJetEmbeddingFromAODTask&); // not implemented
 
-  ClassDef(AliJetEmbeddingFromAODTask, 5) // Jet embedding from AOD task
+  ClassDef(AliJetEmbeddingFromAODTask, 7) // Jet embedding from AOD task
 };
 #endif
index b0ba3a0..0d14576 100644 (file)
 #include <TString.h>
 #include <TRandom.h>
 #include <TParameter.h>
-#include <TSystem.h>
 #include <TH1I.h>
 #include <TGrid.h>
 #include <THashTable.h>
+#include <TSystem.h>
 
 #include "AliVEvent.h"
 #include "AliLog.h"
@@ -38,7 +38,7 @@ AliJetEmbeddingFromPYTHIATask::AliJetEmbeddingFromPYTHIATask() :
   SetSuffix("PYTHIAEmbedding");
   fTotalFiles = 2000;
   fRandomAccess = kTRUE;
-  SetMC(kTRUE);
+  SetAODMC(kTRUE);
 }
 
 //________________________________________________________________________
@@ -58,7 +58,7 @@ AliJetEmbeddingFromPYTHIATask::AliJetEmbeddingFromPYTHIATask(const char *name, B
   SetSuffix("PYTHIAEmbedding");
   fTotalFiles = 2000;
   fRandomAccess = kTRUE;
-  SetMC(kTRUE);
+  SetAODMC(kTRUE);
 }
 
 //________________________________________________________________________
@@ -116,7 +116,7 @@ Bool_t AliJetEmbeddingFromPYTHIATask::ExecOnce()
   fPtHardBinParam = static_cast<TParameter<int>*>(InputEvent()->FindListObject("PYTHIAPtHardBin"));
   if (!fPtHardBinParam) {
     fPtHardBinParam = new TParameter<int>("PYTHIAPtHardBin", 0);
-    AliDebug(2,"Adding pt hard bin param object to the event list...");
+    AliDebug(3,"Adding pt hard bin param object to the event list...");
     InputEvent()->AddObject(fPtHardBinParam);
   }
 
@@ -217,6 +217,17 @@ TFile* AliJetEmbeddingFromPYTHIATask::GetNextFile()
     TGrid::Connect("alien://");
   }
 
+  TString baseFileName(fileName);
+  if (baseFileName.Contains(".zip#")) {
+    Ssiz_t pos = baseFileName.Last('#');
+    baseFileName.Remove(pos);
+  }
+  
+  if (gSystem->AccessPathName(baseFileName)) {
+    AliDebug(3,Form("File %s does not exist!", baseFileName.Data()));
+    return 0;
+  }
+
   AliDebug(3,Form("Trying to open file %s...", fileName.Data()));
   TFile *file = TFile::Open(fileName);
 
index a908057..878ff91 100644 (file)
@@ -41,6 +41,7 @@ AliJetModelBaseTask::AliJetModelBaseTask() :
   fOutCellsName(),
   fMCParticlesName(),
   fOutMCParticlesName(),
+  fIsMC(kFALSE),
   fSuffix(),
   fEtaMin(-1),
   fEtaMax(1),
@@ -87,6 +88,7 @@ AliJetModelBaseTask::AliJetModelBaseTask(const char *name, Bool_t drawqa) :
   fOutCellsName(""),
   fMCParticlesName(""),
   fOutMCParticlesName(""),
+  fIsMC(kFALSE),
   fSuffix("Processed"),
   fEtaMin(-1),
   fEtaMax(1),
@@ -167,7 +169,7 @@ void AliJetModelBaseTask::UserExec(Option_t *)
   
   // Clear map
   if (fOutMCParticlesMap)
-  fOutMCParticlesMap->Clear();
+    fOutMCParticlesMap->Clear();
 
   AliVCaloCells *tempCaloCells = 0;
 
@@ -375,11 +377,11 @@ Bool_t AliJetModelBaseTask::ExecOnce()
        return kFALSE;
       }
     } else {
-       fGeom = AliEMCALGeometry::GetInstance();
-       if (!fGeom) {
-         AliFatal("Could not get default geometry!");
-         return kFALSE;
-       }
+      fGeom = AliEMCALGeometry::GetInstance();
+      if (!fGeom) {
+       AliFatal("Could not get default geometry!");
+       return kFALSE;
+      }
     }
   }
 
@@ -403,28 +405,6 @@ Int_t AliJetModelBaseTask::SetNumberOfOutCells(Int_t n)
 }
 
 //________________________________________________________________________
-void AliJetModelBaseTask::CopyCells()
-{
-  if (!fCaloCells)
-    return;
-
-  for (Short_t i = 0; i < fCaloCells->GetNumberOfCells(); i++) {
-    Int_t mclabel = 0;
-    Double_t efrac = 0.;
-    Double_t time = -1;
-    Short_t cellNum = -1;
-    Double_t amp = -1;
-
-    fCaloCells->GetCell(i, cellNum, amp, time, mclabel, efrac);
-    fOutCaloCells->SetCell(i, cellNum, amp, time, mclabel, efrac);
-  }
-
-  fAddedCells = fCaloCells->GetNumberOfCells();
-
-  AliDebug(2, Form("%d cells from the current event", fAddedCells));
-}
-
-//________________________________________________________________________
 Int_t AliJetModelBaseTask::AddCell(Double_t e, Double_t eta, Double_t phi)
 {
   // Add a cell to the event.
@@ -464,15 +444,40 @@ Int_t AliJetModelBaseTask::AddCell(Double_t e, Int_t absId, Double_t time, Int_t
   else
     label += fMCLabelShift;
 
-  Bool_t r = fOutCaloCells->SetCell(fAddedCells, absId, e, time, label, 0);
+  Short_t pos = fOutCaloCells->GetCellPosition(absId);
+  Double_t efrac = 1;
+  Bool_t increaseOnSuccess = kFALSE;
+
+  if (pos < 0) {
+    increaseOnSuccess = kTRUE;
+    pos = fAddedCells;
+  }
+  else {
+    Short_t cellNumber = -1;
+    Double_t old_e = 0;
+    Double_t old_time = 0;
+    Int_t old_label = 0;
+    Double_t old_efrac = 0;
+    fOutCaloCells->GetCell(pos, cellNumber, old_e, old_time, old_label, old_efrac);
+    
+    if (e / (old_e + e) < old_efrac) {
+      label = old_label;
+      time = old_time;
+    }
+    
+    efrac = (e + old_e * old_efrac) / (e + old_e);
+    e += old_e;
+  }
+
+  Bool_t r = fOutCaloCells->SetCell(pos, absId, e, time, label, efrac);
 
   if (r) {
-    fAddedCells++;
+    if (increaseOnSuccess)
+      fAddedCells++;
     return fAddedCells;
   }
-  else {
+  else 
     return 0;
-  }
 }
 
 
@@ -608,6 +613,32 @@ AliAODMCParticle* AliJetModelBaseTask::AddMCParticle(AliAODMCParticle *part, Int
 }
 
 //________________________________________________________________________
+void AliJetModelBaseTask::CopyCells()
+{
+  if (!fCaloCells)
+    return;
+
+  for (Short_t i = 0; i < fCaloCells->GetNumberOfCells(); i++) {
+    Int_t mclabel = 0;
+    Double_t efrac = 0.;
+    Double_t time = -1;
+    Short_t cellNum = -1;
+    Double_t amp = -1;
+
+    fCaloCells->GetCell(i, cellNum, amp, time, mclabel, efrac);
+
+    if (!fIsMC) 
+      mclabel = 0;
+
+    fOutCaloCells->SetCell(i, cellNum, amp, time, mclabel, efrac);
+  }
+
+  fAddedCells = fCaloCells->GetNumberOfCells();
+
+  AliDebug(2, Form("%d cells from the current event", fAddedCells));
+}
+
+//________________________________________________________________________
 void AliJetModelBaseTask::CopyClusters()
 {
   // Copy all the clusters in the new collection
@@ -622,7 +653,12 @@ void AliJetModelBaseTask::CopyClusters()
       AliESDCaloCluster *esdcluster = static_cast<AliESDCaloCluster*>(fClusters->At(i));
       if (!esdcluster || !esdcluster->IsEMCAL())
        continue;
-      new ((*fOutClusters)[nCopiedClusters]) AliESDCaloCluster(*esdcluster);
+      AliESDCaloCluster *clus = new ((*fOutClusters)[nCopiedClusters]) AliESDCaloCluster(*esdcluster);
+      if (!fIsMC) {
+       TArrayI *labels = clus->GetLabelsArray();
+       if (labels)
+         labels->Reset();
+      }
       nCopiedClusters++;
     }
   }
@@ -631,7 +667,9 @@ void AliJetModelBaseTask::CopyClusters()
       AliAODCaloCluster *aodcluster = static_cast<AliAODCaloCluster*>(fClusters->At(i));
       if (!aodcluster || !aodcluster->IsEMCAL())
        continue;
-      new ((*fOutClusters)[nCopiedClusters]) AliAODCaloCluster(*aodcluster);
+      AliAODCaloCluster *clus = new ((*fOutClusters)[nCopiedClusters]) AliAODCaloCluster(*aodcluster);
+      if (!fIsMC) 
+       clus->SetLabel(0,0);
       nCopiedClusters++;
     }
   }
@@ -648,10 +686,12 @@ void AliJetModelBaseTask::CopyTracks()
   const Int_t nTracks = fTracks->GetEntriesFast();
   Int_t nCopiedTracks = 0;
   for (Int_t i = 0; i < nTracks; ++i) {
-    AliPicoTrack *track = static_cast<AliPicoTrack*>(fTracks->At(i));
-    if (!track)
+    AliPicoTrack *picotrack = static_cast<AliPicoTrack*>(fTracks->At(i));
+    if (!picotrack)
       continue;
-    new ((*fOutTracks)[nCopiedTracks]) AliPicoTrack(*track);
+    AliPicoTrack *track = new ((*fOutTracks)[nCopiedTracks]) AliPicoTrack(*picotrack);
+    if (!fIsMC && track->GetLabel() != 0) 
+      track->SetLabel(0);
     nCopiedTracks++;
   }
 }
index 7c13cb2..0ba6f0c 100644 (file)
@@ -33,6 +33,8 @@ class AliJetModelBaseTask : public AliAnalysisTaskSE {
   void                   SetPtSpectrum(TF1 *f)                 { fPtSpectrum   = new TH1F("ptSpectrum","ptSpectrum",250,f->GetXmin(),f->GetXmax()); 
                                                                  fPtSpectrum->Add(f); }
 
+  void                   SetMC(Bool_t a)                       { fIsMC         = a   ; }
+
   void                   SetCopyArray(Bool_t copy)             { fCopyArray    = copy; }
   void                   SetTracksName(const char *n)          { fTracksName   = n;    }
   void                   SetClusName(const char *n)            { fCaloName     = n;    }
@@ -76,6 +78,7 @@ class AliJetModelBaseTask : public AliAnalysisTaskSE {
   TString                fOutCellsName;           // name of output cells collection
   TString                fMCParticlesName;        // name of MC particle collection
   TString                fOutMCParticlesName;     // name of output MC particle collection
+  Bool_t                 fIsMC;                   // whether the current event is MC or not
   TString                fSuffix;                 // suffix to add in the name of new collections
   Float_t                fEtaMin;                 // eta minimum value
   Float_t                fEtaMax;                 // eta maximum value
@@ -90,7 +93,7 @@ class AliJetModelBaseTask : public AliAnalysisTaskSE {
   Int_t                  fMarkMC;                 // which MC label is to be used (default=100)
   TH1                   *fPtSpectrum;             // pt spectrum parametrization to extract random pt values
   Bool_t                 fQAhistos;               // draw QA histograms
-  Bool_t                 fIsInit;                 //=true if initialized
+  Bool_t                 fIsInit;                 //!=true if initialized
   AliEMCALGeometry      *fGeom;                   //!pointer to EMCal geometry
   TClonesArray          *fClusters;               //!cluster collection
   TClonesArray          *fOutClusters;            //!output cluster collection
@@ -111,6 +114,6 @@ class AliJetModelBaseTask : public AliAnalysisTaskSE {
   AliJetModelBaseTask(const AliJetModelBaseTask&);            // not implemented
   AliJetModelBaseTask &operator=(const AliJetModelBaseTask&); // not implemented
 
-  ClassDef(AliJetModelBaseTask, 7) // Jet modelling task
+  ClassDef(AliJetModelBaseTask, 8) // Jet modelling task
 };
 #endif
index de0428b..f6f2c5c 100644 (file)
@@ -47,6 +47,8 @@ AliJetResponseMaker::AliJetResponseMaker() :
   fJet2MinPhi(-999),
   fJet2MaxPhi(-999),
   fSelectPtHardBin(-999),
+  fIsEmbedded(kFALSE),
+  fIsPythia(kTRUE),
   fPythiaHeader(0),
   fPtHardBin(0),
   fNTrials(0),
@@ -103,6 +105,7 @@ AliJetResponseMaker::AliJetResponseMaker() :
   fHistNonMatchedJets2CorrPtArea(0),
   fHistJet1PtvsJet2Pt(0),
   fHistJet1CorrPtvsJet2CorrPt(0),
+  fHistJet1MCPtvsJet2Pt(0),
   fHistMissedJets2PtArea(0)
 {
   // Default constructor.
@@ -129,6 +132,8 @@ AliJetResponseMaker::AliJetResponseMaker(const char *name) :
   fJet2MinPhi(-999),
   fJet2MaxPhi(-999),
   fSelectPtHardBin(-999),
+  fIsEmbedded(kFALSE),
+  fIsPythia(kTRUE),
   fPythiaHeader(0),
   fPtHardBin(0),
   fNTrials(0),
@@ -185,6 +190,7 @@ AliJetResponseMaker::AliJetResponseMaker(const char *name) :
   fHistNonMatchedJets2CorrPtArea(0),
   fHistJet1PtvsJet2Pt(0),
   fHistJet1CorrPtvsJet2CorrPt(0),
+  fHistJet1MCPtvsJet2Pt(0),
   fHistMissedJets2PtArea(0)
 {
   // Standard constructor.
@@ -279,6 +285,9 @@ Bool_t AliJetResponseMaker::PythiaInfoFromFile(const char* currFile, Float_t &fX
 //________________________________________________________________________
 Bool_t AliJetResponseMaker::UserNotify()
 {
+  if (!fIsPythia)
+    return kTRUE;
+
   TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
   if (!tree) {
     AliError(Form("%s - UserNotify: No current tree!",GetName()));
@@ -614,6 +623,14 @@ void AliJetResponseMaker::UserCreateOutputObjects()
     fOutput->Add(fHistJet1CorrPtvsJet2CorrPt);
   }
 
+  if (fIsEmbedded) {
+    fHistJet1MCPtvsJet2Pt = new TH2F("fHistJet1MCPtvsJet2Pt", "fHistJet1MCPtvsJet2Pt", fNbins, fMinBinPt, fMaxBinPt, fNbins, fMinBinPt, fMaxBinPt);
+    fHistJet1MCPtvsJet2Pt->GetXaxis()->SetTitle("p_{T,1}^{MC}");
+    fHistJet1MCPtvsJet2Pt->GetYaxis()->SetTitle("p_{T,2}");
+    fHistJet1MCPtvsJet2Pt->GetZaxis()->SetTitle("counts");
+    fOutput->Add(fHistJet1MCPtvsJet2Pt);
+  }
+
   fHistMissedJets2PtArea = new TH2F("fHistMissedJets2PtArea", "fHistMissedJets2PtArea", 40, 0, fJetRadius * fJetRadius * TMath::Pi() * 3, fNbins, fMinBinPt, fMaxBinPt);
   fHistMissedJets2PtArea->GetXaxis()->SetTitle("area");  
   fHistMissedJets2PtArea->GetYaxis()->SetTitle("p_{T,2} (GeV/c)");
@@ -1299,6 +1316,9 @@ Bool_t AliJetResponseMaker::FillHistograms()
        fHistJet1PtOverJet2PtvsJet1Pt->Fill(jet2->MatchedJet()->Pt(), jet2->MatchedJet()->Pt() / jet2->Pt());
 
        fHistJet1PtvsJet2Pt->Fill(jet2->MatchedJet()->Pt(), jet2->Pt());
+
+       if (fHistJet1MCPtvsJet2Pt)
+         fHistJet1MCPtvsJet2Pt->Fill(jet2->MatchedJet()->MCPt(), jet2->Pt());
        
        if (!fRhoName.IsNull() || !fRho2Name.IsNull()) {
          dpt -= fRhoVal * jet2->MatchedJet()->Area() - fRho2Val * jet2->Area();
index a507568..fb161fe 100644 (file)
@@ -39,6 +39,8 @@ class AliJetResponseMaker : public AliAnalysisTaskEmcalJet {
   void                        SetMatching(MatchingType t, Double_t p1=1, Double_t p2=1)       { fMatching = t; fMatchingPar1 = p1; fMatchingPar2 = p2; }
   void                        SetPtHardBin(Int_t b)                                           { fSelectPtHardBin   = b         ; }
   void                        SetAreMCCollections(Bool_t f1, Bool_t f2)                       { fAreCollections1MC = f1; fAreCollections2MC = f2; }
+  void                        SetIsEmbedded(Bool_t i)                                         { fIsEmbedded        = i         ; }
+  void                        SetIsPythia(Bool_t i)                                           { fIsPythia          = i         ; }
 
  protected:
   Bool_t                      PythiaInfoFromFile(const char* currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard);
@@ -72,6 +74,8 @@ class AliJetResponseMaker : public AliAnalysisTaskEmcalJet {
   Float_t                     fJet2MinPhi;                    // minimum phi jet 2 acceptance
   Float_t                     fJet2MaxPhi;                    // maximum phi jet 2 acceptance  
   Int_t                       fSelectPtHardBin;               // select one pt hard bin for analysis
+  Bool_t                      fIsEmbedded;                    // trigger, embedded signal
+  Bool_t                      fIsPythia;                      // trigger, if it is a PYTHIA production
 
   AliGenPythiaEventHeader    *fPythiaHeader;                  //!event Pythia header
   Int_t                       fPtHardBin;                     //!event pt hard bin
@@ -133,12 +137,14 @@ class AliJetResponseMaker : public AliAnalysisTaskEmcalJet {
   TH2                        *fHistNonMatchedJets2CorrPtArea;          //!non-matched jet pt distribution
   TH2                        *fHistJet1PtvsJet2Pt;                     //!correlation jet 1 pt vs jet 2 pt
   TH2                        *fHistJet1CorrPtvsJet2CorrPt;             //!correlation jet 1 corr pt vs jet 2 corr pt
+  TH2                        *fHistJet1MCPtvsJet2Pt;                   //!correlation jet 1 MC pt vs jet 2 pt
   TH2                        *fHistMissedJets2PtArea;                  //!jets 2 not found in jet 1 collection
 
+
  private:
   AliJetResponseMaker(const AliJetResponseMaker&);            // not implemented
   AliJetResponseMaker &operator=(const AliJetResponseMaker&); // not implemented
 
-  ClassDef(AliJetResponseMaker, 12) // Jet response matrix producing task
+  ClassDef(AliJetResponseMaker, 13) // Jet response matrix producing task
 };
 #endif
index 8e6a7f7..c626c33 100644 (file)
@@ -46,6 +46,8 @@ AliAnalysisTaskSAQA::AliAnalysisTaskSAQA() :
   fHistJetsParts(0),
   fHistCellsCent(0),
   fHistCellsTracks(0),
+  fHistTrNegativeLabels(0),
+  fHistTrZeroLabels(0),
   fHistTrEmcPhiEta(0),
   fHistTrPhiEtaNonProp(0),
   fHistDeltaEtaPt(0),
@@ -62,7 +64,7 @@ AliAnalysisTaskSAQA::AliAnalysisTaskSAQA() :
 
   for (Int_t i = 0; i < 4; i++) {
     for (Int_t j = 0; j < 4; j++) fHistTrPhiEtaPt[i][j] = 0;
-    fHistTrPhiEtaPtNegLab[i] = 0;
+    fHistTrPhiEtaPtZeroLab[i] = 0;
     fHistClusPhiEtaEnergy[i] = 0;
     fHistJetsPhiEtaPt[i] = 0;
     fHistJetsPtArea[i] = 0;
@@ -87,6 +89,8 @@ AliAnalysisTaskSAQA::AliAnalysisTaskSAQA(const char *name) :
   fHistJetsParts(0),
   fHistCellsCent(0),
   fHistCellsTracks(0),
+  fHistTrNegativeLabels(0),
+  fHistTrZeroLabels(0),
   fHistTrEmcPhiEta(0),
   fHistTrPhiEtaNonProp(0),
   fHistDeltaEtaPt(0),
@@ -103,7 +107,7 @@ AliAnalysisTaskSAQA::AliAnalysisTaskSAQA(const char *name) :
 
   for (Int_t i = 0; i < 4; i++) {
     for (Int_t j = 0; j < 4; j++) fHistTrPhiEtaPt[i][j] = 0;
-    fHistTrPhiEtaPtNegLab[i] = 0;
+    fHistTrPhiEtaPtZeroLab[i] = 0;
     fHistClusPhiEtaEnergy[i] = 0;
     fHistJetsPhiEtaPt[i] = 0;
     fHistJetsPtArea[i] = 0;
@@ -126,6 +130,18 @@ void AliAnalysisTaskSAQA::UserCreateOutputObjects()
   AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
 
   if (!fTracksName.IsNull()) {
+    if (!fParticleLevel && fIsMC) {
+      fHistTrNegativeLabels = new TH1F("fHistTrNegativeLabels","fHistTrNegativeLabels", 500, 0, 1);
+      fHistTrNegativeLabels->GetXaxis()->SetTitle("% of negative labels");
+      fHistTrNegativeLabels->GetYaxis()->SetTitle("counts");
+      fOutput->Add(fHistTrNegativeLabels);
+
+      fHistTrZeroLabels = new TH1F("fHistTrZeroLabels","fHistTrZeroLabels", 500, 0, 1);
+      fHistTrZeroLabels->GetXaxis()->SetTitle("% of negative labels");
+      fHistTrZeroLabels->GetYaxis()->SetTitle("counts");
+      fOutput->Add(fHistTrZeroLabels);
+    }
+
     fHistTracksCent = new TH2F("fHistTracksCent","Tracks vs. centrality", 100, 0, 100, fNbins, 0, 4000);
     fHistTracksCent->GetXaxis()->SetTitle("Centrality (%)");
     fHistTracksCent->GetYaxis()->SetTitle("No. of tracks");
@@ -147,12 +163,12 @@ void AliAnalysisTaskSAQA::UserCreateOutputObjects()
        fOutput->Add(fHistTrPhiEtaPt[i][j]);
       }
       if (!fParticleLevel && fIsMC) {
-       histname = Form("fHistTrPhiEtaPtNegLab_%d",i);
-       fHistTrPhiEtaPtNegLab[i] = new TH3F(histname,histname, 100, -1, 1, 201, 0, TMath::Pi() * 2.01, fNbins, fMinBinPt, fMaxBinPt);
-       fHistTrPhiEtaPtNegLab[i]->GetXaxis()->SetTitle("#eta");
-       fHistTrPhiEtaPtNegLab[i]->GetYaxis()->SetTitle("#phi");
-       fHistTrPhiEtaPtNegLab[i]->GetZaxis()->SetTitle("p_{T} (GeV/c)");
-       fOutput->Add(fHistTrPhiEtaPtNegLab[i]);
+       histname = Form("fHistTrPhiEtaPtZeroLab_%d",i);
+       fHistTrPhiEtaPtZeroLab[i] = new TH3F(histname,histname, 100, -1, 1, 201, 0, TMath::Pi() * 2.01, fNbins, fMinBinPt, fMaxBinPt);
+       fHistTrPhiEtaPtZeroLab[i]->GetXaxis()->SetTitle("#eta");
+       fHistTrPhiEtaPtZeroLab[i]->GetYaxis()->SetTitle("#phi");
+       fHistTrPhiEtaPtZeroLab[i]->GetZaxis()->SetTitle("p_{T} (GeV/c)");
+       fOutput->Add(fHistTrPhiEtaPtZeroLab[i]);
       }
     }
 
@@ -485,9 +501,8 @@ Float_t AliAnalysisTaskSAQA::DoTrackLoop()
   Float_t sum = 0;
 
   Int_t ntracks = fTracks->GetEntriesFast();
-  Int_t nclusters = 0;
-  if (fCaloClusters)
-    nclusters = fCaloClusters->GetEntriesFast();
+  Int_t neg = 0;
+  Int_t zero = 0;
 
   for (Int_t i = 0; i < ntracks; i++) {
 
@@ -510,8 +525,14 @@ Float_t AliAnalysisTaskSAQA::DoTrackLoop()
     }
     else {
       fHistTrPhiEtaPt[fCentBin][3]->Fill(track->Eta(), track->Phi(), track->Pt());
-      if (fHistTrPhiEtaPtNegLab[fCentBin] && track->GetLabel() <= 0)
-       fHistTrPhiEtaPtNegLab[fCentBin]->Fill(track->Eta(), track->Phi(), track->Pt());
+      if (track->GetLabel() == 0) {
+       zero++;
+       if (fHistTrPhiEtaPtZeroLab[fCentBin])
+         fHistTrPhiEtaPtZeroLab[fCentBin]->Fill(track->Eta(), track->Phi(), track->Pt());
+      }
+
+      if (track->GetLabel() < 0)
+       neg++;
 
       Int_t type = 0;
 
@@ -540,7 +561,13 @@ Float_t AliAnalysisTaskSAQA::DoTrackLoop()
     if (fHistDeltaPhiPt)
       fHistDeltaPhiPt->Fill(vtrack->Pt(), vtrack->Phi() - vtrack->GetTrackPhiOnEMCal());
   }
-  
+
+  if (fHistTrNegativeLabels)
+    fHistTrNegativeLabels->Fill(1. * neg / ntracks);
+
+  if (fHistTrZeroLabels)
+    fHistTrZeroLabels->Fill(1. * zero / ntracks);
+
   return sum;
 }
 
index e30f7dc..e247f02 100644 (file)
@@ -51,8 +51,10 @@ class AliAnalysisTaskSAQA : public AliAnalysisTaskEmcalJet {
   TH2F                       *fHistCellsTracks;          //!Number of cells vs. number of tracks
 
   // Tracks
+  TH1                        *fHistTrNegativeLabels;     //!Percentage of negative label tracks
+  TH1                        *fHistTrZeroLabels;         //!Percentage of tracks with label=0
   TH3F                       *fHistTrPhiEtaPt[4][4];     //!Phi-Eta-Pt distribution of tracks
-  TH3F                       *fHistTrPhiEtaPtNegLab[4];  //!Phi-Eta-Pt distribution of tracks with negative labels
+  TH3F                       *fHistTrPhiEtaPtZeroLab[4]; //!Phi-Eta-Pt distribution of tracks with label=0
   TH2F                       *fHistTrEmcPhiEta;          //!Phi-Eta emcal propagated distribution of tracks
   TH2F                       *fHistTrPhiEtaNonProp;      //!Phi-Eta distribution of non emcal propagated tracks
   TH2F                       *fHistDeltaEtaPt;           //!Eta-EtaProp vs. Pt
index 7226994..44ece12 100644 (file)
@@ -20,6 +20,7 @@ AliJetEmbeddingFromPYTHIATask* AddTaskJetEmbeddingFromPYTHIA(
   Double_t        minCent       = -1,
   Double_t        maxCent       = -1,
   UInt_t          mask          = AliVEvent::kAny,
+  Double_t        minJetPt      = 0,
   const Bool_t    copyArray     = kTRUE,  
   const Bool_t    makeQA        = kFALSE,
   const char     *fileTable     = "",
@@ -60,6 +61,7 @@ AliJetEmbeddingFromPYTHIATask* AddTaskJetEmbeddingFromPYTHIA(
   jetEmb->SetCentralityRange(minCent, maxCent);
   jetEmb->SetTriggerMask(mask);
   jetEmb->SetCopyArray(copyArray);
+  jetEmb->SetJetMinPt(minJetPt);
   if (strcmp(fileTable, "") != 0)
     jetEmb->SetFileTable(GenerateFileTable(fileTable));