Some clean up in addTask macros, added centrality selection and event classes to...
authorkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 20 Nov 2010 12:37:57 +0000 (12:37 +0000)
committerkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 20 Nov 2010 12:37:57 +0000 (12:37 +0000)
13 files changed:
PWG4/JetTasks/AliAnalysisHelperJetTasks.cxx
PWG4/JetTasks/AliAnalysisHelperJetTasks.h
PWG4/JetTasks/AliAnalysisTaskJetServices.cxx
PWG4/JetTasks/AliAnalysisTaskJetServices.h
PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx
PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.h
PWG4/macros/AddTaskESDFilterPWG4Train.C
PWG4/macros/AddTaskFragmentationFunction.C
PWG4/macros/AddTaskJetChem.C
PWG4/macros/AddTaskJetCluster.C
PWG4/macros/AddTaskJetSpectrum2.C
PWG4/macros/AddTaskJets.C
PWG4/macros/AnalysisTrainPWG4Jets.C

index b4b0bca..d228f51 100644 (file)
@@ -557,6 +557,12 @@ Bool_t  AliAnalysisHelperJetTasks::TestSelectInfo(UInt_t iMask){
 }
 
 
+Bool_t  AliAnalysisHelperJetTasks::TestEventClass(Int_t iMask){
+  if(iMask==0)return kTRUE;
+  return (EventClass()==iMask);
+}
+
+
 UInt_t  AliAnalysisHelperJetTasks::SelectInfo(Bool_t bSet,UInt_t iNew){
   static UInt_t iSelectInfo = 0; //
   if(bSet){
@@ -566,6 +572,17 @@ UInt_t  AliAnalysisHelperJetTasks::SelectInfo(Bool_t bSet,UInt_t iNew){
 }
 
 
+Int_t  AliAnalysisHelperJetTasks::EventClass(Bool_t bSet,Int_t iNew){
+  static Int_t iEventClass = 0; //
+  if(bSet){
+    iEventClass = iNew;
+  }
+  return iEventClass;
+}
+
+
+
+
 //___________________________________________________________________________________________________________
 
 Bool_t AliAnalysisHelperJetTasks::GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes)
index e206f54..373787a 100644 (file)
@@ -42,9 +42,6 @@ class AliAnalysisHelperJetTasks : public TObject {
   // same as in PWG0Helper
   enum MCProcessType { kInvalidProcess = -1, kND = 0x1, kDD = 0x2, kSD = 0x4, kOnePart = 0x8 };
 
-
-
-  
   static AliGenPythiaEventHeader*  GetPythiaEventHeader(AliMCEvent *mcEvent);
   static void PrintStack(AliMCEvent *mcEvent,Int_t iFirst = 0,Int_t iLast = 0,Int_t iMaxPrint = 10);
   static void GetClosestJets(AliAODJet *genJets,
@@ -71,8 +68,10 @@ class AliAnalysisHelperJetTasks : public TObject {
   static Bool_t IsPileUp(); // Wrapper for SelectInfo with PileUp
   static Bool_t IsCosmic(); // Wrapper for SelectInfo with cosmic
   static Bool_t TestSelectInfo(UInt_t iMask); // Wrapper for testing the SelectInfo bitmask
+  static Bool_t TestEventClass(Int_t iClass); // Wrapper for testing the SelectInfo bitmask
 
   static UInt_t SelectInfo(Bool_t bSet = kFALSE,UInt_t iNew = 0); // static function to store the state bitmask of the selection from service task
+  static Int_t  EventClass(Bool_t bSet = kFALSE,Int_t iNew = 0); // static function to store the event class of the selection from service task
   
   // these methods have been essentially copied from PWG0/AliTriggerAnalysis and expanded to use with AOD
   static Bool_t IsTriggerFired(const AliVEvent* aEsd, Trigger trigger);
@@ -81,7 +80,7 @@ class AliAnalysisHelperJetTasks : public TObject {
   
   static Int_t fgLastProcessType;    // stores the raw value of the last process type extracted
  
-  ClassDef(AliAnalysisHelperJetTasks, 3
+  ClassDef(AliAnalysisHelperJetTasks, 4
 };
 
 #endif // ALIANALYSISHELPERJETTASKS_H
index 1709da3..9da19d7 100644 (file)
@@ -38,6 +38,7 @@
 #include "TDatabasePDG.h"
 
 #include "AliAnalysisTaskJetServices.h"
+#include "AliESDCentrality.h"
 #include "AliAnalysisDataContainer.h"
 #include "AliAnalysisDataSlot.h"
 #include "AliAnalysisManager.h"
 
 ClassImp(AliAnalysisTaskJetServices)
 
+AliAODHeader*  AliAnalysisTaskJetServices::fgAODHeader = NULL;
+
 AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(): AliAnalysisTaskSE(),
   fUseAODInput(kFALSE),
   fUsePhysicsSelection(kFALSE),
   fMC(kFALSE),
+  fFilterAODCollisions(kFALSE),
   fPhysicsSelectionFlag(AliVEvent::kMB),
   fSelectionInfoESD(0),
   fEventCutInfoESD(0),
@@ -82,6 +86,7 @@ AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(): AliAnalysisTaskSE(),
   fPtMinCosmic(5.),
   fRIsolMinCosmic(3.),
   fMaxCosmicAngle(0.01),
+  fNonStdFile(""),
   fh1Xsec(0x0),
   fh1Trials(0x0),
   fh1PtHard(0x0),
@@ -106,6 +111,7 @@ AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(const char* name):
   fUseAODInput(kFALSE),
   fUsePhysicsSelection(kFALSE),
   fMC(kFALSE),
+  fFilterAODCollisions(kFALSE),
   fPhysicsSelectionFlag(AliVEvent::kMB),
   fSelectionInfoESD(0),
   fEventCutInfoESD(0),
@@ -118,6 +124,7 @@ AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(const char* name):
   fPtMinCosmic(5.),
   fRIsolMinCosmic(3.),
   fMaxCosmicAngle(0.01),
+  fNonStdFile(""),
   fh1Xsec(0x0),
   fh1Trials(0x0),
   fh1PtHard(0x0),
@@ -233,7 +240,7 @@ void AliAnalysisTaskJetServices::UserCreateOutputObjects()
   // 3 decisions, 0 trigger X, X + SPD vertex, X + SPD vertex in range  
   // 3 triggers BB BE/EB EE
 
-  fh2ESDTriggerRun = new TH2F("fh2ESDTriggerRun","Trigger vs run number:run;trigger",(Int_t)(1+fRunRange[1]-fRunRange[0]),fRunRange[0]-0.5,fRunRange[1]+0.5,10,-0.5,9.5);
+  fh2ESDTriggerRun = new TH2F("fh2ESDTriggerRun","Eventclass vs run number:run;trigger",(Int_t)(1+fRunRange[1]-fRunRange[0]),fRunRange[0]-0.5,fRunRange[1]+0.5,10,-0.5,9.5);
   fHistList->Add(fh2ESDTriggerRun);
 
   fh2VtxXY = new TH2F("fh2VtxXY","Beam Spot all INT triggered events;x (cm);y (cm)",160,-10,10,160,-10,10);
@@ -254,6 +261,13 @@ void AliAnalysisTaskJetServices::UserCreateOutputObjects()
 
 
   TH1::AddDirectory(oldStatus);
+
+  // Add an AOD branch for replication
+  if(fNonStdFile.Length()){
+     if (fDebug > 1) AliInfo("Replicating header");
+     fgAODHeader = new AliAODHeader;
+     AddAODBranch("AliAODHeader",&fgAODHeader,fNonStdFile.Data());
+  }
 }
 
 void AliAnalysisTaskJetServices::Init()
@@ -274,13 +288,20 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/)
  
   AliAODEvent *aod = 0;
   AliESDEvent *esd = 0;
+
+
   
   AliAnalysisHelperJetTasks::Selected(kTRUE,kFALSE); // set slection to false
+  AliAnalysisHelperJetTasks::EventClass(kTRUE,0);
   fSelectionInfoESD = 0; // reset
   fEventCutInfoESD = 0; // reset
   AliAnalysisHelperJetTasks::SelectInfo(kTRUE,fSelectionInfoESD); // set slection to false
 
 
+  static AliAODHandler *aodH = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
+   
+
+
   if(fUseAODInput){    
     aod = dynamic_cast<AliAODEvent*>(InputEvent());
     if(!aod){
@@ -324,68 +345,8 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/)
     if(v0C)fSelectionInfoESD |=  AliAnalysisHelperJetTasks::kV0C;
     if(!(v0ABG||v0CBG))fSelectionInfoESD |=  AliAnalysisHelperJetTasks::kNoV0BG;
     if(spdFO)fSelectionInfoESD |=  AliAnalysisHelperJetTasks::kSPDFO;
-
-    Float_t run = (Float_t)esd->GetRunNumber();
-    const AliESDVertex *vtxESD = esd->GetPrimaryVertex();
-    esdVtxValid = 
-    esdVtxIn = IsVertexIn(vtxESD);
-    Float_t zvtx = -999;
-    Float_t xvtx = -999;
-    Float_t yvtx = -999;
-
-    if(esdVtxValid){
-      zvtx = vtxESD->GetZ();
-      yvtx = vtxESD->GetY();
-      xvtx = vtxESD->GetX();
-    }
-
-    // CKB this can be cleaned up a bit...
-    
-    Int_t iTrig = -1;
-    if(esd->GetFiredTriggerClasses().Contains("CINT1B")
-       ||esd->GetFiredTriggerClasses().Contains("CSMBB")
-       ||esd->GetFiredTriggerClasses().Contains("MB1")
-       ||esd->GetFiredTriggerClasses().Contains("CINT6B")){
-      iTrig = 0;
-      fSelectionInfoESD |=  AliAnalysisHelperJetTasks::kBunchBunch;
-    }
-    else if(esd->GetFiredTriggerClasses().Contains("CINT1A")
-           ||esd->GetFiredTriggerClasses().Contains("CSMBA")
-           ||esd->GetFiredTriggerClasses().Contains("CINT6A")
-           ||esd->GetFiredTriggerClasses().Contains("CINT1C")
-           ||esd->GetFiredTriggerClasses().Contains("CSMBC")
-           ||esd->GetFiredTriggerClasses().Contains("CINT6C")){
-      // empty bunch or bunch empty
-      iTrig = 1;
-      fSelectionInfoESD |=  AliAnalysisHelperJetTasks::kBunchEmpty;
-    }
-    else if(esd->GetFiredTriggerClasses().Contains("CINT1-E")
-       ||esd->GetFiredTriggerClasses().Contains("CINT6-E")){
-      iTrig = 2;
-      fSelectionInfoESD |=  AliAnalysisHelperJetTasks::kEmptyEmpty;
-    }
-
-    
-    if(iTrig>=0){
-      iTrig *= 3;
-      fh2ESDTriggerRun->Fill(run,iTrig+1);
-      if(vtxESD->GetNContributors()>2){
-       fh2ESDTriggerRun->Fill(run,iTrig+2);
-       fh2VtxXY->Fill(xvtx,yvtx);
-      }
-      xvtx -= fVtxXMean; 
-      yvtx -= fVtxYMean; 
-      zvtx -= fVtxZMean; 
-      Float_t r2 = xvtx *xvtx + yvtx *yvtx; 
-      if(TMath::Abs(zvtx)<fVtxZCut&&r2<(fVtxRCut*fVtxRCut))fh2ESDTriggerRun->Fill(run,iTrig+3);
-    }
-    else{
-      fh2ESDTriggerRun->Fill(run,0);
-    }
-    // BKC
   }
-  
-
   // Apply additional constraints
   Bool_t esdEventSelected = IsEventSelected(esd);
   Bool_t esdEventPileUp = IsEventPileUp(esd);
@@ -394,6 +355,11 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/)
   Bool_t aodEventSelected = IsEventSelected(aod);
 
   Bool_t physicsSelection = ((fInputHandler->IsEventSelected())&fPhysicsSelectionFlag);
+  if(aodH&&physicsSelection&&fFilterAODCollisions){
+    aodH->SetFillAOD(kTRUE);
+  }
+
+
   fEventCutInfoESD |= kPhysicsSelectionCut; // other alreay set via IsEventSelected
   fh1EventCutInfoESD->Fill(fEventCutInfoESD);
 
@@ -425,41 +391,45 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/)
 
   if(esd){
     const AliESDVertex *vtxESD = esd->GetPrimaryVertex();
-    //      Printf(">> ESDvtx %s %s",vtxESD->GetName(),vtxESD->GetTitle());vtxESD->Print();
-    TString vtxName(vtxESD->GetName());
+    esdVtxValid = IsVertexValid(vtxESD);
+    esdVtxIn = IsVertexIn(vtxESD);
     Float_t zvtx = vtxESD->GetZ();
-    for(int it = AliAnalysisHelperJetTasks::kAcceptAll;it < AliAnalysisHelperJetTasks::kTrigger;it++){
-      Bool_t esdTrig = kFALSE;
-      esdTrig = AliAnalysisHelperJetTasks::IsTriggerFired(esd,(AliAnalysisHelperJetTasks::Trigger)it);
-      if(esdTrig)fh2ESDTriggerCount->Fill(it,kAllTriggered);
-      Bool_t cand = physicsSelection;
-      if(cand){
-       fh2ESDTriggerCount->Fill(it,kSelectedALICE); 
-       fh2ESDTriggerVtx->Fill(kSelectedALICE*(it+1),zvtx);
-      }
-      if(!fUsePhysicsSelection)cand =  AliAnalysisHelperJetTasks::IsTriggerFired(esd,AliAnalysisHelperJetTasks::kMB1);
-      if(vtxESD->GetNContributors()>2&&!vtxName.Contains("TPCVertex")){
-       if(esdTrig){
-         fh2ESDTriggerCount->Fill(it,kTriggeredVertex);
-         fh2ESDTriggerVtx->Fill(kTriggeredVertex*(it+1),zvtx);
-       }
-       if(esdEventSelected&&esdTrig){
-         fh2ESDTriggerCount->Fill(it,kTriggeredVertexIn);
-         fh2ESDTriggerVtx->Fill(kTriggeredVertexIn*(it+1),zvtx);
-       }
-       if(cand){
-         fh2ESDTriggerCount->Fill(it,kSelectedALICEVertexValid);
-         fh2ESDTriggerVtx->Fill(kSelectedALICEVertexValid*(it+1),zvtx);
-       }
+    Int_t  iCl = GetEventClass(esd);
+    AliAnalysisHelperJetTasks::EventClass(kTRUE,iCl);
+    Bool_t cand = physicsSelection;
+
+    Printf("%s:%d %d %d %d Icl %d",(char*)__FILE__,__LINE__,esdVtxValid,esdVtxIn,cand,iCl);
+
+    if(cand){
+      fh2ESDTriggerCount->Fill(0.,kSelectedALICE); 
+      fh2ESDTriggerCount->Fill(iCl,kSelectedALICE); 
+      fh2ESDTriggerVtx->Fill(kSelectedALICE*(iCl+1),zvtx);
+    }
+    //    if(!fUsePhysicsSelection)cand =  AliAnalysisHelperJetTasks::IsTriggerFired(esd,AliAnalysisHelperJetTasks::kMB1);
+    if(esdVtxValid){
+      fh2ESDTriggerCount->Fill(0.,kTriggeredVertex);
+      fh2ESDTriggerCount->Fill(iCl,kTriggeredVertex);
+      fh2ESDTriggerVtx->Fill(iCl,zvtx);
+      if(esdVtxIn){
+       fh2ESDTriggerCount->Fill(0.,kTriggeredVertexIn);
+       fh2ESDTriggerCount->Fill(iCl,kTriggeredVertexIn);
+       fh2ESDTriggerVtx->Fill(kTriggeredVertexIn*(iCl+1),zvtx);
       }
-      if(cand&&esdEventSelected){
-       fh2ESDTriggerCount->Fill(it,kSelectedALICEVertexIn);
-       fh2ESDTriggerVtx->Fill(kSelectedALICEVertexIn*(it+1),zvtx);
-       fh2ESDTriggerVtx->Fill(kSelected*(it+1),zvtx);
-       fh2ESDTriggerCount->Fill(it,kSelected);
-       AliAnalysisHelperJetTasks::Selected(kTRUE,kTRUE);// select this event
+      if(cand){
+       fh2ESDTriggerCount->Fill(0.,kSelectedALICEVertexValid);
+       fh2ESDTriggerCount->Fill(iCl,kSelectedALICEVertexValid);
+       fh2ESDTriggerVtx->Fill(kSelectedALICEVertexValid*(iCl+1),zvtx);
       }
     }
+    if(cand&&esdVtxIn){
+      fh2ESDTriggerCount->Fill(0.,kSelectedALICEVertexIn);
+      fh2ESDTriggerCount->Fill(iCl,kSelectedALICEVertexIn);
+      fh2ESDTriggerVtx->Fill(kSelectedALICEVertexIn*(iCl+1),zvtx);
+      fh2ESDTriggerVtx->Fill(kSelected*(iCl+1),zvtx);
+      fh2ESDTriggerCount->Fill(iCl,kSelected);
+      fh2ESDTriggerCount->Fill(0.,kSelected);
+      AliAnalysisHelperJetTasks::Selected(kTRUE,kTRUE);// select this event
+    }
   }
 
   if(aod){
@@ -528,9 +498,15 @@ void AliAnalysisTaskJetServices::UserExec(Option_t */*option*/)
 
   // trigger selection
   
-
+  // replication of 
+  if(fNonStdFile.Length()&&aod){
+    if (fgAODHeader){
+      *fgAODHeader =  *(dynamic_cast<AliAODHeader*>(aod->GetHeader()));
+    }
+  }
+  
   PostData(1, fHistList);
-}
+  }
 
 Bool_t AliAnalysisTaskJetServices::IsEventSelected(const AliESDEvent* esd){
   if(!esd)return kFALSE;
@@ -718,10 +694,22 @@ Bool_t AliAnalysisTaskJetServices::IsEventCosmic(const AliESDEvent* esd) const {
 }
 
 
+Int_t AliAnalysisTaskJetServices::GetEventClass(AliESDEvent *esd){
+
+  Float_t cent = 999;
+  if(esd->GetCentrality()){
+    cent = esd->GetCentrality()->GetCentralityPercentile("V0M");
+  }
+  if(cent>50)return 4;
+  if(cent>30)return 3;
+  if(cent>10)return 2;
+  return 1;
 
+}
 
 void AliAnalysisTaskJetServices::Terminate(Option_t */*option*/)
 {
   // Terminate analysis
   //
 }
+
index 67a1908..cf1d4fa 100644 (file)
@@ -55,6 +55,9 @@ class AliAnalysisTaskJetServices : public AliAnalysisTaskSE
     virtual void SetMCData(Bool_t b){fMC = b;}
     virtual void SetUsePhysicsSelection(Bool_t b){fUsePhysicsSelection = b;}
     virtual void SetPhysicsSelectionFlag(Int_t i){fPhysicsSelectionFlag = i;}
+    virtual void SetFilterAODCollisions(Bool_t b){fFilterAODCollisions = b;}
+
+    virtual void SetNonStdFile(char *c){fNonStdFile = c;}
     Bool_t IsEventSelected(const AliESDEvent* esd);
     Bool_t IsEventSelected(const AliAODEvent* aod) const;
 
@@ -67,6 +70,7 @@ class AliAnalysisTaskJetServices : public AliAnalysisTaskSE
 
     Bool_t IsVertexIn(const AliESDVertex *vtx);
     Bool_t IsVertexIn(const AliAODVertex *vtx) const;
+    Int_t GetEventClass(AliESDEvent *esd);
 
     enum { kAllTriggered = 0,kTriggeredVertex,kTriggeredVertexIn,kSelectedALICE,kSelectedALICEVertexValid,kSelectedALICEVertexIn,kSelected,kConstraints};
 
@@ -91,6 +95,7 @@ class AliAnalysisTaskJetServices : public AliAnalysisTaskSE
     Bool_t        fUseAODInput;        // take jet from input AOD not from ouptu AOD
     Bool_t        fUsePhysicsSelection;// decide wether we take into account physicsselction task
     Bool_t        fMC;                 // true for MC data to allow correct trigger slection
+    Bool_t        fFilterAODCollisions; // filter out collision canditates to the AOD
     UInt_t        fPhysicsSelectionFlag; // defines the glag for acceptance of events from physics selection
     UInt_t        fSelectionInfoESD;   // slection info bit mask
     UInt_t        fEventCutInfoESD;   // event selection info of what is cutted after physics selection
@@ -104,6 +109,7 @@ class AliAnalysisTaskJetServices : public AliAnalysisTaskSE
     Float_t       fRIsolMinCosmic;     // Minimum R = sqrt{deltaPhi^2 + deltaEta^2} to be considered as cosmic candidate
     Float_t       fMaxCosmicAngle;     // Max deviation from pi (angle between two tracks) in case of cosmic candidate
     Float_t       fRunRange[2];        // only important for real data for 
+    TString       fNonStdFile;         // outputName for replication
     TProfile*     fh1Xsec;             //! pythia cross section and trials
     TH1F*         fh1Trials;           //! trials are added
     TH1F*         fh1PtHard;           //! Pt har of the event...       
@@ -118,10 +124,12 @@ class AliAnalysisTaskJetServices : public AliAnalysisTaskSE
     TH2F*         fh2VtxXY;            //! XY position of VTX were available
     TH1F*         fh1NCosmicsPerEvent;  //! Number of coscmic candidates found in event
     AliTriggerAnalysis *fTriggerAnalysis; //! Trigger Analysis to get the background rates etc.
+    TList *fHistList; //! Output list
+
+        // Provisions for replication
+    static AliAODHeader*    fgAODHeader;        //! Header for replication
 
-    TList *fHistList; // Output list
-   
-    ClassDef(AliAnalysisTaskJetServices,9)
+    ClassDef(AliAnalysisTaskJetServices,11)
 };
  
 #endif
index bbe272f..bd33d2c 100644 (file)
@@ -86,6 +86,7 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(): AliAnalysisTaskSE(),
                                                            fAnalysisType(0),
   fTrackTypeRec(kTrackUndef),
   fTrackTypeGen(kTrackUndef),
+  fEventClass(0),
   fAvgTrials(1),
   fExternalWeight(1),    
                                                            fRecEtaWindow(0.5),
@@ -195,6 +196,7 @@ AliAnalysisTaskJetSpectrum2::AliAnalysisTaskJetSpectrum2(const char* name):
   fAnalysisType(0),
   fTrackTypeRec(kTrackUndef),
   fTrackTypeGen(kTrackUndef),
+  fEventClass(0),
   fAvgTrials(1),
   fExternalWeight(1),    
   fRecEtaWindow(0.5),
@@ -513,7 +515,7 @@ void AliAnalysisTaskJetSpectrum2::UserCreateOutputObjects()
     fHistList->Add(fh1PtHardNoW);
     fHistList->Add(fh1PtHardTrials);
     fHistList->Add(fh1ZVtx);
-    if(fBranchGen.Length()>0){
+    if(fBranchGen.Length()>0||fBkgSubtraction){
       fHistList->Add(fh1NGenJets);
       fHistList->Add(fh1PtTracksGenIn);
     }
@@ -535,7 +537,7 @@ void AliAnalysisTaskJetSpectrum2::UserCreateOutputObjects()
     for(int ij = 0;ij<kMaxJets;++ij){
       fHistList->Add( fh1PtRecIn[ij]);
 
-      if(fBranchGen.Length()>0){       
+      if(fBranchGen.Length()>0||fBkgSubtraction){      
        fHistList->Add(fh1PtGenIn[ij]);
        fHistList->Add(fh2FragGen[ij]);
        fHistList->Add(fh2FragLnGen[ij]);
@@ -625,9 +627,13 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
     selected = AliAnalysisHelperJetTasks::TestSelectInfo(fEventSelectionMask);
   }
 
+  if(fEventClass>0){
+    selected = selected&&(AliAnalysisHelperJetTasks::EventClass()==fEventClass);
+  }
+
   if(!selected){
     // no selection by the service task, we continue
-    if (fDebug > 1)Printf("Not selected %s:%d",(char*)__FILE__,__LINE__);
+    if (fDebug > 1)Printf("Not selected %s:%d SelectInfo %d  Class %d",(char*)__FILE__,__LINE__, AliAnalysisHelperJetTasks::Selected(),AliAnalysisHelperJetTasks::EventClass());
     PostData(1, fHistList);
     return;
   }
@@ -750,20 +756,20 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
            fh2Errorvspthardest3->Fill(ptsub3,err3/ptsub3);
         }
 
-              Float_t ptsub=0.;
-              if(fFillCorrBkg==1) ptsub=ptsub1;
-              if(fFillCorrBkg==2) ptsub=ptsub2;
-              if(fFillCorrBkg==3) ptsub=ptsub3;
-              Float_t subphi=jet->Phi();
-              Float_t subtheta=jet->Theta();
-              Float_t subpz = ptsub/TMath::Tan(subtheta);
-              Float_t subpx=ptsub*TMath::Cos(subphi);
-              Float_t subpy=ptsub * TMath::Sin(subphi);
-              Float_t subp  = TMath::Sqrt(ptsub*ptsub+subpz*subpz);
-             if(k<kMaxJets){
-               genJets[k].SetPxPyPzE(subpx,subpy,subpz,subp);
-               nGenJets = k+1;
-             }
+        Float_t ptsub=0.;
+        if(fFillCorrBkg==1) ptsub=ptsub1;
+        if(fFillCorrBkg==2) ptsub=ptsub2;
+        if(fFillCorrBkg==3) ptsub=ptsub3;
+        Float_t subphi=jet->Phi();
+        Float_t subtheta=jet->Theta();
+        Float_t subpz = ptsub/TMath::Tan(subtheta);
+        Float_t subpx=ptsub*TMath::Cos(subphi);
+        Float_t subpy=ptsub * TMath::Sin(subphi);
+        Float_t subp  = TMath::Sqrt(ptsub*ptsub+subpz*subpz);
+        if(k<kMaxJets){
+          genJets[k].SetPxPyPzE(subpx,subpy,subpz,subp);
+          nGenJets = k+1;
+        }
        }
        fh2Rhovspthardest1->Fill(pthardest,bkg1);
        fh2Rhovspthardest2->Fill(pthardest,bkg2);
@@ -825,12 +831,14 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
          if(fMinJetPt>0&&pythiaGenJets[iCount].Pt()<fMinJetPt)continue;
          // if we have MC particles and we do not read from the aod branch
          // use the pythia jets
-         genJets[iCount].SetPxPyPzE(p[0],p[1],p[2],p[3]);
-         iCount++;
+         if(!fBkgSubtraction){
+           genJets[iCount].SetPxPyPzE(p[0],p[1],p[2],p[3]);
+           iCount++;
+         }
        }
       }
     }
-    if(fBranchGen.Length()==0)nGenJets = iCount;    
+    if(fBranchGen.Length()==0&&!fBkgSubtraction)nGenJets = iCount;    
   }// (fAnalysisType&kMCESD)==kMCESD)
 
 
@@ -856,7 +864,7 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
 
 
   // If we set a second branch for the input jets fetch this 
-  if(fBranchGen.Length()>0){
+  if(fBranchGen.Length()>0&&!fBkgSubtraction){
     TClonesArray *aodGenJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchGen.Data()));
     if(aodGenJets){
       Int_t iCount = 0;
index 1ee8b3a..fc11ffe 100644 (file)
@@ -45,6 +45,7 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE
     virtual Bool_t Notify();
 
     virtual void SetUseGlobalSelection(Bool_t b){fUseGlobalSelection = b;}
+    virtual void SetEventClass(Int_t i){fEventClass = i;}
     virtual void SetExternalWeight(Float_t f){fExternalWeight = f;}
     virtual void SetUseExternalWeightOnly(Bool_t b){fUseExternalWeightOnly = b;}
     virtual void SetAODJetInput(Bool_t b){fUseAODJetInput = b;}
@@ -122,6 +123,7 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE
     Int_t         fAnalysisType;          // Analysis type 
     Int_t         fTrackTypeRec;          // type of tracks used for FF 
     Int_t         fTrackTypeGen;          // type of tracks used for FF 
+    Int_t         fEventClass;            // event class to be looked at for this instance of the task
     Float_t       fAvgTrials;             // Average nimber of trials
     Float_t       fExternalWeight;        // external weight
     Float_t       fRecEtaWindow;          // eta window used for corraltion plots between rec and gen 
@@ -210,10 +212,10 @@ class AliAnalysisTaskJetSpectrum2 : public AliAnalysisTaskSE
     TH2F*         fh2Errorvspthardest1;//! relative error vs hardest subtracted jet pt (Bkg1)
     TH2F*         fh2Errorvspthardest2;//! relative error vs hardest subtracted jet pt (Bkg2)
     TH2F*         fh2Errorvspthardest3;//! relative error vs hardest subtracted jet pt (Bkg3)    
-    TList *fHistList; // Output list
+    TList *fHistList;                  //! Output list
    
 
-    ClassDef(AliAnalysisTaskJetSpectrum2, 10) // Analysis task for standard jet analysis
+    ClassDef(AliAnalysisTaskJetSpectrum2, 11) // Analysis task for standard jet analysis
 };
  
 #endif
index bf75690..d1d9d0b 100644 (file)
@@ -85,9 +85,12 @@ AliAnalysisTaskESDfilter *AddTaskESDFilter(Bool_t useKineFilter=kTRUE,
    esdTrackCutsH->SetMaxDCAToVertexXY(2.4);
    esdTrackCutsH->SetMaxDCAToVertexZ(3.2);
    esdTrackCutsH->SetDCAToVertex2D(kTRUE);
+   esdTrackCutsH->SetDCAToVertex2D(kTRUE);
+   esdTrackCutsH->SetPtRange(0.15,1E10);
 
    // standard cuts with tight DCA cut
    AliESDtrackCuts* esdTrackCutsH2 = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
+   esdTrackCutsH2->SetPtRange(0.15,1E10);
 
    // standard cuts with tight DCA but with requiring the first SDD cluster instead of an SPD cluster
    // tracks selected by this cut are exclusive to those selected by the previous cut
index b9098a9..589178e 100644 (file)
@@ -129,6 +129,10 @@ AliAnalysisTaskFragmentationFunction *AddTaskFragmentationFunction(
    Printf("Jet Type %s", typeJets.Data());
    Printf("Track Type %s", typeTracks.Data());
    
+   // attach the filter maska
+   if(branchRecJets.Contains("AOD")&&branchRecJets.Contains("jets")&&!branchRecJets.Contains("MC"))branchRecJets += Form("_Filter%05d",filterMask); 
+   if(branchGenJets.Contains("AOD")&&branchRecJets.Contains("jets")&&!branchGenJets.Contains("MC"))branchGenJets += Form("_Filter%05d",filterMask);
+
    if(!branchRecJets.Contains("noRecJets")) task->SetBranchRecJets(branchRecJets);
    if(!branchGenJets.Contains("noGenJets")) task->SetBranchGenJets(branchGenJets);
 
index c302e7f..d12ac39 100644 (file)
@@ -1,4 +1,4 @@
-AliAnalysisTask *AddTaskJetChem(){
+AliAnalysisTask *AddTaskJetChem(UInt_t filterMask){
 
 
 
@@ -61,7 +61,7 @@ AliAnalysisTask *AddTaskJetChem(){
   task->SetCutnSigdEdx(2); 
  
   task->ReadDeltaAOD(); // uncomment for DeltaAODs
-  task->SelectDeltaAODBranch("jetsAOD_FASTJET04"); 
+  task->SelectDeltaAODBranch(Form("jetsAOD_FASTJET04_Filter%05d",filterMask)); 
   //task->SelectAODBranch("jetsAOD_FASTKT04");
   //task->SelectAODBranch("jetsAOD_UA107");
   //task->SelectAODBranch("jets");
index 08bceb0..46df495 100644 (file)
@@ -1,4 +1,4 @@
-AliAnalysisTaskJetCluster *AddTaskJetCluster(char* bRec = "AOD",char* bGen = "",UInt_t filterMask = 16, UInt_t iPhysicsSelectionFlag = AliVEvent::kMB,Char_t *jf = "KT", Float_t radius = 0.4,Int_t nSkip = 0,Int_t kWriteAOD = kFALSE);\r
+AliAnalysisTaskJetCluster *AddTaskJetCluster(char* bRec = "AOD",char* bGen = "",UInt_t filterMask = 16, UInt_t iPhysicsSelectionFlag = AliVEvent::kMB,Char_t *jf = "KT", Float_t radius = 0.4,Int_t nSkip = 0,Int_t kWriteAOD = kFALSE,char* deltaFile = "");\r
 \r
 \r
 AliAnalysisTaskJetCluster *AddTaskJetClusterDelta(UInt_t filterMask = 16,Bool_t kUseAODMC = kFALSE,UInt_t iPhysicsSelectionFlag = AliVEvent::kMB,Char_t *jf = "KT", UInt_t iFlag){\r
@@ -26,10 +26,10 @@ AliAnalysisTaskJetCluster *AddTaskJetClusterDelta(UInt_t filterMask = 16,Bool_t
 }\r
 \r
 \r
-AliAnalysisTaskJetCluster *AddTaskJetCluster(char* bRec,char* bGen ,UInt_t filterMask,UInt_t iPhysicsSelectionFlag,Char_t *jf,Float_t radius,Int_t nSkip,Int_t kWriteAOD)\r
+AliAnalysisTaskJetCluster *AddTaskJetCluster(char* bRec,char* bGen ,UInt_t filterMask,UInt_t iPhysicsSelectionFlag,Char_t *jf,Float_t radius,Int_t nSkip,Int_t kWriteAOD,char *deltaFile)\r
 {\r
 // Creates a jet fider task, configures it and adds it to the analysis manager.\r
-\r
+  TString outputFile(deltaFile);\r
    // Get the pointer to the existing analysis manager via the static access method.\r
    //==============================================================================\r
    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
@@ -114,7 +114,6 @@ AliAnalysisTaskJetCluster *AddTaskJetCluster(char* bRec,char* bGen ,UInt_t filte
      break;\r
    case "KT":\r
      pwg4spec->SetAlgorithm(0); // kt from fastjet/JetDefinition.hh\r
-     if(TMath::Abs(radius - 0.6)<0.05)pwg4spec->SetBackgroundCalc(kTRUE);\r
      break;\r
    default:\r
      ::Error("AddTaskJetCluster", "Wrong jet finder selected\n");\r
@@ -123,6 +122,7 @@ AliAnalysisTaskJetCluster *AddTaskJetCluster(char* bRec,char* bGen ,UInt_t filte
 \r
    \r
    if(kWriteAOD){\r
+     if(outputFile.Length())pwg4spec->SetJetOutputFile(outputFile);\r
      pwg4spec->SetJetOutputBranch(Form("clusters%s_%s%s",bRec,jf,cRadius));\r
      pwg4spec->SetJetOutputMinPt(0); // store only jets / clusters above a certain threshold\r
    }\r
index 4649da3..9ca3500 100644 (file)
@@ -1,13 +1,11 @@
-AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec = "jets",const char* bGen = "jetsAODMC_UA104",const char* bBkg="",UInt_t filterMask = 32, Int_t iPhysicsSelectionFlag = AliVEvent::kMB,UInt_t iEventSelectionMask = 0,Bool_t kBackground=kTRUE,Int_t iFillCorrBkg = 0);\r
+AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec = "jets",const char* bGen = "jetsAODMC_UA104",const char* bBkg="",UInt_t filterMask = 32, Int_t iPhysicsSelectionFlag = AliVEvent::kMB,UInt_t iEventSelectionMask = 0,Bool_t kBackground=kTRUE,Int_t iFillCorrBkg = 0,Int_t iCl = 0);\r
 \r
 \r
-AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2Delta(UInt_t filterMask = 32,Bool_t kUseAODMC = kFALSE,Int_t iPhysicsSelectionFlag = AliVEvent::kMB,UInt_t iFlag = 0xfffffff, UInt_t iEventSelectionMask = 0,Bool_t kBackground = kTRUE){\r
+AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2Delta(UInt_t filterMask = 32,Bool_t kUseAODMC = kFALSE,Int_t iPhysicsSelectionFlag = AliVEvent::kMB,UInt_t iFlag = 0xfffffff, UInt_t iEventSelectionMask = 0,Bool_t kBackground = kTRUE,char* back = ""){\r
 \r
+  TString cBack = back;\r
 \r
   AliAnalysisTaskJetSpectrum2 *js = 0;\r
-\r
-  TString cBack = ""; // \r
-\r
   if(kUseAODMC){\r
     if(iFlag&(1<<0)){ // UA104\r
       js = AddTaskJetSpectrum2("jets","jetsAODMC_UA104",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
@@ -31,75 +29,49 @@ AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2Delta(UInt_t filterMask = 32,Boo
   }\r
   else { // only the data ... no MC\r
     if(iFlag&(1<<0)){ // UA104\r
-      js = AddTaskJetSpectrum2("jets","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
+      js = AddTaskJetSpectrum2("jets","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground,1);\r
     }\r
     if(iFlag&(1<<1)){ // ANTIKT 04\r
-      js = AddTaskJetSpectrum2("jetsAOD_FASTJET04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
+      js = AddTaskJetSpectrum2("jetsAOD_FASTJET04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground,1);\r
     }\r
     if(iFlag&(1<<2)){ // KT 04\r
-      js = AddTaskJetSpectrum2("jetsAOD_FASTKT04","",cBack.Data(),filterMask,iPhysicsSelectionFlag,iEventSelectionMask,kBackground);\r
+      js = AddTaskJetSpectrum2("jetsAOD_FASTKT04","",cBack.Data(),filterMask,iPhysicsSelectionFlag,iEventSelectionMask,kBackground,1);\r
     }\r
     if(iFlag&(1<<3)){ // SISCONE 04\r
-      js = AddTaskJetSpectrum2("jetsAOD_SISCONE04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
+      js = AddTaskJetSpectrum2("jetsAOD_SISCONE04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground,1);\r
     }\r
   }\r
-    \r
-  \r
-  /*\r
-  if(iFlag&(1<<7))js = AddTaskJetSpectrum2("jets","jetsAOD_FASTJET04",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-  if(iFlag&(1<<8))js = AddTaskJetSpectrum2("jetsAOD_FASTJET04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-  if(iFlag&(1<<9))js = AddTaskJetSpectrum2("jetsAOD_FASTKT04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-  if(iFlag&(1<<10))js = AddTaskJetSpectrum2("jetsAOD_SISCONE04","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-  \r
-  \r
-  if(iFlag&(1<<11)){\r
-    js = AddTaskJetSpectrum2("jetsAOD_UA107","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-    js->SetRecEtaWindow(0.2);\r
-  }\r
-  if(iFlag&(1<<12)){\r
-    js = AddTaskJetSpectrum2("jetsAOD_FASTJET07","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-    js->SetRecEtaWindow(0.2);\r
-  }\r
-  if(iFlag&(1<<13)){\r
-    js = AddTaskJetSpectrum2("jetsAOD_FASTKT07","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-    js->SetRecEtaWindow(0.2);\r
-  }\r
-  if(iFlag&(1<<14)){\r
-    js = AddTaskJetSpectrum2("jetsAOD_SISCONE07","",cBack.Data(),filterMask,iPhysicsSelectionFlag, iEventSelectionMask,kBackground);\r
-    js->SetRecEtaWindow(0.2);\r
-  }\r
-  */\r
-\r
   return js;\r
 }\r
 \r
 \r
-AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec,const char* bGen ,const char* bBkg,UInt_t filterMask,Int_t iPhysicsSelectionFlag,UInt_t iEventSelectionMask,Bool_t kBackground,Int_t iFillCorrBkg)\r
+AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec,const char* bGen ,const char* bBkg,UInt_t filterMask,Int_t iPhysicsSelectionFlag,UInt_t iEventSelectionMask,Bool_t kBackground,Int_t iFillCorrBkg,Int_t iCl)\r
 {\r
-// Creates a jet fider task, configures it and adds it to the analysis manager.\r
-   // Get the pointer to the existing analysis manager via the static access method.\r
-   //==============================================================================\r
-   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
-   if (!mgr) {\r
-      ::Error("AddTaskJetSpectrum2", "No analysis manager to connect to.");\r
-      return NULL;\r
+  // Creates a jet fider task, configures it and adds it to the analysis manager.\r
+  // Get the pointer to the existing analysis manager via the static access method.\r
+  //==============================================================================\r
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
+  if (!mgr) {\r
+     ::Error("AddTaskJetSpectrum2", "No analysis manager to connect to.");\r
+    return NULL;\r
    }  \r
-   \r
-   // Check the analysis type using the event handlers connected to the analysis manager.\r
-   //==============================================================================\r
-   if (!mgr->GetInputEventHandler()) {\r
-     ::Error("AddTaskJetSpectrum2", "This task requires an input event handler");\r
-      return NULL;\r
-   }\r
-\r
-   TString type = mgr->GetInputEventHandler()->GetDataType();\r
-   TString typeRec(bRec);\r
-   TString typeGen(bGen);\r
-   typeGen.ToUpper();\r
-   typeRec.ToUpper();\r
-\r
+  \r
+  // Check the analysis type using the event handlers connected to the analysis manager.\r
+  //==============================================================================\r
+  if (!mgr->GetInputEventHandler()) {\r
+    ::Error("AddTaskJetSpectrum2", "This task requires an input event handler");\r
+    return NULL;\r
+  }\r
+  \r
+  TString type = mgr->GetInputEventHandler()->GetDataType();\r
+  TString typeRec(bRec);\r
+  TString typeGen(bGen);\r
+  typeGen.ToUpper();\r
+  typeRec.ToUpper();\r
+  \r
    TString bBkgName = bBkg;\r
    if(kBackground&&bBkgName.Length()==0){\r
+     // default\r
      if(typeRec.Contains("AODMC2"))bBkgName = "jeteventbackground_clustersAODMC2_KT06";\r
      else bBkgName = "jeteventbackground_clustersAOD_KT06";\r
    }\r
@@ -108,14 +80,9 @@ AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec,const char* bG
    //===========================================================================\r
 \r
    if(iFillCorrBkg)bGen = Form("SubBkg%d",iFillCorrBkg);   \r
-   AliAnalysisTaskJetSpectrum2* pwg4spec = new  AliAnalysisTaskJetSpectrum2(Form("JetSpectrum2%s-%s_%010d",bRec,bGen,iEventSelectionMask));\r
+   AliAnalysisTaskJetSpectrum2* pwg4spec = new  AliAnalysisTaskJetSpectrum2(Form("JetSpectrum2%s-%s_%010d_Class%02d",bRec,bGen,iEventSelectionMask,iCl));\r
    pwg4spec->SetFillCorrBkg(iFillCorrBkg);\r
-   // or a config file\r
-   // pwg4spec->SetAnalysisType(AliAnalysisTaskJetSpectrum2::kAnaMC);\r
-   // if(iAODanalysis)pwg4spec->SetAODInput(kTRUE);\r
-   // pwg4spec->SetDebugLevel(11); \r
-\r
-\r
+   if(iCl)pwg4spec->SetEventClass(iCl);\r
 \r
    // add the filter mask for non default jets branches\r
    TString cAdd("");\r
@@ -124,7 +91,7 @@ AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec,const char* bG
    if(iFillCorrBkg)pwg4spec->SetBranchGen("");  \r
    else {\r
      pwg4spec->SetBranchGen(bGen); \r
-     if(typeGen.Contains("JETSAOD")&&!typeGen.Contains("MC"))     pwg4spec->SetBranchGen(Form("%s%s",bGen,cAdd.Data())); \r
+     if(typeGen.Contains("JETSAOD")&&!typeGen.Contains("MC"))pwg4spec->SetBranchGen(Form("%s%s",bGen,cAdd.Data())); \r
    }\r
    pwg4spec->SetBranchRec(bRec); \r
    if(typeRec.Contains("JETSAOD")&&!typeRec.Contains("MC"))     pwg4spec->SetBranchRec(Form("%s%s",bRec,cAdd.Data())); \r
@@ -186,7 +153,7 @@ AliAnalysisTaskJetSpectrum2 *AddTaskJetSpectrum2(const char* bRec,const char* bG
    // Create ONLY the output containers for the data produced by the task.\r
    // Get and connect other common input/output containers via the manager as below\r
    //==============================================================================\r
-   AliAnalysisDataContainer *coutput1_Spec = mgr->CreateContainer(Form("pwg4spec2_%s_%s_%010d",bRec,bGen,iEventSelectionMask),TList::Class(),AliAnalysisManager::kOutputContainer,Form("%s:PWG4_spec2_%s_%s_%010d",AliAnalysisManager::GetCommonFileName(),bRec,bGen,iEventSelectionMask));\r
+   AliAnalysisDataContainer *coutput1_Spec = mgr->CreateContainer(Form("pwg4spec2_%s_%s_%010d_Class%02d",bRec,bGen,iEventSelectionMask,iCl),TList::Class(),AliAnalysisManager::kOutputContainer,Form("%s:PWG4_spec2_%s_%s_%010d_Class%02d",AliAnalysisManager::GetCommonFileName(),bRec,bGen,iEventSelectionMask,iCl));\r
 \r
    mgr->ConnectInput  (pwg4spec, 0, mgr->GetCommonInputContainer());\r
    mgr->ConnectOutput (pwg4spec, 0, mgr->GetCommonOutputContainer());\r
index 781bfea..b4ec481 100644 (file)
@@ -172,7 +172,7 @@ AliAnalysisTaskJets *AddTaskJets(Char_t *jr, Char_t *jf, Float_t radius,UInt_t f
    jetana->SetConfigFile("");\r
    jetana->SetDebugLevel(2);\r
    if(TMath::Abs((radius-0.4))< 0.02&&c_jf.Contains("fastjet")){\r
-     jetana->SetFilterPt(100.);\r
+     jetana->SetFilterPt(0.1);\r
    }\r
 \r
 \r
index 69bb230..0887172 100644 (file)
@@ -37,6 +37,7 @@ Int_t       kSaveAOD = 8;        // Bit switch 1 = Full AOD 2 = Jet AOD , 4 = Pa
 
 Int_t       iAODanalysis       = 1;      // Analysis on input AOD's
 Int_t       iAODhandler        = 1;      // Analysis produces an AOD or dAOD's
+Int_t       iCentralitySelection  = 0;      // Use the centrality
 Int_t       iESDfilter         = 0;      // ESD to AOD filter (barrel + muon tracks)
 Int_t       iPhysicsSelection  = 1;      // ESD to AOD filter (barrel + muon tracks)
 UInt_t      iPhysicsSelectionFlag = 0; // set by pyshics selection and passed to the task, kMB, kUserDefined etc
@@ -73,6 +74,7 @@ Bool_t      kUseESDTags         = kFALSE; // use ESD tags for selection
 Bool_t      kUseTR              = kFALSE;  // use track references
 Bool_t      kUseAODTags         = kFALSE;  // use AOD tags
 Bool_t      kSaveTrain          = kFALSE;  // save train configuration as: 
+Bool_t      kIsPbPb             = kFALSE;  // Pb+Pb
 
 
 // ### Analysis modules to be included. Some may not be yet fully implemented.
@@ -113,7 +115,7 @@ Int_t       iPWG4CaloConv     = 0;      // Gamma Conversio
 Int_t       kHighPtFilterMask  = 32;     // change depending on the used AOD Filter
 TString     kDeltaAODJetName   = "AliAOD.Jets.root";     
 TString     kDeltaAODJCORRANName   = "AliAOD.JCORRAN.root";     
-TString     kDeltaAODPartCorrName   = "deltaAODPartCorr.root";     
+TString     kDeltaAODPartCorrName   = "AliAOD.PartCorr.root";     
 
 
 //==============================================================================
@@ -217,6 +219,7 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
    if (iAODanalysis) printf("=  AOD analysis                                                  =\n");
    else                     printf("=  ESD analysis                                                  =\n");
    if (iPhysicsSelection)   printf("=  Physics selection                                                =\n");
+   if(iCentralitySelection)printf("=  Centrality selection                                                =\n");
    if (useTender)   printf("=  Using tender                                                =\n");
    if (iESDfilter)   printf("=  ESD filter                                                    =\n");
    if (iJETAN)       printf("=  Jet analysis                                                  =\n");
@@ -322,14 +325,8 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
       AliAODHandler* aodHandler   = new AliAODHandler();
       aodHandler->SetOutputFileName("AliAOD.root");
       aodHandler->SetFillAODforRun(kFillAOD);
-      
-      mgr->SetOutputEventHandler(aodHandler);
       //
-      if (iAODanalysis) {
-
-       //         aodHandler->SetCreateNonStandardAOD();
-       //      if (iJETAN)aodHandler->SetOutputFileName(kDeltaAODJetName.Data());
-      } 
+      mgr->SetOutputEventHandler(aodHandler);
       AliAnalysisDataContainer * cout_aod = mgr->GetCommonOutputContainer();
       cout_aod->SetSpecialOutput();
    }
@@ -378,7 +375,7 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
      Int_t iTriggerHIC = 0;
      Bool_t rejectBkg = true;
-     if(kGridPassPattern.CompareTo("LHC10h")==0) {
+     if(kIsPbPb){
        iTriggerHIC = 2;
        rejectBkg = false; // for the moment...
      }
@@ -386,11 +383,22 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
      iPhysicsSelectionFlag = AliVEvent::kMB;
    }
 
+   if(iCentralitySelection){
+
+     // has to run before AOD filter
+     gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskCentralitySelection.C");
+     const char* file1="$ALICE_ROOT/ANALYSIS/macros/AliCentralityBy1D_137161_v4.root";
+     const char* file2="$ALICE_ROOT/ANALYSIS/macros/AliCentralityBy1D_137161_v4.root";
+     AliCentralitySelectionTask *taskC = AddTaskCentralitySelection(file1,file2);
+      if (!taskC) ::Warning("AnalysisTrainPWG4Jets", "AliCentralitySelectionTask cannot run for this train conditions - EXCLUDED");
+   }
+
    if (iESDfilter && !iAODanalysis) {
       //  ESD filter task configuration.
       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskESDFilterPWG4Train.C");
       AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kUseKinefilter,kUseMuonfilter);
       taskesdfilter->SetEnableFillAOD(kFALSE);
+
       if(kIsMC){
        mgr->RegisterExtraFile("pyxsec_hists.root");
        if(kGridMergeExclude.Length())kGridMergeExclude += " ";
@@ -428,21 +436,35 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
        AddTaskJets("AOD","FASTKT",0.2,kHighPtFilterMask); 
       }
       if (!taskjets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
+       if(kDeltaAODJetName.Length()>0)mgr->RegisterExtraFile(kDeltaAODJetName.Data()); 
    }
 
    if(iPWG4Cluster){
      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C");
      AliAnalysisTaskJetCluster *taskCl = 0;
      if(iPWG4Cluster&1){
-       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1); // this one is for the background random jets
-       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1); // this one is for the background jets
-       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1); // this one is for the background random jets
+
+       if(kIsPbPb){
+        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.2,0,1, kDeltaAODJetName.Data()); // this one is for the background random jets
+        taskCl->SetBackgroundCalc(kTRUE);       
+        taskCl->SetGhostEtamax(0.9);
+        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data()); // this one is for the background random jets
+        taskCl->SetBackgroundCalc(kTRUE);
+        taskCl->SetGhostEtamax(0.9);
+       }
+       else{
+        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1,kDeltaAODJetName.Data()); // this one is for the background jets
+        taskCl->SetBackgroundCalc(kTRUE);
+       }
+
+       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data()); 
+       taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1,kDeltaAODJetName.Data());
 
        if(kUseAODMC){
-        taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1); // this one is for the background jets
-        taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1); // this one is for the background jets
-        taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1); // this one is for the background random jets
-        taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1); // this one is for the background random jets
+        taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1,kDeltaAODJetName.Data()); // this one is for the background jets
+        taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1,kDeltaAODJetName.Data()); // this one is for the background jets
+        taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1,kDeltaAODJetName.Data()); // this one is for the background random jets
+        taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1,kDeltaAODJetName.Data()); // this one is for the background random jets
        }
 
        if (!taskCl) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCluster cannot run for this train conditions - EXCLUDED");
@@ -451,8 +473,13 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
        UInt_t selection = 0;
        if(!iAODanalysis) selection = 0xffffff;
        else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9;
-       selection&=~(1<<4); // exluded R = .04 already the dafault
-       selection&=~(1<<6); // exluded R = .04 already the dafault
+       if(kIsPbPb){
+        selection&=~(1<<2); // exluded R = .04 already the dafault
+        selection&=~(1<<4); // exluded R = .04 already the dafault
+       }
+       else{
+        selection&=~(1<<6); // exluded R = .04 already the dafault
+       }
        AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelectionFlag,"KT",selection);
      }
      if(iPWG4Cluster&4){
@@ -462,8 +489,8 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
         selection &= ~(1<<1)&~(1<<3)&~(1<<5)&~(1<<7)&~(1<<9);
        }
        else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9;
+       selection&=~(1<<2); // exluded R = .04 already the dafault
        selection&=~(1<<4); // exluded R = .04 already the dafault
-       selection&=~(1<<6); // exluded R = .04 already the dafault
        AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelectionFlag,"ANTIKT",selection);
        //       AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelection,"ANTIKT",0.4,0,1);
 
@@ -526,7 +553,7 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
 
    if(iPWG4JetChem){
      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetChem.C");
-     AliAnalysisTask *taskChem = AddTaskJetChem();
+     AliAnalysisTask *taskChem = AddTaskJetChem(kHighPtFilterMask);
      if (!taskChem) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetChem cannot run for this train conditions - EXCLUDED");
    }
 
@@ -542,15 +569,28 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
      taskjetServ->SetUsePhysicsSelection((Bool_t)iPhysicsSelection);
      taskjetServ->SetPhysicsSelectionFlag(iPhysicsSelectionFlag); // 
      taskjetServ->SetDebugLevel(0);
+     taskjetServ->SetNonStdFile(kDeltaAODJetName.Data());
+     if(kIsPbPb){
+       taskjetServ->SetFilterAODCollisions(kTRUE);
+     }
    }
 
    if(iPWG4JetSpectrum){
      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetSpectrum2.C");
      AliAnalysisTaskJetSpectrum2 *taskjetSpectrum = 0;
 
+     TString cBack;
+     if(kIsPbPb){
+       cBack = "jeteventbackground_clustersAOD_KT04";
+     }
+     else{
+       cBack = "jeteventbackground_clustersAOD_KT06";
+     }
+
      if(iPWG4JetSpectrum&1){
-       UInt_t iSelection = 0xffff;
-       taskJetSpectrum = AddTaskJetSpectrum2Delta(kHighPtFilterMask,kUseAODMC,iPhysicsSelectionFlag,iSelection);  // bug fixed 10.11.10
+       // add the dfault jet finders with R = 0.4 
+       UInt_t iSelection = 0xfffff; 
+       taskJetSpectrum = AddTaskJetSpectrum2Delta(kHighPtFilterMask,kUseAODMC,iPhysicsSelectionFlag,iSelection,0,kTRUE,cBack.Data());  // bug fixed 10.11.10
      }
      if(iPWG4JetSpectrum&2){
        if(kIsMC){
@@ -566,6 +606,7 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
         eventSelection =  AliAnalysisHelperJetTasks::kNone;
         taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC2_FASTJET04","",kHighPtFilterMask,iPhysicsSelectionFlag,eventSelection);
         taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC_FASTJET04","",kHighPtFilterMask,iPhysicsSelectionFlag,eventSelection);     
+        taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC_FASTJET04","",kHighPtFilterMask,iPhysicsSelectionFlag,eventSelection);     
        }
        else{
         UInt_t eventSelection =  AliAnalysisHelperJetTasks::kIsPileUp|AliAnalysisHelperJetTasks::kVertexIn;
@@ -577,11 +618,14 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
        }
      }
      if(iPWG4JetSpectrum&4){
-       // jet backgrounds... just for testing...
-       taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","","",kHighPtFilterMask,iPhysicsSelectionFlag,0,kTRUE,1); 
+       // central events backgrounds... just for testing...
+       if(kIsPbPb){
+        taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","",cBack.Data(),kHighPtFilterMask,iPhysicsSelectionFlag,0,kTRUE,1,1); 
+        taskjetSpectrum->SetDebugLevel(10);
+       }
      }
      if (!taskjetSpectrum) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetSpectrum2 cannot run for this train conditions - EXCLUDED");
-     //       taskjetSpectrum->SetDebugLevel(1);
+     
    }
 
 
@@ -914,6 +958,13 @@ void CheckModuleFlags(const char *mode) {
      kUseTR = kFALSE;
    }
 
+   // Decide if we have PbPb
+   if(kGridDataSet.CompareTo("LHC10h")==0) {
+     kIsPbPb = true;
+   }
+
+   
+
    if (iAODanalysis) {
    // AOD analysis
       if (kUseMC)
@@ -964,8 +1015,14 @@ void CheckModuleFlags(const char *mode) {
       if (iPWG4GammaConv)::Info("AnalysisPWG4Jets.C::CheckModuleFlags", "PWG4gammaconv disabled on AOD's");
       iPWG4GammaConv = 0;   
       iPWG1QASym     = 0;
+      iCentralitySelection = 0;
    } else {   
    // ESD analysis
+
+     if(kIsPbPb){
+       iCentralitySelection = 1;
+     }
+
      if (!kUseMC){
        kUseTR = kFALSE;
        
@@ -1884,6 +1941,9 @@ Bool_t PatchAnalysisMacro(){
   add += "\n\n // added by CKB \n";
   if(kErrorIgnoreLevel>0)add += Form("gErrorIgnoreLevel = %d;\n",kErrorIgnoreLevel);
   add += "\n gSystem->AddIncludePath(\"./\"); \n";
+  add += "\n gSystem->SetFPEMask(); \n";
+
+
   if(gGrid&&kPluginAliRootVersion.Length()==0){
     add += "\n // Dirty hack for TRD reference data \n";
     add += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";