From 9382bd6e3b45b800c4f04848a76eca70a7f1bea5 Mon Sep 17 00:00:00 2001 From: ancastro Date: Tue, 9 Sep 2014 17:06:49 -0400 Subject: [PATCH] Adding JetTaggingSample Task --- PWGJE/CMakelibPWGJEFlavourJetTasks.pkg | 1 + ...iAnalysisTaskEmcalJetFlavourTagExample.cxx | 455 ++++++++++++++++++ ...AliAnalysisTaskEmcalJetFlavourTagExample.h | 136 ++++++ .../macros/AddTaskEmcalJetFlavourTagExample.C | 131 +++++ PWGJE/PWGJEFlavourJetTasksLinkDef.h | 1 + 5 files changed, 724 insertions(+) create mode 100644 PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.cxx create mode 100644 PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.h create mode 100644 PWGJE/FlavourJetTasks/macros/AddTaskEmcalJetFlavourTagExample.C diff --git a/PWGJE/CMakelibPWGJEFlavourJetTasks.pkg b/PWGJE/CMakelibPWGJEFlavourJetTasks.pkg index c56d776ce4a..f0a4f47197b 100644 --- a/PWGJE/CMakelibPWGJEFlavourJetTasks.pkg +++ b/PWGJE/CMakelibPWGJEFlavourJetTasks.pkg @@ -40,6 +40,7 @@ set ( SRCS FlavourJetTasks/AliAnalysisTaskSEPicoV0Filter.cxx FlavourJetTasks/AliAnalysisTaskSEPicoV0Maker.cxx FlavourJetTasks/AliAnalysisTaskSEPicoV0MakerMC.cxx + FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.cxx ) set ( DHDR PWGJEFlavourJetTasksLinkDef.h) diff --git a/PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.cxx b/PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.cxx new file mode 100644 index 00000000000..18ce90c87d5 --- /dev/null +++ b/PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.cxx @@ -0,0 +1,455 @@ +/************************************************************************** +* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +/* +* This sample task demostrates the basics of tagging a jet. The PID response +* is retrived for both the TPC. A Hadronic tag is implemented for +* clusters matched to tracks in a jet with a E/P < 0.2 +* +* Author: Andrew Castro (UTK) and Joel Mazer (UTK) +*/ + +#include "AliAnalysisTaskEmcalJetFlavourTagExample.h" + +// general ROOT includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// AliROOT includes +#include "AliAODEvent.h" +#include "AliESDEvent.h" +#include "AliAnalysisManager.h" +#include "AliAnalysisTask.h" +#include "AliCentrality.h" +#include "AliEmcalJet.h" +#include "AliAODJet.h" +#include "AliVCluster.h" +#include "AliVTrack.h" +#include +#include +#include "AliRhoParameter.h" +#include "AliLog.h" +#include "AliJetContainer.h" +#include "AliParticleContainer.h" +#include "AliClusterContainer.h" +#include "AliEmcalParticle.h" +#include "AliESDCaloCluster.h" +#include +#include "AliPID.h" + +// event handler (and pico's) includes +#include +#include +#include "AliESDInputHandler.h" +#include "AliPicoTrack.h" +#include "AliEventPoolManager.h" +#include "AliAODTrack.h" +#include "AliESDtrack.h" + +// PID includes +#include "AliPIDResponse.h" +#include "AliTPCPIDResponse.h" +#include "AliESDpid.h" + +// magnetic field includes +#include "TGeoGlobalMagField.h" +#include "AliMagF.h" + +ClassImp(AliAnalysisTaskEmcalJetFlavourTagExample) + +//________________________________________________________________________ +AliAnalysisTaskEmcalJetFlavourTagExample::AliAnalysisTaskEmcalJetFlavourTagExample() : + AliAnalysisTaskEmcalJet("heavyF",kFALSE), + event(0), + fCuts(0), + fPhimin(-10), fPhimax(10), + fEtamin(-0.9), fEtamax(0.9), + fAreacut(0.0), + fJetHIpt(50.0), + fTrackPtCut(2.0), + fTrackEta(0.9), + fesdTrackCuts(0), + fPIDResponse(0x0), fTPCResponse(), + fJetsCont(0), fTracksCont(0), fCaloClustersCont(0), fTracksJetCont(0), fCaloClustersJetCont(0), + fESD(0), fAOD(0), + fHistJetPhi(0), + fHistCorJetPt(0), fHistJetPt(0), + fHistHighJetPt(0), + fHistnSigElecPt(0), + fHistdEdXvsPt(0), + fHistnJetTrackvnJetClusters(0) +{ + // Default constructor. + + + SetMakeGeneralHistograms(kTRUE); + +} + +//________________________________________________________________________ +AliAnalysisTaskEmcalJetFlavourTagExample::AliAnalysisTaskEmcalJetFlavourTagExample(const char *name) : + AliAnalysisTaskEmcalJet(name,kTRUE), + event(0), + fCuts(0), + fPhimin(-10), fPhimax(10), + fEtamin(-0.9), fEtamax(0.9), + fAreacut(0.0), + fJetHIpt(50.0), + fTrackPtCut(2.0), + fTrackEta(0.9), + fesdTrackCuts(0), + fPIDResponse(0x0), fTPCResponse(), + fJetsCont(0), fTracksCont(0), fCaloClustersCont(0), fTracksJetCont(0), fCaloClustersJetCont(0), + fESD(0), fAOD(0), + fHistJetPhi(0), + fHistCorJetPt(0), fHistJetPt(0), + fHistHighJetPt(0), + fHistnSigElecPt(0), + fHistdEdXvsPt(0), + fHistnJetTrackvnJetClusters(0) +{ + + SetMakeGeneralHistograms(kTRUE); + + DefineInput(0,TChain::Class()); + DefineOutput(1, TList::Class()); +} + +//_______________________________________________________________________ +AliAnalysisTaskEmcalJetFlavourTagExample::~AliAnalysisTaskEmcalJetFlavourTagExample() +{ + // destructor + // + if (fOutput) { + delete fOutput; + fOutput = 0; + } +} + +//________________________________________________________________________ +void AliAnalysisTaskEmcalJetFlavourTagExample::UserCreateOutputObjects() +{ + if (! fCreateHisto) + return; + AliAnalysisTaskEmcalJet::UserCreateOutputObjects(); + + //fJetsCont = GetJetContainer(0); + if(fJetsCont) { //get particles and clusters connected to jets + fTracksJetCont = fJetsCont->GetParticleContainer(); + fCaloClustersJetCont = fJetsCont->GetClusterContainer(); + } + else { //no jets, just analysis tracks and clusters + fTracksCont = GetParticleContainer(0); + fCaloClustersCont = GetClusterContainer(0); +} +fTracksCont->SetClassName("AliVTrack"); +fCaloClustersCont->SetClassName("AliVCluster"); + + fHistJetPhi = new TH1F("NjetvsPhi", "NjetvsPhi", 288,-2*TMath::Pi(),2*TMath::Pi()); + fHistJetPt = new TH1F("NjetvsJetPt", "NjetvsJetPt", 300, 0, 300); + fOutput->Add(fHistJetPhi); + fOutput->Add(fHistJetPt); + + + TString histname; + + fHistCorJetPt = new TH1F("CorrJetPt", "CorrJetPt", 300, -100, 200); + fHistnSigElecPt = new TH2F("nsigvsPt(TPC)","nSigmaElectronTPC_v_Pt",60,0,60,40,-10,10); + fHistdEdXvsPt = new TH2F("dEdXvsTrackPt","dEdXvsTrackPt",60,0,60,80,0,80); + fHistnJetTrackvnJetClusters = new TH2F("NumbJetTracksvJetClusters","NumbJetTracksvJetClusters",21,0,20,21,0,20); + fHistHighJetPt = new TH1F("HighestPtJetPerEvent","HighJetPt",80,0,80); + + TString name; + TString title; + + fOutput->Add(fHistCorJetPt); + fOutput->Add(fHistnSigElecPt); + fOutput->Add(fHistdEdXvsPt); + fOutput->Add(fHistnJetTrackvnJetClusters); + fOutput->Add(fHistHighJetPt); + + + // ****************************** PID ***************************************************** + // set up PID handler + AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager(); + AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler()); + if(!inputHandler) { + AliFatal("Input handler needed"); + } + + // PID response object + //fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse(); + // inputHandler->CreatePIDResponse(fIsMC); // needed to create object, why though? + fPIDResponse = inputHandler->GetPIDResponse(); + if (!fPIDResponse) { + AliError("PIDResponse object was not created"); + } + // *************************************************************************************** + + PostData(1, fOutput); + +} + +//________________________________________________________ +void AliAnalysisTaskEmcalJetFlavourTagExample::ExecOnce() +{ + // Initialize the analysis + AliAnalysisTaskEmcalJet::ExecOnce(); + + if (fJetsCont && fJetsCont->GetArray() == 0) fJetsCont = 0; + if (fTracksCont && fTracksCont->GetArray() == 0) fTracksCont = 0; + if (fCaloClustersCont && fCaloClustersCont->GetArray() == 0) fCaloClustersCont = 0; + + +} // end of ExecOnce + +//________________________________________________________________________ +Bool_t AliAnalysisTaskEmcalJetFlavourTagExample::Run() +{ + // check to see if we have any tracks + if (!fTracks) return kTRUE; + if (!fJets) return kTRUE; + + // what kind of event do we have: AOD or ESD? + Bool_t useAOD; + if (dynamic_cast(InputEvent())) useAOD = kTRUE; + else useAOD = kFALSE; + + // if we have ESD event, set up ESD object + if(!useAOD){ + fESD = dynamic_cast(InputEvent()); + if (!fESD) { + AliError(Form("ERROR: fESD not available\n")); + return kTRUE; + } + } + + // if we have AOD event, set up AOD object + if(useAOD){ + fAOD = dynamic_cast(InputEvent()); + if(!fAOD) { + AliError(Form("ERROR: fAOD not available\n")); + return kTRUE; + } + } + + // get magnetic field info for DCA + Double_t MagF = fESD->GetMagneticField(); + Double_t MagSign = 1.0; + if(MagF<0)MagSign = -1.0; + // set magnetic field + if (!TGeoGlobalMagField::Instance()->GetField()) { + AliMagF* field = new AliMagF("Maps","Maps", MagSign, MagSign, AliMagF::k5kG); + TGeoGlobalMagField::Instance()->SetField(field); + } + + // get vertex information + Double_t fvertex[3]={0,0,0}; + InputEvent()->GetPrimaryVertex()->GetXYZ(fvertex); + //Double_t zVtx=fvertex[2]; + + // create pointer to list of input event + TList *list = InputEvent()->GetList(); + if(!list) { + AliError(Form("ERROR: list not attached\n")); + return kTRUE; + } + + // background density + fRhoVal = fRho->GetVal(); + + // initialize TClonesArray pointers to jets and tracks + TClonesArray *jets = 0; + //TClonesArray *tracks = 0; + //TClonesArray *clusters = 0; + + // get Jets object + jets = dynamic_cast(list->FindObject(fJets)); + if(!jets){ + AliError(Form("Pointer to jets %s == 0", fJets->GetName())); + return kTRUE; + } // verify existence of jets + + // get number of jets and tracks + const Int_t Njets = jets->GetEntries(); + if(Njets<1) return kTRUE; + + if (fTracksCont) { + AliVTrack *track = static_cast(fTracksCont->GetNextAcceptParticle(0)); + while(track) { + track = static_cast(fTracksCont->GetNextAcceptParticle()); + } + } + if (fCaloClustersCont) { + AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster(0); + while(cluster) { + TLorentzVector nPart; + cluster->GetMomentum(nPart, fVertex); + cluster = fCaloClustersCont->GetNextAcceptCluster(); + } + } + + // Start Jet Analysis + // initialize jet parameters + Int_t ijethi=-1; + Double_t highestjetpt=0.0; + + // loop over jets in an event - to find highest jet pT and apply some cuts && JetQA Sparse + for (Int_t ijet = 0; ijet < Njets; ijet++){ + // get our jets + AliEmcalJet *jet = static_cast(jets->At(ijet)); + if (!jet) continue; + + // apply jet cuts + if(!AcceptMyJet(jet)) continue; + + if(highestjetptPt()){ + ijethi=ijet; + highestjetpt=jet->Pt(); + } + } // end of looping over jets + + fHistHighJetPt->Fill(ijethi); + + // ********************************************************************** + // JET LOOP + // ********************************************************************** + + // loop over jets in the event and make appropriate cuts + for (Int_t iJets = 0; iJets < Njets; ++iJets) { + AliEmcalJet *jet = static_cast(fJets->At(iJets)); + if (!jet) // see if we have a jet + continue; + + // apply jet cuts + if(!AcceptMyJet(jet)) continue; + + //AliEmcalJet::EFlavourTag tag=AliEmcalJet::kDStar; + //jet->AddFlavourTag(tag); + + + Int_t JetClusters = jet->GetNumberOfClusters(); + Int_t JetTracks = jet -> GetNumberOfTracks(); + fHistnJetTrackvnJetClusters->Fill(JetClusters,JetTracks); + // Initializations and Calculations + Double_t jetPt = -500; // initialize corr jet pt LOCAL + Double_t jetarea = -500; // initialize jet area + jetPt = jet->Pt() - jetarea*fRhoVal; // semi-corrected pT of jet from GLOBAL rho value + fHistCorJetPt->Fill(jetPt); + + Bool_t bkgrnd1 = kFALSE; + + if(jet->Pt() > fJetHIpt) { + if(!fTracksCont || !fCaloClustersCont) continue; + + //******************************Cluster Matched To Closest Track + //************************************************************** + Int_t NumbTrackContainer = -999; + NumbTrackContainer = fTracksCont->GetNParticles(); + for(int iTracks = 0; iTracks <= NumbTrackContainer; iTracks++){ + AliVTrack *AcceptedTrack =static_cast(fTracksCont->GetParticle(iTracks)); + if(!AcceptedTrack){ + AliError(Form("Couldn't get AliVTrack Container %d\n", iTracks)); + continue; + } + if(!IsJetTrack(jet,iTracks,kFALSE))continue; + //Get matched cluster + Int_t emc1 = AcceptedTrack->GetEMCALcluster(); + + Double_t acceptTrackP = AcceptedTrack->P(); + Double_t acceptTrackPt = AcceptedTrack->Pt(); + Double_t nSigmaElectron_TPC = fPIDResponse->NumberOfSigmasTPC(AcceptedTrack,AliPID::kElectron); + fHistnSigElecPt->Fill(acceptTrackPt,nSigmaElectron_TPC); + + AliESDtrack *ESDacceptedTrack = static_cast(AcceptedTrack); + if(!ESDacceptedTrack){ + AliError(Form("Couldn't get AliESDTrack %d\n", iTracks)); + continue; + } + Double_t dEdx = AcceptedTrack->GetTPCsignal(); + fHistdEdXvsPt->Fill(acceptTrackPt,dEdx); + if(fCaloClustersCont && emc1>=0) { + AliVCluster *clusMatch = fCaloClustersCont->GetCluster(emc1); + if(!clusMatch){ + AliError(Form("Couldn't get matched AliVCluster %d\n", emc1)); + continue; + } + + Double_t mClusterE = clusMatch->E(); + Double_t EovP_mc = -999; + EovP_mc = mClusterE/acceptTrackP; + + if(EovP_mc < 0.2) bkgrnd1 = kTRUE; + } + + } //loop over tracks for matching to closest cluster + + + + + } // highest pt jet cut + + + if(bkgrnd1 == kTRUE) { + AliEmcalJet::EFlavourTag tag=AliEmcalJet::kBckgrd1; + jet->AddFlavourTag(tag); + } + + } // LOOP over JETS in event + + + return kTRUE; + +} +//________________________________________________________________________ +void AliAnalysisTaskEmcalJetFlavourTagExample::Terminate(Option_t *) +{ + cout<<"###########################"<Phi()Phi()>fPhimax)) return 0; + if ((jet->Eta()Eta()>fEtamax)) return 0; + if (jet->Area()Area()==0) return 0; + //exclude jets with extremely high pt tracks which are likely misreconstructed + if(jet->MaxTrackPt()>100) return 0; + + //passed all above cuts + return 1; +} + + + + + diff --git a/PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.h b/PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.h new file mode 100644 index 00000000000..512c35470c2 --- /dev/null +++ b/PWGJE/FlavourJetTasks/AliAnalysisTaskEmcalJetFlavourTagExample.h @@ -0,0 +1,136 @@ +#ifndef AliAnalysisTaskEmcalJetFlavourTagExample_h +#define AliAnalysisTaskEmcalJetFlavourTagExample_h + +class TClonesArray; +class TH1; +class TH2; +class TH3; +class TH1F; +class TH2F; +class TH3F; +class THnSparse; +class TLorentzVector; +class TGraph; + +class AliEMCALTrack; +class AliMagF; +class AliESDEvent; +class AliAODEvent; +class AliEMCALGeometry; +class AliEMCALRecoUtils; +class AliESDtrack; +class AliESDtrackCuts; +class AliAnalysisEtCuts; +class AliDetectorPID; +class AliESDCaloCluster; + +class AliJetContainer; +class AliParticleContainer; +class AliClusterContainer; + + +// this whole section of includes added +#include +#include +#include +#include +#include +#include +#include +#include +#include "AliAnalysisTaskEmcalJet.h" +#include "AliEMCALPIDResponse.h" +#include +#include +#include "AliAODTrack.h" +#include "AliESDtrack.h" +#include "AliPID.h" +#include "AliTPCdEdxInfo.h" + +// PID stuff +#include "AliPIDResponse.h" +#include "AliTPCPIDResponse.h" +#include "AliESDpid.h" +#include "AliAnalysisFilter.h" + +class AliAnalysisTaskEmcalJetFlavourTagExample : public AliAnalysisTaskEmcalJet { + public: + AliAnalysisTaskEmcalJetFlavourTagExample(); + AliAnalysisTaskEmcalJetFlavourTagExample(const char *name); + virtual ~AliAnalysisTaskEmcalJetFlavourTagExample(); + + virtual void UserCreateOutputObjects(); + + /** Cuts info */ + AliAnalysisEtCuts * GetCuts() const { return fCuts; } + virtual void SetCuts(const AliAnalysisEtCuts *cuts) + { fCuts = (AliAnalysisEtCuts *) cuts; } + + // setters + void SetJetPt(Double_t jpt) { fJetHIpt = jpt; } // jet threshold pt cut + void SetTrackPtCut(Double_t trpt) { fTrackPtCut = trpt; } // track pt threshold to do PID on + virtual void SetTrackEta(Double_t e) { fTrackEta = e; } //eta range of the associated tracks + void SetTrackCuts(AliESDtrackCuts *cuts) { fesdTrackCuts = cuts; } + + // eta and phi limits of jets - setters + virtual void SetJetEta(Double_t emin, Double_t emax) { fEtamin = emin; fEtamax = emax; } + virtual void SetJetPhi(Double_t pmin, Double_t pmax) { fPhimin = pmin; fPhimax = pmax; } + + // event no. + Int_t event; // event number (processed) + + protected: + Bool_t Run(); + virtual void Terminate(Option_t *); + virtual Int_t AcceptMyJet(AliEmcalJet *jet); // applies basic jet tests/cuts before accepting + void ExecOnce(); + + + // data type switch + + AliAnalysisEtCuts *fCuts; // keeper of basic cuts + + // cuts + Double_t fPhimin; + Double_t fPhimax; + Double_t fEtamin; + Double_t fEtamax; + Double_t fAreacut; //area cut + Double_t fJetHIpt; // high jet pt + Double_t fTrackPtCut; // track pt cut to do PID on + Double_t fTrackEta; + AliESDtrackCuts *fesdTrackCuts; //esd track cuts!! + + // PID + AliPIDResponse *fPIDResponse; // PID response object + AliTPCPIDResponse *fTPCResponse; // TPC pid response object + + AliJetContainer *fJetsCont; //!Jets + AliParticleContainer *fTracksCont; //!Tracks + AliClusterContainer *fCaloClustersCont; //!Clusters + AliParticleContainer *fTracksJetCont; //! JetTracks + AliClusterContainer *fCaloClustersJetCont; //!JetClusters + + + private: + AliESDEvent *fESD;//! // ESD object + AliAODEvent *fAOD;//! // AOD Object + + + TH1F *fHistJetPhi;//! // Njets vs Phi + TH1F *fHistCorJetPt;//! // (Njets) vs Corrected Jet Pt (local rho) + TH1F *fHistJetPt;//! // raw jet pt (uncorrected) + TH1F *fHistHighJetPt;//! + + TH2F *fHistnSigElecPt;//! check + TH2F *fHistdEdXvsPt;//! check + TH2F *fHistnJetTrackvnJetClusters;//! check + + AliAnalysisTaskEmcalJetFlavourTagExample(const AliAnalysisTaskEmcalJetFlavourTagExample & g) ; // cpy ctor + AliAnalysisTaskEmcalJetFlavourTagExample& operator=(const AliAnalysisTaskEmcalJetFlavourTagExample&); // not implemented + + + + ClassDef(AliAnalysisTaskEmcalJetFlavourTagExample, 4); // Emcal jet Heavy Flavor +}; +#endif diff --git a/PWGJE/FlavourJetTasks/macros/AddTaskEmcalJetFlavourTagExample.C b/PWGJE/FlavourJetTasks/macros/AddTaskEmcalJetFlavourTagExample.C new file mode 100644 index 00000000000..fe09dc698ac --- /dev/null +++ b/PWGJE/FlavourJetTasks/macros/AddTaskEmcalJetFlavourTagExample.C @@ -0,0 +1,131 @@ +AliAnalysisTaskEmcalJetFlavourTagExample* AddTaskEmcalJetFlavourTagExample( + const char *outfilename = "AnalysisOutput.root", + const char *nJets = "Jets", + const char *nClusters = "CaloClustersCorr", + UInt_t type = 0, //AliAnalysisTaskEmcal::kTPC, + const char *nrho = "rhoChEm", + const Double_t minPhi = 1.8, + const Double_t maxPhi = 2.74, + const Double_t minEta = -0.3, + const Double_t maxEta = 0.3, + const Double_t minArea = 0.4, + const char *nPicoTracks = "PicoTracks", + const Double_t hiPTjet = 50.0, + const Double_t trptcut = 2.0, + const Double_t trketa = 0.9, + Bool_t isESD = 0, + const char *typeDET = "EMCAL", + Double_t jetradius = 0.2, + Double_t jetptcut = 1, + Double_t jetareacut = 0.08, + Int_t leadhadtype = 0, + const char *tag = "" +) +{ + // Get the pointer to the existing analysis manager via the static access method. + //============================================================================== + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) + { + ::Error("AddTaskEmcalJetFlavourTagExample", "No analysis manager to connect to."); + return NULL; + } + + // Check the analysis type using the event handlers connected to the analysis manager. + //============================================================================== + AliVEventHandler *evhand = mgr->GetInputEventHandler(); + //if (!mgr->GetInputEventHandler()) + if (!evhand) { + Error("AddTaskEmcalJetHadEPpid", "This task requires an input event handler"); + return NULL; + } + + // check on type of event + TString dType("ESD"); + if (!evhand->InheritsFrom("AliESDInputHandler")) + dType = "AOD"; + if (dType == "AOD") nTracks = "AODFilterTracks"; + if (dType == "ESD") nTracks = "ESDFilterTracks"; + //ESD Trk Cuts + //if(isESD > 0){ + AliESDtrackCuts *esdTrackCuts = 0x0; + gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/CreateTrackCutsPWGJE.C"); + + //} + + + + //------------------------------------------------------- + // Init the task and do settings + //------------------------------------------------------- + +// TString name(Form("Spectra_%s", nJets)); + TString name(Form("Spectra_%s_%s%s", nJets, nrho, tag)); + AliAnalysisTaskEmcalJetFlavourTagExample *spectratask = new AliAnalysisTaskEmcalJetFlavourTagExample(name); + spectratask->SetJetsName(nJets); + spectratask->SetClusName(nClusters); + spectratask->SetAnaType(type); + spectratask->SetRhoName(nrho); + spectratask->SetJetPhi(minPhi,maxPhi); + spectratask->SetJetEta(minEta,maxEta); + spectratask->SetJetAreaCut(minArea); + spectratask->SetTracksName(nTracks); + spectratask->SetJetPt(hiPTjet); + spectratask->SetTrackPtCut(trptcut); + spectratask->SetTrackEta(trketa); + spectratask->SetTrackCuts(esdTrackCuts); + //spectratask->SetDataType(isESD); + + // =================== set up containers ================================================ + + + AliParticleContainer *trackCont = spectratask->AddParticleContainer(nTracks); + if(trackCont){ + trackCont->SetClassName("AliVTrack"); + trackCont->SetParticleEtaLimits(-0.9,0.9); + trackCont->SetParticlePhiLimits(1.4,3.2); + } + + AliClusterContainer *clusterCont = spectratask->AddClusterContainer(nClusters); + + AliParticleContainer *trackJetCont = spectratask->AddParticleContainer(nTracks); + if(trackJetCont){ + trackJetCont->SetClassName("AliVTrack"); + trackJetCont->SetParticleEtaLimits(-0.9,0.9); + //trackJetCont->SetParticlePhiLimits(1.4,3.2); + } + + AliClusterContainer *clusterJetCont = spectratask->AddClusterContainer(nClusters); + + + TString strType(typeDET); + AliJetContainer *jetCont = spectratask->AddJetContainer(nJets,strType,jetradius); + if(jetCont) { + jetCont->SetRhoName(nrho); + jetCont->ConnectParticleContainer(trackJetCont); + jetCont->ConnectClusterContainer(clusterJetCont); + //jetCont->ConnectParticleContainer(trackCont); + //jetCont->ConnectClusterContainer(clusterCont); + //jetCont->SetZLeadingCut(0.98,0.98); + jetCont->SetPercAreaCut(jetareacut); // 0.6 + jetCont->SetJetPtCut(jetptcut); + //jetCont->SetLeadingHadronType(leadhadtype); + } + + //------------------------------------------------------- + // Final settings, pass to manager and set the containers + //------------------------------------------------------- + + mgr->AddTask(spectratask); + + // Create containers for input/output + mgr->ConnectInput (spectratask, 0, mgr->GetCommonInputContainer() ); + AliAnalysisDataContainer *cospectra = mgr->CreateContainer(name, + TList::Class(), + AliAnalysisManager::kOutputContainer, + outfilename); + mgr->ConnectOutput(spectratask,1,cospectra); + + return spectratask; +} + diff --git a/PWGJE/PWGJEFlavourJetTasksLinkDef.h b/PWGJE/PWGJEFlavourJetTasksLinkDef.h index 12fc64bda93..e5b3b088416 100644 --- a/PWGJE/PWGJEFlavourJetTasksLinkDef.h +++ b/PWGJE/PWGJEFlavourJetTasksLinkDef.h @@ -21,5 +21,6 @@ #pragma link C++ class AliAnalysisTaskSEPicoV0Filter+; #pragma link C++ class AliAnalysisTaskSEPicoV0Maker+; #pragma link C++ class AliAnalysisTaskSEPicoV0MakerMC+; +#pragma link C++ class AliAnalysisTaskEmcalJetFlavourTagExample+; #endif -- 2.39.3