void run(const Char_t *files=NULL, Bool_t mc=kFALSE, Bool_t tpid=kTRUE, Bool_t tchg=kFALSE, Bool_t tpp=kTRUE, Long64_t nev=1234567890, Long64_t first = 0)
{
TStopwatch timer;
timer.Start();
// VERY GENERAL SETTINGS
//AliLog::SetGlobalLogLevel(AliLog::kError);
if(gSystem->Load("libANALYSIS.so")<0) return;
if(gSystem->Load("libANALYSISalice.so")<0) return;
if(gSystem->Load("libTender.so")<0) return;
if(gSystem->Load("libTenderSupplies.so")<0) return;
// if(gSystem->Load("libMES.so")<0) return;
if(gSystem->Load("libPWGLFspectra.so")<0) return;
// DEFINE DATA CHAIN
TChain *chain = NULL;
if(!files) chain = MakeChainLST();
else chain = MakeChainLST(files);
if(!chain) return;
chain->Lookup();
chain->GetListOfFiles()->Print();
Long64_t nfound=chain->GetEntries();
printf("\tENTRIES FOUND [%lli] REQUESTED [%lli]\n", nfound, nev>nfound?nfound:nev);
// BUILD ANALYSIS MANAGER
AliAnalysisManager *mgr = new AliAnalysisManager("Multiplicity and Event Shape");
AliESDInputHandler *esdH = new AliESDInputHandler();
AliMCEventHandler *mcH(NULL);
mgr->SetInputEventHandler(esdH);
if(mc) mgr->SetMCtruthEventHandler(mcH = new AliMCEventHandler());
//mgr->SetDebugLevel(10);
mgr->SetSkipTerminate(kTRUE);
// LOAD tasks
// ******************* PID response ******************
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
if(!mc) AddTaskPIDResponse();
else AddTaskPIDResponse(kTRUE,kTRUE,kTRUE,2);
// ******************* Tenders ***********************
AliTender *aliTender(NULL);
gROOT->LoadMacro("$ALICE_PHYSICS/TENDER/TenderSupplies/AddTaskTender.C");
if(!mc){ // for DATA
aliTender = (AliTender*)AddTaskTender(!mc, kTRUE, kTRUE, kTRUE, kTRUE, kFALSE, kTRUE, kFALSE, kFALSE);
// (useV0, useTPC, !!! useTOF=kFALSE for MC !!!, useTRD, usePID, useVTX, useT0, useEmc, usePtFix)
} else { // for MC
aliTender = (AliTender*)AddTaskTender(!mc, kTRUE, kFALSE, kTRUE, kTRUE, kTRUE, kTRUE, kFALSE, kFALSE); // (useV0, useTPC, !!! useTOF=kFALSE for MC !!!, useTRD, usePID, useVTX, useT0, useEmc, usePtFix)
}
aliTender->SetHandleOCDB(kTRUE);
//aliTender->SetDefaultCDBStorage(Form("alien://folder=/alice/data/2010/OCDB?cacheFolder=%s/local", gSystem->ExpandPathName("$HOME")));
// aliTender->SetDefaultCDBStorage(Form("local://%s/local/alice/data/2010/OCDB", gSystem->ExpandPathName("$HOME")));
// ******************* Physics Selection *************
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(mc); // 0 = real data; 1 = MC
// ******************* MES Tender ******************
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMEStender.C");
AddMEStender(mc);
// ******************* MES PID task ******************
if(tpid){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESpidTask.C");
AddMESpidTask(mc);
}
//
// // ******************* MES CHG task ******************
if(tchg){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESchgTask.C");
AddMESchgTask(mc);
}
//
// // ******************* MES ppCol task ******************
if(tpp){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESppColTask.C");
AddMESppColTask(mc);
}
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
mgr->StartAnalysis("local", chain, nev, first);
timer.Stop();
timer.Print();
// verbosity
printf("\tCLEANING TASK LIST:\n");
mgr->GetTasks()->Delete();
if(mcH) delete mcH;
delete esdH;
delete chain;
}
//______________________________________________________________________________
void AddAnalysisTasks(UInt_t config)
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
mgr->SetCommonFileName("QAresults.root");
//
// Event Statistics (Jan Fiete)
//
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
mgr->RegisterExtraFile("event_stat.root");
//
// Tender and supplies
//
if (config & kTender) {
gROOT->LoadMacro("$ALICE_ROOT/TENDER/TenderSupplies/AddTaskTender.C");
AliAnalysisTaskSE *tender = AddTaskTender();
// SelectCollisionCandidates ?? Tender has to derive from TaskSE
tender->SelectCollisionCandidates();
tender->SetDebugLevel(2);
}
// AOD creation with collision events
if (config & kAOD) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
mgr->RegisterExtraFile("AliAOD.Muons.root");
mgr->RegisterExtraFile("AliAOD.Dimuons.root");
AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kFALSE, kTRUE, kTRUE, doEventStat);
}
// TPC QA (E. Sicking)
//
if (config & kCar00) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0);
taskqasim->SelectCollisionCandidates();
}
//
// VZERO QA (C. Cheshkov)
//
if (config & kCar01) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
// Vertexing (A. Dainese)
//
if (config & kCar02) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD();
taskvertexesd->SelectCollisionCandidates();
}
//
// SPD (A. Mastroserio)
//
if (config & kCar03) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSE* taskspdqa = AddTaskSPDQA();
taskspdqa->SelectCollisionCandidates();
}
//
// SDD (F. Prino)
//
if (config & kCar04) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates();
}
//
// SSD dEdx (Marek Chojnacki)
//
if (config & kCar05) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates();
}
// FMD (Hans Hjersing Dalsgaard)
//
if (config & kCar06) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskFMD.C");
AliAnalysisTaskSE* taskfmd = AddTaskFMD();
taskfmd->SelectCollisionCandidates();
}
//
// ITS
//
if (config & kCar07) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(kFALSE);
}
//
// TPC (Jacek Otwinowski)
//
if (config & kCar08) {
gROOT->LoadMacro("$(ALICE_ROOT)/PWGPP/TPC/macros/AddTaskPerformanceTPCQA.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPCQA(kFALSE, kTRUE);
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(config & kCar09) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
AddTrainPerformanceTRD("ALL");
}
//
// Calorimetry (Gustavo Conesa)
//
if(config & kCar10) {
gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/QA/AddTaskCalorimeterQA.C");
AliAnalysisTaskParticleCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", kTRUE, kFALSE);
taskCaloQA->SetDebugLevel(0);
}
//
// Muon Trigger
//
if(config & kCar11) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
//
// Muon Efficiency
//
/*
if(doMUONEff) {
gROOT->LoadMacro("$ALICE_ROOT/PWG3/muondep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff *taskMuonTrackEff = AddTaskMUONTrackingEfficiency();
}
//
// V0-Decay Reconstruction (Ana Marin)
//
if (doV0) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kFALSE);
}
*/
}
TString Setup
(
Int_t nmix,
const char *options,
const char *outputFileName,
const char *macroPath = "."
)
{
// prepare output
TString out("");
//
// === EXAMINE OPTIONS ==========================================================================
//
// this is done using the utility 'RsnOptions.C'
// which provides a unique way to interpret them
TString opt(options);
opt.ToUpper();
Bool_t isMC = opt.Contains("MC") || (!opt.Contains("DATA"));
Bool_t isPP = opt.Contains("PP") || (!opt.Contains("PBPB"));
Bool_t isESD = opt.Contains("ESD");
Bool_t useTender = opt.Contains("Tender");
Bool_t noV0 = opt.Contains("NOV0");
//
// === LOAD LIBRARIES ===========================================================================
//
// load analysis libraries
gSystem->Load("libCore");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libMinuit");
gSystem->Load("libPhysics");
gSystem->Load("libTree");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libEventMixing");
gSystem->Load("libCORRFW");
gSystem->Load("libPWGLFresonances");
// tender-related libraries
if (isESD && useTender) {
::Info("AnalysisSetup", "Loading tender libraries");
gSystem->Load("libTender");
gSystem->Load("libTenderSupplies");
} else if (!isESD) {
useTender = kFALSE;
}
// load development RSN library
if (!AliAnalysisAlien::SetupPar("PWGLFresonances.par")) return "";
//
// === CREATE ANALYSIS MANAGER ==================================================================
//
AliAnalysisManager *mgr = new AliAnalysisManager("RsnAnalysisManager");
mgr->SetCommonFileName(outputFileName);
::Info("AnalysisSetup", "Common file name: %s", outputFileName);
//
// === INPUT / OUTPUT HANDLER CONFIGURATION =====================================================
//
if (isESD) {
out = "esdTree";
::Info("AnalysisSetup", "Creating ESD handler");
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
if (isMC) {
::Info("AnalysisSetup", "Creating MC handler");
AliMCEventHandler *mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
}
} else {
out = "aodTree";
::Info("AnalysisSetup", "Creating AOD handler");
AliAODInputHandler *aodHandler = new AliAODInputHandler();
mgr->SetInputEventHandler(aodHandler);
}
//
// === Tender TASK (ESD only -- optional) =======================================================
//
if (isESD && useTender) {
::Info("AnalysisSetup", "Adding tender (and then accepting V0 info)", options);
gROOT->LoadMacro(Form("%s/AddTaskTender.C", macroPath));
AddTaskTender();
noV0 = kFALSE;
}
//
// === PHYSICS SELECTION (ESD only) =============================================================
//
if (isESD) {
::Info("AnalysisSetup", "Add physics selection by default on ESD analysis");
gROOT->LoadMacro("$(ALICE_PHYSICS)/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC);
if (noV0) {
::Info("AnalysisSetup", "Skip of V0 info is required");
physSelTask->GetPhysicsSelection()->SetSkipV0(kTRUE);
}
}
//
// === CENTRALITY/PLANE (ESD only) ==============================================================
//
if (isESD && !isPP) {
::Info("AnalysisSetup", "Add centrality and event plane computation tasks");
gROOT->LoadMacro("$(ALICE_PHYSICS)/OADB/macros/AddTaskCentrality.C");
gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskEventplane.C");
AliCentralitySelectionTask* taskCentrality = (AliCentralitySelectionTask*)AddTaskCentrality();
if (isMC) {
::Info("AnalysisSetup", "Setting centrality computation for MC");
taskCentrality->SetMCInput();
}
AddTaskEventplane();
}
//
// === PID RESPONSE =============================================================================
//
gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskPIDResponse.C");
AddTaskPIDResponse(isMC,kTRUE,kTRUE);
//gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskPIDqa.C ");
//AddTaskPIDqa();
//
// === OTHER TASKS ==============================================================================
//
// add RSN task
gROOT->LoadMacro(Form("%s/AddTaskLStarPPb.C", macroPath));
if (!AddTaskLStarPPb(isMC, isPP, macroPath, nmix)) return "";
::Info("AnalysisSetup", "Setup successful");
return out;
}
//______________________________________________________________________________
void AddAnalysisTasks(const char *cdb_location)
{
// Add all analysis task wagons to the train
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
//
// Tender and supplies. Needs to be called for every event.
//
AliAnalysisManager::SetCommonFileName("AODQA.root");
if (useTender) {
gROOT->LoadMacro("$ALICE_PHYSICS/ANALYSIS/TenderSupplies/AddTaskTender.C");
// IF V0 tender needed, put kTRUE below
AliAnalysisTaskSE *tender = AddTaskTender(useV0tender);
// tender->SetDebugLevel(2);
}
// Clean Geometry: Ruben
// gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/CalibMacros/commonMacros/CleanGeom.C++");
// CleanGeom* clgmTask = new CleanGeom("cleanGeom");
// mgr->AddTask(clgmTask);
// AliAnalysisDataContainer *dummyInp = mgr->GetCommonInputContainer();
// if (dummyInp) mgr->ConnectInput(clgmTask,0,dummyInp);
//
// PIDResponse(JENS)
//
if (doPIDResponse) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
// PIDResponse->SetUserDataRecoPass(1);
// PIDResponse->SelectCollisionCandidates(AliVEvent::kAny);
}
//
// PIDqa(JENS)
//
if (doPIDqa) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
PIDQA->SelectCollisionCandidates(AliVEvent::kAny);
}
// CDB connection
//
if (doCDBconnect && !useTender) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C");
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, 0 /*run_number*/);
if (!taskCDB) return;
AliCDBManager *cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage(cdb_location);
// taskCDB->SetRunNumber(run_number);
}
if (usePhysicsSelection) {
// Physics selection task
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
mgr->RegisterExtraFile("event_stat.root");
AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(useMC);
mgr->AddStatisticsTask(AliVEvent::kAny);
}
//Jacek
if (iPWGPP) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFilteredTree.C");
AddTaskFilteredTree("FilterEvents_Trees.root");
}
// Centrality
if (useCentrality) {
if ( run_flag >= 1500 )
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
AliMultSelectionTask *taskMult = AddTaskMultSelection();
}
else
{
// old scheme is only valid for PbPb
if ( iCollision == kPbPb )
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
//taskCentrality->SelectCollisionCandidates(AliVEvent::kAny);
}
}
}
// --- PWGLF - Forward ([email protected]) -----------------------------
if (iPWGLFForward && usePhysicsSelection) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskForwardMult.C");
UShort_t pwglfForwardSys = 0; // iCollision+1; // pp:1, PbPb:2, pPb:3
UShort_t pwglfSNN = 0; // GeV, 0==unknown
Short_t pwglfField = 0;
AddTaskForwardMult(useMC && useTR, // Need track-refs
pwglfForwardSys, // Collision system
pwglfSNN,
pwglfField);
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskCentralMult.C");
AddTaskCentralMult(useMC, pwglfForwardSys, pwglfSNN, pwglfField);
}
//PWGAgammaconv
if (iPWGGAgammaconv) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/GammaConv/macros/AddTask_ConversionAODProduction.C");
Int_t dataset=iCollision;
if( iCollision == kXeXe) dataset=kPbPb;
if( iCollision == kPbp || iCollision == kpPb ) dataset=2;
AliAnalysisTask *taskconv = AddTask_ConversionAODProduction(dataset, kFALSE, periodName);
mgr->RegisterExtraFile("AliAODGammaConversion.root");
}
if (iESDfilter)
{
// ESD filter task configuration.
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/ESDfilter/macros/AddTaskESDFilter.C");
if (iMUONcopyAOD) {
printf("Registering delta AOD file\n");
mgr->RegisterExtraFile("AliAOD.Muons.root");
}
Bool_t muonWithSPDTracklets = (iCollision==kPbPb || iCollision==kXeXe) ? kFALSE : kTRUE; // add SPD information to muon AOD only for pp
AliAnalysisTaskESDfilter *taskesdfilter =
AddTaskESDFilter(useKFILTER,
iMUONcopyAOD, // write Muon AOD
kFALSE, // write dimuon AOD
kFALSE, // usePhysicsSelection
kFALSE, // centrality OBSOLETE
kTRUE, // enable TPS only tracks
kFALSE, // disable cascades
kFALSE, // disable kinks
run_flag, // run flag (YY00)
3, // muonMCMode
//kTRUE, // useV0Filter
kFALSE, // useV0Filter - turned off for PCM to make sense
muonWithSPDTracklets,
isMuonCaloPass,
iPWGGAgammaconv); // Add PCMV0
AliEMCALGeometry::GetInstance("","");
}
// ********** PWG3 wagons ******************************************************
// PWGHF vertexing
if (iPWGHFvertexing)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C");
Int_t configHF=0;
if(iCollision == kPbPb || iCollision == kXeXe) configHF=1;
AliAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF(configHF,train_name,"",run_number,periodName);
// Now we need to keep in sync with the ESD filter
if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "AliAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("AliAOD.VertexingHF.root");
taskvertexingHF->SelectCollisionCandidates(0);
}
// PWGDQ JPSI filtering (only pp)
if (iPWGDQJPSIfilter && (iCollision==kpp)) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C");
AliAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter();
if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "AliAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("AliAOD.Dielectron.root");
taskJPSIfilter->SelectCollisionCandidates(0);
}
// PWGHF D2h
if (iPWGHFd2h)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/vertexingHF/AddD2HTrain.C");
AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0);
}
// ********** PWG4 wagons ******************************************************
// Jet analysis
// Configurations flags, move up?
TString kDeltaAODJetName = "AliAOD.Jets.root"; //
Bool_t kIsPbPb = (iCollision==kPbPb || iCollision==kXeXe);
TString kDefaultJetBackgroundBranch = "";
TString kJetSubtractBranches = "";
UInt_t kHighPtFilterMask = 272;// from esd filter
UInt_t iPhysicsSelectionFlag = 0;
if (iJETAN) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJets.C");
// Default jet reconstructor running on ESD's
AliAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
if (!taskjets) ::Fatal("AnalysisTrainNew", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
if (iJETANdelta) {
// AddTaskJetsDelta("AliAOD.Jets.root"); // need to modify this accordingly in the add task jets
mgr->RegisterExtraFile(kDeltaAODJetName.Data());
TString cTmp("");
if(kIsPbPb){
// UA1 intrinsic background subtraction
taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
// SICONE
taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later....
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
cTmp = taskjets->GetNonStdBranch();
if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
// Add the clusters..
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJetCluster.C");
AliAnalysisTaskJetCluster *taskCl = 0;
Float_t fCenUp = 0;
Float_t fCenLo = 0;
Float_t fTrackEtaWindow = 0.9;
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetNRandomCones(10);
taskCl->SetCentralityCut(fCenLo,fCenUp);
taskCl->SetGhostEtamax(fTrackEtaWindow);
kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
taskCl->SetNRandomCones(10);
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
// DO THE BACKGROUND SUBTRACTION
if(kIsPbPb&&kJetSubtractBranches.Length()){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJetBackgroundSubtract.C");
AliAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d");
taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
}
}
}
//______________________________________________________________________________
void AddAnalysisTasks(){
// Add all analysis task wagons to the train
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
//
// Tender and supplies. Needs to be called for every event.
//
IlcAnalysisManager::SetCommonFileName("AODQA.root");
if (useTender) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/TenderSupplies/AddTaskTender.C");
// IF V0 tender needed, put kTRUE below
IlcAnalysisTaskSE *tender = AddTaskTender(useV0tender);
// tender->SetDebugLevel(2);
}
if (usePhysicsSelection) {
// Physics selection task
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
mgr->RegisterExtraFile("event_stat.root");
IlcPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(useMC);
// IlcOADBPhysicsSelection * oadbDefaultPbPb = CreateOADBphysicsSelection();
// physSelTask->GetPhysicsSelection()->SetCustomOADBObjects(oadbDefaultPbPb,0,0);
mgr->AddStatisticsTask(IlcVEvent::kAny);
}
// Centrality (only Pb-Pb)
if (iCollision && useCentrality) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
IlcCentralitySelectionTask *taskCentrality = AddTaskCentrality();
taskCentrality->SelectCollisionCandidates(IlcVEvent::kAny);
}
if (iESDfilter) {
// ESD filter task configuration.
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
if (iMUONcopyAOD) {
printf("Registering delta AOD file\n");
mgr->RegisterExtraFile("IlcAOD.Muons.root");
mgr->RegisterExtraFile("IlcAOD.Dimuons.root");
IlcAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, kTRUE, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,IlcESDpid::kTOF_T0,kTRUE,kFALSE,kFALSE,run_flag);
} else {
IlcAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, kFALSE, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,IlcESDpid::kTOF_T0,kTRUE,kFALSE,kFALSE,run_flag); // others
}
}
// ********** PWG3 wagons ******************************************************
// PWGHF vertexing
if (iPWGHFvertexing) {
gROOT->LoadMacro("$ILC_ROOT/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C");
if (!iPWGHFd2h) TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
IlcAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF();
if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "IlcAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("IlcAOD.VertexingHF.root");
taskvertexingHF->SelectCollisionCandidates(0);
}
// PWGDQ JPSI filtering (only pp)
if (iPWGDQJPSIfilter && (iCollision==0)) {
gROOT->LoadMacro("$ILC_ROOT/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C");
IlcAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter();
if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "IlcAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("IlcAOD.Dielectron.root");
taskJPSIfilter->SelectCollisionCandidates(0);
}
// PWGHF D2h
if (iPWGHFd2h) {
gROOT->LoadMacro("$ILC_ROOT/PWGHF/vertexingHF/AddD2HTrain.C");
TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0);
}
// ********** PWG4 wagons ******************************************************
// Jet analysis
// Configurations flags, move up?
TString kDeltaAODJetName = "IlcAOD.Jets.root"; //
Bool_t kIsPbPb = (iCollision==0)?false:true; // can be more intlligent checking the name of the data set
TString kDefaultJetBackgroundBranch = "";
TString kJetSubtractBranches = "";
UInt_t kHighPtFilterMask = 128;// from esd filter
UInt_t iPhysicsSelectionFlag = IlcVEvent::kMB;
if (iJETAN) {
gROOT->LoadMacro("$ILC_ROOT/PWGJE/macros/AddTaskJets.C");
// Default jet reconstructor running on ESD's
IlcAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
if (!taskjets) ::Fatal("AnalysisTrainNew", "IlcAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
if (iJETANdelta) {
// AddTaskJetsDelta("IlcAOD.Jets.root"); // need to modify this accordingly in the add task jets
mgr->RegisterExtraFile(kDeltaAODJetName.Data());
TString cTmp("");
if(kIsPbPb){
// UA1 intrinsic background subtraction
taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
// SICONE
taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later....
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
cTmp = taskjets->GetNonStdBranch();
if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
// Add the clusters..
gROOT->LoadMacro("$ILC_ROOT/PWGJE/macros/AddTaskJetCluster.C");
IlcAnalysisTaskJetCluster *taskCl = 0;
Float_t fCenUp = 0;
Float_t fCenLo = 0;
Float_t fTrackEtaWindow = 0.9;
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetNRandomCones(10);
taskCl->SetCentralityCut(fCenLo,fCenUp);
taskCl->SetGhostEtamax(fTrackEtaWindow);
kDefaultJetBackgroundBranch = Form("%s_%s",IlcAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
taskCl->SetNRandomCones(10);
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
// DO THE BACKGROUND SUBTRACTION
if(kIsPbPb&&kJetSubtractBranches.Length()){
gROOT->LoadMacro("$ILC_ROOT/PWGJE/macros/AddTaskJetBackgroundSubtract.C");
IlcAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d");
taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
}
}
}
