void run(Char_t* data, Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 0, Bool_t isMC = 0,
Int_t centrBin = 0, const char * centrEstimator = "VOM", Int_t useOtherCentralityCut = 0, Int_t trackMin=0, Int_t trackMax=10000,
const char* option = "",TString customSuffix = "", Int_t workers = -1, Bool_t useSingleBin=kTRUE, const char * runList = 0)
{
// runMode:
//
// 0 local
// 1 proof
if (nev < 0)
nev = 1234567890;
InitAndLoadLibs(runMode,workers,debug);
// Create the analysis manager
mgr = new AliAnalysisManager;
// Add ESD handler
AliESDInputHandler* esdH = new AliESDInputHandler;
// Do I need any of this?
esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks");
mgr->SetInputEventHandler(esdH);
if(isMC) {
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetPreReadMode(AliMCEventHandler::kLmPreRead);
mgr->SetMCtruthEventHandler(handler);
}
// Parse option strings
TString optionStr(option);
// remove SAVE option if set
// This is copied from a macro by Jan. The reason I kept it is that I may want to pass textual options to the new task at some point
Bool_t doSave = kFALSE;
TString optionStr(option);
if (optionStr.Contains("SAVE"))
{
optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
doSave = kTRUE;
}
AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE);
TString pathsuffix = "";
if(!useSingleBin) pathsuffix += "_AllCentr";
if (optionStr.Contains("DCA")) {
delete cuts;
// cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
cout << ">>>> USING DCA cut" << endl;
cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
cuts->SetMaxChi2TPCConstrainedGlobal(); // remove golden cut
pathsuffix+="_DCAcut";
}
if (optionStr.Contains("ITSsa")) {
delete cuts;
cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
cout << ">>>> USING ITS sa tracks" << endl;
pathsuffix+="_ITSsa";
}
if (optionStr.Contains("TPC")) {
delete cuts;
cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
cout << ">>>> USING TPC only tracks" << endl;
pathsuffix+="_TPC";
}
if(optionStr.Contains("NoElectrons")) pathsuffix +="_NoElectrons";
Bool_t useMCKinematics = isMC;
if (optionStr.Contains("NOMCKIN")) {
cout << ">>>> Ignoring MC kinematics" << endl;
useMCKinematics=kFALSE;
pathsuffix+="_NOMCKIN";
}
// If we are running on grid, we need the alien handler
if (runMode == kMyRunModeGRID) {
// Create and configure the alien handler plugin
gROOT->LoadMacro("CreateAlienHandler.C");
AliAnalysisGrid *alienHandler = CreateAlienHandler(data, runList, pathsuffix.Data(), listToLoad, "full", isMC); // full
if (!alienHandler) {
cout << "Cannot create alien handler" << endl;
exit(1);
}
mgr->SetGridHandler(alienHandler);
}
// Add tasks
// physics selection
gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
physicsSelectionTask = AddTaskPhysicsSelection(isMC);
//PID
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AddTaskPIDResponse(isMC);
// // PID QA:
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
// AddTaskPIDqa();
// Centrality
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentr = AddTaskCentrality();
// OBSOLETE
const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root";
const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root";
// END of OBSOLETE
if(isMC) taskCentr-> SetMCInput();
taskCentr->SetPass(2);
// Create my own centrality selector
AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector();
centrSelector->SetIsMC(isMC);
centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only
centrSelector->SetCentralityBin(centrBin);
if (!useSingleBin) centrSelector->SetCentralityBin(0); // FIXME: ok?
centrSelector->SetCentralityEstimator(centrEstimator);
if(useOtherCentralityCut == 1){
cout << "Setting centrality by MULT" << endl;
centrSelector->SetUseMultRange();
centrSelector->SetMultRange(trackMin,trackMax);
}
if(useOtherCentralityCut == 2){
cout << "Setting centrality by V0" << endl;
centrSelector->SetUseV0Range();
centrSelector->SetMultRange(trackMin,trackMax);
}
if(useOtherCentralityCut == 3){
cout << "Setting centrality by SPD outer" << endl;
centrSelector->SetUseSPDOuterRange();
centrSelector->SetMultRange(trackMin,trackMax);
}
// load my task
if (useSingleBin) {
gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C");
AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector);
task->SetIsMC(useMCKinematics);
task->SetOfflineTrigger(AliVEvent::kMB);
if(optionStr.Contains("TPC")) task->SetTPCOnly();
if(optionStr.Contains("NoElectrons")) task->RejectElectrons(kTRUE);
if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC");
if(customSuffix!=""){
cout << "Setting custom suffix: " << customSuffix << endl;
task->GetHistoManager()->SetSuffix(customSuffix);
}
} else {
gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracksAllCentrality.C");
centrSelector->SetUseV0Range(kTRUE);
Int_t ncentr = 11;
const Float_t minCentr[] = {0 ,79 ,239,559 ,1165,2135,3555,5525,8213 ,12191,15079};
const Float_t maxCentr[] = {79,239,559,1165,2135,3555,5525,8213,12191,15079,21000};
AliAnalysisTaskMultPbTracks ** tasks = AddTaskMultPbPbTracksAllCentrality("multPbPbtracks.root", cuts, centrSelector, ncentr,minCentr,maxCentr);
for(Int_t icentr = 0; icentr < ncentr; icentr++){
tasks[icentr]->Print();
cout << "MC KINEMATICS:" << useMCKinematics << endl;
tasks[icentr]->SetIsMC(useMCKinematics);
tasks[icentr]->SetOfflineTrigger(AliVEvent::kMB);
if(optionStr.Contains("TPC")) tasks[icentr]->SetTPCOnly();
if(optionStr.Contains("NoElectrons")) task[icentr]->RejectElectrons(kTRUE);
if(useMCKinematics) tasks[icentr]->GetHistoManager()->SetSuffix("MC");
if(customSuffix!=""){
cout << "Setting custom suffix: " << customSuffix+long(icentr) << endl;
tasks[icentr]->GetHistoManager()->SetSuffix(customSuffix+long(icentr));
}
}
}
// Init and run the analy
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
if (runMode == kMyRunModeLocal ) {
// If running in local mode, create chain of ESD files
cout << "RUNNING LOCAL, CHAIN" << endl;
TChain * chain = GetAnalysisChain(data);
chain->Print();
mgr->StartAnalysis("local",chain,nev);
} else if (runMode == kMyRunModeProofLite) {
TChain * chain = GetAnalysisChain(data);
mgr->StartAnalysis("proof",chain,nev);
}
else if (runMode == kMyRunModeCAF) {
mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev);
} else if (runMode == kMyRunModeGRID) {
mgr->StartAnalysis("grid");
} else {
cout << "ERROR: unknown run mode" << endl;
}
if (!useOtherCentralityCut) {
pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin);
} else if(useOtherCentralityCut==1){
pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax);
} else if(useOtherCentralityCut==2){
pathsuffix = pathsuffix + "_V0Range_" + long(trackMin) + "_" + long(trackMax);
} else if(useOtherCentralityCut==3){
pathsuffix = pathsuffix + "_SPDOutRange_" + long(trackMin) + "_" + long(trackMax);
}
pathsuffix += customSuffix;
if (doSave) MoveOutput(data, pathsuffix.Data());
}
//________________________________________________________________
void runAAF(Int_t nFilesMax, char* type, char* textFileName, Int_t task)
{
Int_t analysisMC = 0;
Bool_t debug = kTRUE;
Bool_t readTR = kFALSE;
Bool_t esdAna = kTRUE; // run ESD analysis (kTRUE) or AOD analysis (kFALSE)
Int_t runtype = -1;
if(strstr(type,"aod") != NULL) {
esdAna = kFALSE;; // AOD analysis
cout << "Performing AOD analysis" << endl;
} else
cout << "Performing ESD analysis" << endl;
const Char_t* treeName = GetTreeName(esdAna);
if(strstr(type,"PbPb") != NULL) runtype = 2; // PbPb
if(strstr(type,"pp") != NULL) runtype = 3; // pp
if(strstr(type,"900") != NULL){ // 900GeV pp
if(runtype != -1){
printf("conflicting run types\n");
return;
}
runtype = 1;
}
if(runtype == -1) runtype = 0; // 7TeV pp
char *test;
test = strstr(type,"MC");
if(test != NULL){
analysisMC = kTRUE;
cout << "Test: " << test << endl;
if(sscanf(test,"MC%d",&analysisMC)){
// cout << "**************" << analysisMC << endl;
if(!analysisMC) analysisMC = 1;
}
}
cout << "MonteCarlo " << analysisMC << endl;
const char* alirootver = "v5-02-17-AN";
Int_t mode = -1; // mode 1: PROOF, 2: GRID, 0: LOCAL
printf("===================================================================\n");
if(strstr(type,"proof") != NULL){
if(mode != -1){
printf("===== CONFLICTING TYPES =====\n");
return;
}
mode = 1;
printf("=============== RUNNING ANALYSIS IN CAF MODE ================\n");
}
if(strstr(type,"grid") != NULL){
if(mode != -1){
printf("===== CONFLICTING TYPES =====\n");
return;
}
printf("=============== RUNNING ANALYSIS IN GRID MODE ================\n");
mode = 2;
}
if(strstr(type,"local") != NULL || mode<0){
if(mode != -1){
printf("===== CONFLICTING TYPES =====\n");
return;
}
printf("=============== RUNNING ANALYSIS IN LOCAL MODE ================\n");
mode = 0;
}
printf("===================================================================\n");
printf("===================================================================\n");
if (analysisMC) printf(":: use MC TRUE\n");
else printf(":: use MC FALSE\n");
if (readTR) printf(":: read TR TRUE\n");
else printf(":: read TR FALSE\n");
if (debug) printf(":: debugging TRUE\n");
else printf(":: debugging FALSE\n");
Char_t taskname[128];
switch(task){
case 1:
sprintf(taskname,"HighPtDeDxCosmic");
break;
case 2:
sprintf(taskname,"HighPtDeDx");
break;
case 3:
sprintf(taskname,"HighPtDeDxV0");
break;
case 4:{
sprintf(taskname,"EffDecomposition");
}
break;
default:
printf("Unknown task\n");
return;
}
Char_t nameouputfiles[1280]={0};
if(runtype ==2){
for(Int_t i=0;i<6;++i){
//Char_t tmpname[128]={0};
sprintf(nameouputfiles,"%s %s_Tree_%1.0f_%1.0f.root",nameouputfiles,taskname,minCent[i],maxCent[i]);
}
}
if(runtype ==3){
sprintf(nameouputfiles,"%s %s_Tree.root",taskname);
}
cout<<"Files to be stored:"<<nameouputfiles<<endl;
// Load common libraries
gSystem->Load("libTree.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libGeom.so");
gSystem->Load("libVMC.so");
gSystem->Load("libSTEERBase.so");
gSystem->Load("libESD.so");
gSystem->Load("libAOD.so");
gSystem->Load("libCDB.so");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
// tender
gROOT->ProcessLine(Form(".include %s/include", gSystem->ExpandPathName("$ALICE_ROOT")));
cout << "mode " << mode << ", type " << type << endl;
if (mode == 1){
cout << "Connecting to CAF..." << endl;
gEnv->SetValue("XSec.GSI.DelegProxy","2");
//const char* AAF = "*****@*****.**";
const char* AAF = "*****@*****.**";
if(strstr(type,"reset") != NULL)
TProof::Reset(AAF,kFALSE);
// TProof::Reset("*****@*****.**",kTRUE);
// TProof::Open(AAF);
TProof::Open(AAF, "workers=10");
TList *list = new TList();
list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "CDB"));
gProof->EnablePackage(Form("VO_ALICE@AliRoot::%s",alirootver), list);
cout << "Connected to " << AAF << endl;
}
// Load the analysis macro (old version); should be removed when the library will be decided
Char_t loadtask[128];
if(task==4) {
sprintf(loadtask,"AliAnaTaskV0%s.cxx++", taskname);
}else{
sprintf(loadtask,"AliAnalysisTask%s.cxx++", taskname);
}
if(mode == 1){ // PROOF
// switch(task){
// case 1: // ch fluct
// break;
// case 2: // high pt dedx
//gProof->Load("DebugClasses.C++g");
// break;
// case 3: // high pt v0s
// gProof->Load("DebugClasses.C++g");
// break;
// default:
// printf("Unknown task\n");
// return;
// }
gProof->Load(loadtask);
}else{
if(task==2) {
cout << "Analysis task is loaded with AliRoot" << endl;
} else {
gROOT->LoadMacro(loadtask);
}
}
// Make the analysis manager
AliAnalysisManager* mgr = new AliAnalysisManager("PID histos", "testing analysis");
// Dataset
switch(mode){
case 1: // PROOF
TFileCollection* proofColl = gProof->GetDataSet(textFileName);
TFileCollection* stagedColl = proofColl->GetStagedSubset();
TChain* chain = CreateChainCAF(nFilesMax, stagedColl, treeName);
// TChain* chain = CreateChainCAF(nFilesMax, textFileName, treeName, analysisMC);
break;
case 2: // GRID
//gSystem->Setenv("alien_CLOSE_SE", "ALICE::GSI::SE2");
// gSystem->Setenv("alien_CLOSE_SE", "ALICE::NIHAM::FILE");
TGrid::Connect("alien://");
//gSystem->Setenv("alien_CLOSE_SE", "ALICE::GSI::SE2");
// gSystem->Setenv("alien_CLOSE_SE", "ALICE::NIHAM::FILE");
Char_t gridmode[64];
sprintf(gridmode, "full");
if(strstr(type,"term") != NULL)
sprintf(gridmode, "terminate");
if(strstr(type,"off") != NULL)
sprintf(gridmode, "offline");
if(strstr(type,"sub") != NULL)
sprintf(gridmode, "submit");
if(strstr(type,"test") != NULL)
sprintf(gridmode, "test");
gROOT->LoadMacro("CreateAlienHandler.C");
// AliAnalysisGrid *alienHandler = CreateAlienHandler(nFilesMax, analysisMC, runtype, taskname, gridmode);
AliAnalysisGrid *alienHandler = CreateAlienHandler(nFilesMax, analysisMC, esdAna, taskname, nameouputfiles, gridmode, textFileName, alirootver, task);
if (!alienHandler) return;
// DOES NOT WORK BECAUSE THERE ARE NO GETTERS?
// // Here we can add extra files to the plugin
// switch(task){
// case 1: // ch fluct
// break;
// case 2: // high pt dedx
// alienHandler->SetAnalysisSource(Form("DebugClasses.C %s", alienHandler->GetAnalysisSource()));
// alienHandler->SetAdditionalLibs(Form("DebugClasses.C %s", alienHandler->GetAdditionalLibs()));
// break;
// case 3: // high pt v0s
// alienHandler->SetAnalysisSource(Form("DebugClasses.C %s", alienHandler->GetAnalysisSource()));
// alienHandler->SetAdditionalLibs(Form("DebugClasses.C %s", alienHandler->GetAdditionalLibs()));
// break;
// default:
// printf("Unknown task\n");
// return;
// }
// Connect plugin to the analysis manager
mgr->SetGridHandler(alienHandler);
break;
case 0: // LOCAL
// Process data - chain
AliXRDPROOFtoolkit tool;
TChain* chain = tool.MakeChain(textFileName,treeName, 0, 100);
chain->Lookup();
break;
default:
printf("Unknown mode");
return;
}
// ESD input handler
if(esdAna) {
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
} else {
AliAODInputHandler* aodHandler = new AliAODInputHandler();
mgr->SetInputEventHandler(aodHandler);
}
// Monte Carlo handler
if (analysisMC) {
AliMCEventHandler* mcHandler = new AliMCEventHandler();
if(esdAna)
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetReadTR(readTR);
}
// Debug if needed
if (debug)
mgr->SetDebugLevel(3);
// ######### Centrality task ###############
cout<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<endl;
cout<<"esdAna="<<esdAna<<" runtype="<<runtype<<endl;
// ######### PHYSICS SELECTION ###############
if (esdAna) { // PC: 17/8-15: this does not work for AODs.....
cout << "Adding task physics selection" << endl;
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
if (analysisMC) {
AliPhysicsSelection* physSel = physSelTask->GetPhysicsSelection();
physSel->SetAnalyzeMC();
}
}
if(esdAna && runtype==2) { // only for ESD and PbPb
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
//taskCentrality->SetPass(2);
if (analysisMC)
taskCentrality->SetMCInput();
}
// ######### PID task ###############
if(task == 2) {
cout << "Loading macro in AliRoot!" << endl;
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/IdentifiedHighPt/train/macros/AddTask.C");
cout << "Adding task!" << endl;
AliAnalysisTask* taskPid = AddTask(analysisMC, taskname, runtype, kTriggerInt, minCent, maxCent);
} else {
cout << "Adding AliAnaTaskV0EffDecomposition" << endl;
gROOT->LoadMacro("AddTask.C");
AliAnalysisTask* taskPid = AddTask(taskname);
}
// Run the analysis
if (mgr->InitAnalysis()){
mgr->PrintStatus();
switch(mode){
case 1: // PROOF
mgr->StartAnalysis("proof",chain);
break;
case 2: // GRID
mgr->StartAnalysis("grid");
break;
case 0:
mgr->StartAnalysis("local",chain);
break;
default:
printf("Unknown mode\n");
return;
}
}
}
void runNorm(TString inputFileName = "AliAOD.root", Int_t nEvents = 1e6, TString beamConf = "p-Pb", Bool_t isESD = kFALSE, Bool_t isMC = kFALSE, Int_t debugLevel = 0)
{
TStopwatch timer;
timer.Start();
// Check runing mode
Int_t mode = GetMode(inputFileName);
if(mode < 0){
Error("runAnalysis","Please provide either an ESD/AOD root file or a collection of ESDs/AODs.");
return;
}
// Load common libraries
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
gSystem->Load("libSTEERBase");
// gSystem->Load("libSTEER");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libEventMixing");
gSystem->Load("libCORRFW");
gSystem->Load("libPWGmuon");
gSystem->Load("libPWGmuondep");
gSystem->AddIncludePath(Form("-I\"%s/include\" -I\"%s/include\"", gSystem->ExpandPathName("$ALICE_ROOT"),gSystem->ExpandPathName("$ALICE_PHYSICS")));
gROOT->ProcessLine(Form(".include %s/include %s/include", gSystem->ExpandPathName("$ALICE_ROOT"), gSystem->ExpandPathName("$ALICE_PHYSICS")));
// Create input chain
TChain* chain = CreateChain(inputFileName,isESD);
if (!chain) return;
// Create the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("MuonTask");
if ( isESD) {
// ESD input handler
AliESDInputHandler* esdH = new AliESDInputHandler();
esdH->SetReadFriends(kFALSE);
mgr->SetInputEventHandler(esdH);
}
else {
// AOD input handler
AliAODInputHandler* aodH = new AliAODInputHandler();
mgr->SetInputEventHandler(aodH);
}
TString dataType = mgr->GetInputEventHandler()->GetDataType();
Info("runLocal",Form("Manager with %s",dataType.Data()));
// Enable MC event handler for ESDs
if ( isMC && isESD ){
AliVEventHandler* handler = new AliMCEventHandler;
mgr->SetMCtruthEventHandler(handler);
}
// event selection and centrality framework
if ( isESD ){
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physicsSelection = AddTaskPhysicsSelection(isMC);
if ( !physicsSelection ) {
Error("runLocal","AliPhysicsSelectionTask not created!");
return;
}
}
if ( isESD ){
// event centrality
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
if ( !taskCentrality ) {
Error("runLocal on ESD","AliCentralitySelectionTask not created!");
return;
}
if ( isMC ) taskCentrality->SetMCInput();
//taskCentrality->SetPass(1); // remember to set the pass you are processing!!!
}
/*else {
//Only on full AOD, it is possible to reprocess the centrality framework
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(kTRUE,kTRUE);
if ( !taskCentrality ) {
Error("runLocal on AOD","AliCentralitySelectionTask not created!");
return;
}
if ( isMC ) taskCentrality->SetMCInput();
}*/
// Example analysis
// Create task
//Analysis task is on working directory
// gROOT->LoadMacro("AliAnalysisTaskNorm.cxx+g");
// gROOT->LoadMacro("AddTaskNorm.C");
gROOT->LoadMacro("$ALICE_PHYSICS/../src/PWG/muon/AliAnalysisTaskNorm.cxx+g");
gROOT->LoadMacro("$ALICE_PHYSICS/../src/PWG/muon/AddTaskNorm.C");
AliAnalysisTaskNorm* task = AddTaskNorm(isESD,isMC,beamConf);
if (!task) {
Error("runAnalysis","AliAnalysisTaskNorm not created!");
return;
}
task->SetDebugLevel(debugLevel);
// Enable debug printouts
mgr->SetDebugLevel(debugLevel);
// start local analysis
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
if(debugLevel>=2) mgr->SetNSysInfo(100);
mgr->StartAnalysis("local", chain, nEvents);
}
if(debugLevel>=2){
mgr->ProfileTask("Task");
}
timer.Stop();
timer.Print();
}
Bool_t AddTasksEmcalFjetSparseMaker()
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (bIsInfoAOD) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODHandler.C");
AliAODInputHandler *aodIH = AddAODHandler();
} else {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddESDHandler.C");
AliESDInputHandler *esdIH = AddESDHandler();
// esdIH->SetReadFriends(kFALSE);
}
if (bAnaInfoMC && (!bIsInfoAOD)) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddMCHandler.C");
AliMCEventHandler *mctEH = AddMCHandler(kTRUE);
}
if (bOutputAOD) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODOutputHandler.C");
AliAODHandler *aodH = AddAODOutputHandler();
aodH->SetOutputFileName("AliAOD.PicoJets.root");
aodH->SetFillAOD(kTRUE);
aodH->SetCreateNonStandardAOD();
mgr->SetOutputEventHandler(aodH);
}
//=============================================================================
if (bIsPhysSel) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalPhysicsSelection.C");
AliEmcalPhysicsSelectionTask *taksPhysSel = AddTaskEmcalPhysicsSelection(kTRUE, kTRUE, wTriggerMask, 5., 5., 10., kTRUE, -1, -1, -1, -1);
if (bAnaInfoMC) {
AliEmcalPhysicsSelection *pPhysSel = static_cast<AliEmcalPhysicsSelection*>(taksPhysSel->GetPhysicsSelection());
if (!pPhysSel) return kTRUE; pPhysSel->SetAnalyzeMC();
}
}
if (bIsCentSel) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentSel = AddTaskCentrality(kTRUE, bIsAOD);
if (bAnaInfoMC) taskCentSel->SetMCInput();
}
if (bIsEvPnSel) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
AliEPSelectionTask *taskEventPlane = AddTaskEventplane();
if (bAnaInfoMC) taskEventPlane->SetUseMCRP();
}
if (bIsRespPID) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskSE *taskRespPID = AddTaskPIDResponse(bAnaInfoMC);
}
//=============================================================================
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalSetup.C");
AliEmcalSetupTask *taskSetupEMCal = AddTaskEmcalSetup();
taskSetupEMCal->SetGeoPath("$ALICE_PHYSICS/OADB/EMCAL");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalPreparation.C");
AliAnalysisTaskSE *taskEmcMaker = AddTaskEmcalPreparation(sPeriodIn);
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskJetPreparation.C");
AliAnalysisTaskSE *taskHadCorr = AddTaskJetPreparation(sPeriodIn.Data(),
sUsedTrksRD.Data(),
(bAnaInfoMC ? sUsedTrksMC.Data() : ""),
sInputClsRD.Data(),
sUsedClusRD.Data(),
2., 0., 0.03, 0.015, 0.15,
wTriggerMask,
kTRUE, // do trk clus
kTRUE, // histos
kTRUE, // make pico trk
kFALSE, // make trigger
kFALSE, // is EMCal train
1., // track eff
kTRUE, // do AOD track prop
kTRUE, // modify match
kFALSE, // use old bit
kFALSE, // trigger QA
4); // cent bin
//=============================================================================
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
/*AliEmcalJetTask *taskAkt = AddTaskEmcalJet(sUsedTrksRD.Data(),
sUsedClusRD.Data(),
1, // anti-kT
dJetRadius,
nJetType,
dTrkPtCut,
dCluEnCut);*/
//=============================================================================
AliAnalysisTaskEmcalFjetSparseMaker *taskEmcalSM = new AliAnalysisTaskEmcalFjetSparseMaker("AliAnalysisTaskEmcalFjetSM");
//taskEmcalSM->SetForceBeamType(0);
//taskEmcalSM->SetIsPythia(kTRUE);
/*taskEmcalSM->SetCaloTriggerPatchInfoName("EmcalTriggers");
taskEmcalSM->SetTriggerTypeSel(AliAnalysisTaskEmcal::kJ2);
taskEmcalSM->SetMainPatchType(AliAnalysisTaskEmcal::kTriggerLevel1Jet);*/
AliParticleContainer *pContTrks = taskEmcalSM->AddParticleContainer(sUsedTrksRD.Data());
pContTrks->SetParticlePtCut(dTrkPtCut);
AliClusterContainer *pContClus = taskEmcalSM->AddClusterContainer(sUsedClusRD.Data());
pContClus->SetClusPtCut(dCluEnCut);
/*AliJetContainer *pContJets = taskEmcalSM->AddJetContainer(taskAkt->GetName(), sCutType.Data(), dJetRadius);
pContJets->SetPercAreaCut(dJetAreaCut);
pContJets->SetJetPtCut(dJetPtCut);
//pContJets->SetRhoName(sUsedRho.Data());
//pContJets->SetLocalRhoName();
pContJets->SetLeadingHadronType(nLeading);
pContJets->ConnectParticleContainer(taskEmcalSM->GetParticleContainer());
pContJets->ConnectClusterContainer(taskEmcalSM->GetClusterContainer());
pContJets->SetNameTitle(taskEmcalSM->GetNameJet().Data(),
taskEmcalSM->GetNameJet().Data());*/
mgr->AddTask(taskEmcalSM);
mgr->ConnectInput(taskEmcalSM, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(taskEmcalSM, 1, mgr->CreateContainer("listGeneralH",
TList::Class(),
AliAnalysisManager::kOutputContainer,
AliAnalysisManager::GetCommonFileName()));
mgr->ConnectOutput(taskEmcalSM, 2, mgr->CreateContainer("listEmcalEvH",
TList::Class(),
AliAnalysisManager::kOutputContainer,
"AnalysisResults_EmcalEvH.root"));
mgr->ConnectOutput(taskEmcalSM, 3, mgr->CreateContainer("listEmcalTrk",
TList::Class(),
AliAnalysisManager::kOutputContainer,
"AnalysisResults_EmcalTrk.root"));
mgr->ConnectOutput(taskEmcalSM, 4, mgr->CreateContainer("listEmcalClu",
TList::Class(),
AliAnalysisManager::kOutputContainer,
"AnalysisResults_EmcalClu.root"));
/*mgr->ConnectOutput(taskEmcalSM, 5, mgr->CreateContainer("listEmcalJet",
TList::Class(),
AliAnalysisManager::kOutputContainer,
"AnalysisResults_EmcalJet.root"));*/
//=============================================================================
TObjArray *aTasks = mgr->GetTasks();
for (Int_t i=0; i<aTasks->GetEntries(); i++) {
AliAnalysisTaskEmcal *taskJE = dynamic_cast<AliAnalysisTaskEmcal*>(aTasks->At(i));
if (taskJE) if (taskJE->InheritsFrom("AliAnalysisTaskEmcal")) {
taskJE->SetVzRange(-10., 10.);
if (!sCentEsti.IsNull()) {
taskJE->SetCentralityEstimator(sCentEsti.Data());
taskJE->SetCentRange(dCentMin, dCentMax);
}
}
if (wTriggerMask) {
AliAnalysisTaskSE *taskSE = dynamic_cast<AliAnalysisTaskSE*>(aTasks->At(i));
if (taskSE) if (!(taskSE->InheritsFrom("AliPhysicsSelectionTask"))) {
taskSE->SelectCollisionCandidates(wTriggerMask);
}
}
}
//=============================================================================
return kFALSE;
}
// const char* cDataType = "AOD", // set the analysis type, AOD or ESD
//##################################################
AliAnalysisManager* EmcalJetCDF (
const char* cRunPeriod = "LHC11d", // set the run period
const char* cLocalFiles = "data.txt", // set the local list file
const Int_t arg_sel_chg = 3145763, // "mykEMC_noGA", // physics selection
const Int_t arg_sel_full = 3145763, // "mykEMC_noGA", // physics selection
const Int_t mgr_mode = 0, // local = 0, proof = 1, grid = 2, mixing = 3
const Int_t alien_mode = 0, // test = 0, offline = 1, submit = 2, merge = 3, full = 4
const char* cTaskName = "CDFJets", // sets name of task manager
unsigned int iNumFiles = 100, // numger of files to process from list file
unsigned int iNumEvents = 999999999, // number of events to be analyzed
bool bDoChargedJets = true, // enable charge jets
bool bDoFullJets = false // enable full jets
) {
//Load needed libs
TString ListLibs = ""; // string list of loaded libs
TString ListLibsExtra = ""; // string list of loaded extra libs
LoadLibs( ListLibs, ListLibsExtra );
AnalysisType ManagerMode = static_cast<AnalysisType>(mgr_mode);
PluginType PluginMode = static_cast<PluginType>(alien_mode);
namespace CDF = PWGJE::EMCALJetTasks::AliAnalysisTaskEmcalJetCDF_NS; // shortcut to task namespace
unsigned int kGridFilesPerJob = iNumFiles; // Maximum number of files per job (gives size of AOD)
unsigned int kTTL = 64800 ; // Time To Live; 18h = 64800; 12h = 43200
bool bDoBackgroundSubtraction = true;
bool bDoEmbedding = false;
// Embeded Configuration options
// Embedding files list
const TString embeddedFilesList = "aodFilesEmbed.txt";
// If true, events that are not selected in the PbPb will not be used for embedding.
// This ensures that good embedded events are not wasted on bad PbPb events.
const bool internalEventSelection = true;
// Do jet matching
const bool useJetTagger = true;
TString sGridMode ("test");
if ( PluginMode == PluginType::offline ) { sGridMode = "offline"; }
if ( PluginMode == PluginType::submit ) { sGridMode = "submit"; }
if ( PluginMode == PluginType::merge ) { sGridMode = "merge"; }
if ( PluginMode == PluginType::full ) { sGridMode = "full"; }
const char* cGridMode = sGridMode.Data();
TString sAnalysisType ("local");
if ( ManagerMode == AnalysisType::proof ) { sAnalysisType = "proof"; }
if ( ManagerMode == AnalysisType::grid ) { sAnalysisType = "grid"; }
if ( ManagerMode == AnalysisType::mixing ) { sAnalysisType = "mix"; }
const char* cAnalysisType = sAnalysisType.Data();
cout << std::endl << ">>>>>>>> ManagerMode : " << ManagerMode << " ; String value : " << cAnalysisType << std::endl << ">>>>>>>> PluginMode : " << PluginMode << " ; String value : " << cGridMode << std::endl << std::endl;
//---------------------------------------------------------------------------------------------
TRegexp false_regex ("[f,F][a,A][l,L][s,S][e,E]");
TRegexp true_regex ("[t,T][r,R][u,U][e,E]");
TRegexp enable_regex ("[e,E][n,N][a,A][b,B][l,L][e,E]");
TRegexp disable_regex ("[d,D][i,I][s,S][a,A][b,B][l,L][e,E]");
bool bDoSample = false;
TString ENV_doSAMPLE = gSystem->Getenv("CDF_doSAMPLE");
if (!ENV_doSAMPLE.IsNull() && ( ENV_doSAMPLE.EqualTo("0") || ENV_doSAMPLE.Contains(false_regex) ) ) { bDoSample = kFALSE; }
if (!ENV_doSAMPLE.IsNull() && ( ENV_doSAMPLE.EqualTo("1") || ENV_doSAMPLE.Contains(true_regex) ) ) { bDoSample = kTRUE; }
bool bDoCDF = true;
TString ENV_doCDF = gSystem->Getenv("CDF_doCDF");
if (!ENV_doCDF.IsNull() && ( ENV_doCDF.EqualTo("0") || ENV_doCDF.Contains(false_regex) ) ) { bDoCDF = kFALSE; }
if (!ENV_doCDF.IsNull() && ( ENV_doCDF.EqualTo("1") || ENV_doCDF.Contains(true_regex) ) ) { bDoCDF = kTRUE; }
// ###### DEBUG ######
Int_t debug = 0 ; // kFatal = 0, kError, kWarning, kInfo, kDebug, kMaxType
UInt_t mgr_debug = 0 ; // AliAnalysisManager debug level
UInt_t kUseSysInfo = 0 ; // activate debugging
TString ENV_DEBUG = gSystem->Getenv("CDF_DEBUG");
if (!ENV_DEBUG.IsNull() && ENV_DEBUG.IsDigit() ) { debug = ENV_DEBUG.Atoi(); }
TString ENV_DEBUG_MGR = gSystem->Getenv("CDF_DEBUG_MGR");
if (!ENV_DEBUG_MGR.IsNull() && ENV_DEBUG_MGR.IsDigit() ) { mgr_debug = ENV_DEBUG_MGR.Atoi(); }
TString ENV_NSYSINFO = gSystem->Getenv("CDF_NSYSINFO");
if (!ENV_NSYSINFO.IsNull() && ENV_NSYSINFO.IsDigit() ) { kUseSysInfo = ENV_NSYSINFO.Atoi(); }
if ( debug == 0 ) { AliLog::SetGlobalLogLevel ( AliLog::kFatal ); }
if ( debug == 1 ) { AliLog::SetGlobalLogLevel ( AliLog::kError ); }
if ( debug == 2 ) { AliLog::SetGlobalLogLevel ( AliLog::kWarning ); }
if ( debug == 3 ) { AliLog::SetGlobalLogLevel ( AliLog::kInfo ); }
if ( debug >= 4 ) { AliLog::SetGlobalLogLevel ( AliLog::kDebug ); }
// Progress bar
Bool_t bUseProgBar = kFALSE; // N.B. !! if true will set fDebug to 0
TString ENV_USEPROGBAR = gSystem->Getenv("PROGRESSBAR");
if (!ENV_USEPROGBAR.IsNull() && ( ENV_USEPROGBAR.EqualTo("1") || ENV_USEPROGBAR.Contains(true_regex) ) ) { bUseProgBar = kTRUE; }
//##################################################
// AliEN plugin variables
//##################################################
const char* curdir = gSystem->BaseName(gSystem->pwd());
TString kJobTag (curdir);
TString execArgs (" -l -b -q -x");
TString exec =
// "aliroot";
"root.exe";
TString kPluginExecutableCommand = exec + execArgs;
TString kAliPhysicsVersion = "vAN-20190304-1";
// == grid plugin files rules
TString kGridExtraFiles = ""; // extra files that will be added to the input list in the JDL
TString kGridMergeExclude = "AliAOD.root AliAOD.Jets.root"; // Files that should not be merged
TString kGridOutputStorages = "disk=2"; // Make replicas on the storages
// FILES USED IN MACRO
TString kCommonOutputFileName = "AnalysisResults.root";
//--------------------
// PROOF SETTINGS
//--------------------
TString kAAF = "";
Int_t kProofReset = 0; (void)kProofReset;
Int_t kWorkers = 20; (void)kWorkers;
Int_t kCores = 8 ; (void)kCores;
// AliRoot mode among the list supported by the proof cluster.
// TString kAlirootMode = "ALIROOT"; // STEERBase,ESD,AOD,ANALYSIS,ANALYSISalice (default aliroot mode)
//############################################################
// const AliAnalysisTaskEmcal::EDataType_t kAod = AliAnalysisTaskEmcal::kAOD;
// const AliAnalysisTaskEmcal::EDataType_t kEsd = AliAnalysisTaskEmcal::kESD;
const AliJetContainer::EJetType_t fulljet = AliJetContainer::kFullJet;
const AliJetContainer::EJetType_t chgjet = AliJetContainer::kChargedJet;
const AliJetContainer::EJetAlgo_t antikt = AliJetContainer::antikt_algorithm;
const AliJetContainer::EJetAlgo_t kt = AliJetContainer::kt_algorithm;
const AliJetContainer::ERecoScheme_t recomb = AliJetContainer::pt_scheme;
// kTPC, kTPCfid, kEMCAL, kEMCALfid, kDCAL, kDCALfid, kDCALonly, kDCALonlyfid, kPHOS, kPHOSfid, kUser
const AliEmcalJet::JetAcceptanceType acc_chgjets = AliEmcalJet::kTPCfid;
const AliEmcalJet::JetAcceptanceType acc_fulljets = AliEmcalJet::kEMCALfid;
//############################################################
// data source name
TString kDataSource (cLocalFiles);
// label of dataset from InputData.C
TString kGridDataSet ("");
if ( ManagerMode == AnalysisType::grid ) { kGridDataSet = kDataSource;}
//############################################################
// SETUP OF TRIGGERS
const AliEmcalPhysicsSelection::EOfflineEmcalTypes mykEMCAL = AliEmcalPhysicsSelection::kEmcalOk;
const AliVEvent::EOfflineTriggerTypes mykEMC = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE | AliVEvent::kEMCEGA);
const AliVEvent::EOfflineTriggerTypes mykEMC_noGA = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE);
const AliVEvent::EOfflineTriggerTypes mykMB = AliVEvent::kAnyINT;
const AliVEvent::EOfflineTriggerTypes mykMB_central = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kCentral);
const AliVEvent::EOfflineTriggerTypes mykMB_semicentral = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kSemiCentral);
const AliVEvent::EOfflineTriggerTypes mykMB_mostcentral = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kCentral | AliVEvent::kSemiCentral);
AliVEvent::EOfflineTriggerTypes kPhysSel = mykMB; //AliVEvent::kAnyINT; // physics selection
// AliVEvent::EOfflineTriggerTypes kSel_tasks = mykMB;
AliVEvent::EOfflineTriggerTypes kSel_chg = static_cast<AliVEvent::EOfflineTriggerTypes>(arg_sel_chg);
AliVEvent::EOfflineTriggerTypes kSel_full = static_cast<AliVEvent::EOfflineTriggerTypes>(arg_sel_full);
//############################################################
// Analysis manager
AliAnalysisManager* pMgr = new AliAnalysisManager(cTaskName);
pMgr->SetDebugLevel(mgr_debug);
if ( kUseSysInfo > 0 ) { pMgr->SetNSysInfo ( kUseSysInfo ); }
// actual runName in the form of LHCXXX....
TString sRunName;
Bool_t kIsAOD = kTRUE;
AliAnalysisTaskEmcal::EDataType_t iDataType = AliAnalysisTaskEmcal::kAOD; // assuming default is to process AOD
TString file;
AliAnalysisAlien* plugin = NULL;
if ( ManagerMode == AnalysisType::grid ) { // start grid analysis
// ( const char* gridMode, const char* tag, unsigned int nr_test_files, unsigned int TTL, const char* outdir, const char subworkdir, const char* extradirlvl);
plugin = CreateAlienHandler(cGridMode, kJobTag.Data(), kGridFilesPerJob, kTTL);
if ( !plugin ) { ::Error ( "runEMCalJetSampleTask.C - StartGridAnalysis", "plugin invalid" ); return NULL; }
pMgr->SetGridHandler(plugin);
// use this command to run the macro
plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
// AliPhysics version.
plugin->SetAliPhysicsVersion ( kAliPhysicsVersion.Data() ); // Here you can set the (Ali)PHYSICS version you want to use
gROOT->LoadMacro("InputData.C");
InputData(kGridDataSet);
sRunName = CDF::GetPeriod( plugin->GetGridDataDir() );
file = CDF::GetFileFromPath(plugin->GetDataPattern());
if (file.Contains("AliESD")) { iDataType = AliAnalysisTaskEmcal::kESD; kIsAOD = kFALSE; }
plugin->SetMergeExcludes(kGridMergeExclude.Data());
}
if ( ManagerMode == AnalysisType::local ) { // start local analysis
if ( kDataSource.IsNull() ) { Printf("You need to provide the list of local files!"); return NULL; }
TChain* pChain = CDF::CreateChain(kDataSource.Data(), "auto", "", iNumFiles);
if (!pChain) { std::cout << ">>>>>>>>>>>>>> CHAIN NOT CREATED <<<<<<<<<<<<<<" << std::endl; return NULL; }
Printf("Setting local analysis for %d files from list %s, max events = %d", iNumFiles, kDataSource.Data(), iNumEvents);
// get the path of first file
file = pChain->GetFile()->GetEndpointUrl()->GetUrl();
sRunName = CDF::GetPeriod(file.Data()); // get the run name : first token beggining with lhc
if ( CDF::GetFileFromPath(file).Contains("AliESD") ) { iDataType = AliAnalysisTaskEmcal::kESD; kIsAOD = kFALSE; }
}
TString sDataType ("AOD");
if (!kIsAOD) { sDataType = "ESD"; }
std::cout << ">>> Analysis data type : " << sDataType.Data() << std::endl;
// name of de period (for MC is the name of "achored to" production)
TString sRunPeriod (cRunPeriod);
sRunPeriod.ToLower();
bool isMC = false;
isMC = CDF::PeriodIsMC(sRunName.Data());
// EMCAL corrections task configuration file
TString EMCALcfg ("CDF_CorrectionsConf.yaml");
if (isMC) {EMCALcfg = "CDF_MC_CorrectionsConf.yaml";}
if ( !kGridExtraFiles.IsNull() ) {kGridExtraFiles += " ";}
kGridExtraFiles += EMCALcfg;
AliAnalysisTaskEmcal::BeamType iBeamType = AliAnalysisTaskEmcal::kpp;
Bool_t bIsRun2 = kFALSE;
if (sRunPeriod.Length() == 6 && (sRunPeriod.BeginsWith("lhc15") || sRunPeriod.BeginsWith("lhc16") || sRunPeriod.BeginsWith("lhc17") || sRunPeriod.BeginsWith("lhc18") ) ) { bIsRun2 = kTRUE; }
if (sRunPeriod == "lhc10h" || sRunPeriod == "lhc11h" || sRunPeriod == "lhc15o" || sRunPeriod == "lhc17n" ) { iBeamType = AliAnalysisTaskEmcal::kAA; }
if (sRunPeriod == "lhc12g" || sRunPeriod == "lhc13b" || sRunPeriod == "lhc13c" || sRunPeriod == "lhc13d" || sRunPeriod == "lhc13e" ||
sRunPeriod == "lhc13f" || sRunPeriod == "lhc16q" || sRunPeriod == "lhc16r" || sRunPeriod == "lhc16s" || sRunPeriod == "lhc16t" ) { iBeamType = AliAnalysisTaskEmcal::kpA; }
Double_t kGhostArea = 0.01;
if (iBeamType != AliAnalysisTaskEmcal::kpp) { kGhostArea = 0.005; }
AliTrackContainer::SetDefTrackCutsPeriod(sRunPeriod);
Printf("Default track cut period set to: %s", AliTrackContainer::GetDefTrackCutsPeriod().Data());
Bool_t bDoEmcalCorrections = kFALSE;
if (bDoFullJets) { bDoEmcalCorrections = kTRUE; }
// ### Containers and string definitions
TString name_tracks = "usedefault";
TString name_clusters = "usedefault";
TString name_cells = "usedefault";
// Set centrality estimator for centrality task
TString cent_est_chg = "V0M" ;
TString cent_est_full = "V0M" ;
TString mc_container ("");
if (isMC) { mc_container = "mcparticles"; }
/*
// General input object names
TString tracksName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kTrack);
TString clustersName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCluster);
TString emcalCellsName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCaloCells);
// Combined (PbPb + embedded det level)
TString emcalCellsCombined = emcalCellsName + "Combined";
TString clustersCombined = clustersName + "Combined";
*/
//##########################
// TASKS DEFINITIONS ###
//##########################
AliAODInputHandler* pAODHandler = NULL;
AliESDInputHandler* pESDHandler = NULL;
if (kIsAOD)
{ pAODHandler = AliAnalysisTaskEmcal::AddAODHandler(); }
else
{ pESDHandler = AliAnalysisTaskEmcal::AddESDHandler(); }
// CDBconnect task
AliTaskCDBconnect* taskCDB = AliTaskCDBconnect::AddTaskCDBconnect();
taskCDB->SetFallBackToRaw(kTRUE); // Needed for the moment as not all grid sites do support cvmfs OCDB for the moment
if (!taskCDB) { std::cout << "--------->>>> taskCDB :: could not connect!!!! CHECK CVMFS" << std::endl; return NULL;}
// Physics selection task
AliPhysicsSelectionTask* pPhysSelTask = NULL;
if (!kIsAOD) {
// signature : (Bool_t mCAnalysisFlag = kFALSE, Bool_t applyPileupCuts = kFALSE, UInt_t deprecatedFlag2 = 0, Bool_t useSpecialOutput=kFALSE)
pPhysSelTask = AliPhysicsSelectionTask::AddTaskPhysicsSelection();
}
// Centrality task
// The Run 2 condition is too restrictive, but until the switch to MultSelection is complete, it is the best we can do
AliCentralitySelectionTask* pCentralityTask = NULL;
if ( !kIsAOD && (iBeamType != AliAnalysisTaskEmcal::kpp && bIsRun2) ) {
//signature : (Bool_t fillHistos=kTRUE, Bool_t aod=kFALSE)
pCentralityTask = AliCentralitySelectionTask::AddTaskCentrality(kFALSE, kIsAOD);
pCentralityTask->SelectCollisionCandidates(AliVEvent::kAny);
}
// AliMultSelection
AliMultSelectionTask* pMultSelTask = NULL;
if (bIsRun2) {
// signature : ( Bool_t lCalibration = kFALSE, TString lExtraOptions = "", Int_t lNDebugEstimators = 1, const TString lMasterJobSessionFlag = "")
pMultSelTask = AliMultSelectionTask::AddTaskMultSelection();
pMultSelTask->SelectCollisionCandidates(AliVEvent::kAny);
}
// Embedding task
if (bDoEmbedding) {
// Debug options
//AliLog::SetClassDebugLevel("AliAnalysisTaskEmcalEmbeddingHelper", AliLog::kDebug+0);
// Setup embedding task
AliAnalysisTaskEmcalEmbeddingHelper * embeddingHelper = AliAnalysisTaskEmcalEmbeddingHelper::AddTaskEmcalEmbeddingHelper();
embeddingHelper->SelectCollisionCandidates(kPhysSel);
// The pt hard bin should be set via the filenames in this file
// If using a file pattern, it could be configured via embeddingHelper->SetPtHardBin(ptHardBin);
embeddingHelper->SetFileListFilename(embeddedFilesList.Data());
// Some example settings for LHC12a15e_fix (anchored to LHC11h)
embeddingHelper->SetNPtHardBins(11);
embeddingHelper->SetMCRejectOutliers();
// Setup internal event selection and additional configuration options
embeddingHelper->SetConfigurationPath("EmbeddingConfigurationExample.yaml");
// Initialize the task to complete the setup.
embeddingHelper->Initialize();
}
// EMCal corrections
AliEmcalCorrectionTask* correctionTask = NULL;
if (bDoEmcalCorrections) {
// Configuration of the Correction Task is handled via a YAML file, which is setup below
// signature : (TString suffix)
correctionTask = AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask();
// correctionTask = AliEmcalCorrectionTask::ConfigureEmcalCorrectionTaskOnLEGOTrain(suffix);
correctionTask->SelectCollisionCandidates(kPhysSel);
correctionTask->SetUseNewCentralityEstimation(bIsRun2);
correctionTask->SetForceBeamType(static_cast<AliEmcalCorrectionTask::BeamType>(iBeamType));
// Configure and initialize
correctionTask->SetUserConfigurationFilename( EMCALcfg.Data() );
//correctionTask->SetUserConfigurationFilename("alien:///alice/cern.ch/user/m/mfasel/EMCALCorrectionConfig/ConfigDataPWGJEhighClusterThresholds.yaml");
correctionTask->Initialize(true);
}
// TObjArray correctionTasks;
//
// // Create the Correction Tasks
// // "data" corresponds to the PbPb level
// // "embed" corresponds to the embedded detector level
// // "combined" corresponds to the hybrid (PbPb + embedded detector) level
// correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("data"));
// correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("embed"));
// // It is important that combined is last!
// correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("combined"));
//
// // Loop over all of the correction tasks to configure them
// AliEmcalCorrectionTask * tempCorrectionTask = 0;
// TIter next(&correctionTasks);
// while (( tempCorrectionTask = static_cast<AliEmcalCorrectionTask *>(next()))) {
// tempCorrectionTask->SelectCollisionCandidates(kPhysSel);
// // Configure centrality
// tempCorrectionTask->SetNCentBins(5);
// tempCorrectionTask->SetUseNewCentralityEstimation(bIsRun2);
// tempCorrectionTask->SetUserConfigurationFilename("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/EMCalCorrectionTaskEmbeddingExample.yaml");
//
// tempCorrectionTask->Initialize(true);
// }
// Background
TString sRhoChName;
TString sRhoFuName;
AliAnalysisTaskRho* pRhoTask = NULL;
if ( bDoBackgroundSubtraction && iBeamType != AliAnalysisTaskEmcal::kpp ) {
sRhoChName = "Rho";
sRhoFuName = "Rho_Scaled";
AliEmcalJetTask* pKtChJetTask = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", kt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 0., kFALSE, kFALSE);
pKtChJetTask->SelectCollisionCandidates(kPhysSel);
//signature :
// const char* nTracks = "usedefault", const char* nClusters = "usedefault", const char* nRho = "Rho", Double_t jetradius = 0.2, UInt_t acceptance = AliEmcalJet::kTPCfid,
// AliJetContainer::EJetType_t jetType = AliJetContainer::kChargedJet, const Bool_t histo = kFALSE, AliJetContainer::ERecoScheme_t rscheme = AliJetContainer::pt_scheme, const char* suffix = ""
pRhoTask = AliAnalysisTaskRho::AddTaskRhoNew(name_tracks.Data(), name_clusters.Data(), sRhoChName, 0.4);
pRhoTask->SetExcludeLeadJets(2);
pRhoTask->SelectCollisionCandidates(kPhysSel);
pRhoTask->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
if (bDoFullJets) {
TString sFuncPath = "alien:///alice/cern.ch/user/s/saiola/LHC11h_ScaleFactorFunctions.root";
TString sFuncName = "LHC11h_HadCorr20_ClustersV2";
pRhoTask->LoadRhoFunction(sFuncPath, sFuncName);
}
}
// Find Charged jets
AliEmcalJetTask* pChJet02Task = NULL;
AliEmcalJetTask* pChJet04Task = NULL;
AliEmcalJetTask* pChJet02Task_MC = NULL;
AliEmcalJetTask* pChJet04Task_MC = NULL;
if (bDoChargedJets) {
pChJet02Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", antikt, 0.2, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet02Task->SelectCollisionCandidates(kSel_chg);
pChJet04Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", antikt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet04Task->SelectCollisionCandidates(kSel_chg);
if (isMC) {
pChJet02Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), "", antikt, 0.2, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet02Task_MC->SelectCollisionCandidates(kSel_chg);
if (bDoEmbedding) {
pChJet02Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks02Task_MC = pChJet02Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks02Task_MC->SetIsEmbedding(kTRUE);
}
pChJet04Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), "", antikt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pChJet04Task_MC->SelectCollisionCandidates(kSel_chg);
if (bDoEmbedding) {
pChJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks04Task_MC = pChJet04Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks04Task_MC->SetIsEmbedding(kTRUE);
}
} // isMC
} // bDoChargedJets
// Find Full jets
AliEmcalJetTask* pFuJet02Task = NULL;
AliEmcalJetTask* pFuJet04Task = NULL;
AliEmcalJetTask* pFuJet02Task_MC = NULL;
AliEmcalJetTask* pFuJet04Task_MC = NULL;
if (bDoFullJets) {
pFuJet02Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), name_clusters.Data(), antikt, 0.2, fulljet, 0.15, 0.30, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet02Task->SelectCollisionCandidates(kSel_full);
pFuJet02Task->GetClusterContainer(0)->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
pFuJet04Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), name_clusters.Data(), antikt, 0.4, fulljet, 0.15, 0.30, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet04Task->SelectCollisionCandidates(kSel_full);
pFuJet04Task->GetClusterContainer(0)->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
if (isMC) {
pFuJet02Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), name_clusters.Data(), antikt, 0.2, fulljet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet02Task_MC->SelectCollisionCandidates(kSel_chg);
if (bDoEmbedding) {
pFuJet02Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks02Task_MC = pFuJet02Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks02Task_MC->SetIsEmbedding(kTRUE);
}
pFuJet04Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), name_clusters.Data(), antikt, 0.4, fulljet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE);
pFuJet04Task_MC->SelectCollisionCandidates(kSel_chg);
pFuJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
if (bDoEmbedding) {
pFuJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection);
AliParticleContainer* partLevelTracks04Task_MC = pFuJet04Task_MC->GetParticleContainer(0);
// Called Embedded, but really just means get from an external event!
partLevelTracks04Task_MC->SetIsEmbedding(kTRUE);
}
} // isMC
} // bDoFullJets
////////////////////////
// ANALYSIS TASKS //
////////////////////////
// Sample task - charge jets
AliAnalysisTaskEmcalJetSample* sampleTaskchg = NULL;
if (bDoSample && bDoChargedJets) {
sampleTaskchg = AliAnalysisTaskEmcalJetSample::AddTaskEmcalJetSample(name_tracks.Data(), "", "", "SMPCHG");
sampleTaskchg->SetHistoBins(600, 0, 300);
sampleTaskchg->SelectCollisionCandidates(kSel_chg);
sampleTaskchg->SetDebugLevel(debug);
AliParticleContainer* sampleTaskchg_partCont = sampleTaskchg->GetParticleContainer(0);
sampleTaskchg_partCont->SetParticlePtCut(0.15);
if (bDoEmbedding) { sampleTaskchg_partCont->SetIsEmbedding(kTRUE); }
if ( pMultSelTask ) {
sampleTaskchg->SetUseNewCentralityEstimation(bIsRun2);
sampleTaskchg->SetNCentBins(5);
}
}
// Sample task - full jets
AliAnalysisTaskEmcalJetSample* sampleTaskfull = NULL;
if (bDoSample && bDoFullJets) {
sampleTaskfull = AliAnalysisTaskEmcalJetSample::AddTaskEmcalJetSample(name_tracks.Data(), name_clusters.Data(), name_cells.Data(), "SMPFULL");
sampleTaskfull->SetHistoBins(600, 0, 300);
sampleTaskfull->SelectCollisionCandidates(kSel_full);
sampleTaskfull->SetDebugLevel(debug);
AliParticleContainer* sampleTaskfull_partCont = sampleTaskfull->GetParticleContainer(0);
sampleTaskfull_partCont->SetParticlePtCut(0.15);
AliClusterContainer* sampleTaskfull_clusCont = sampleTaskfull->GetClusterContainer(0);
sampleTaskfull_clusCont->SetClusECut(0.);
sampleTaskfull_clusCont->SetClusPtCut(0.);
sampleTaskfull_clusCont->SetClusNonLinCorrEnergyCut(0.);
sampleTaskfull_clusCont->SetClusHadCorrEnergyCut(0.30);
sampleTaskfull_clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
if (bDoEmbedding) {
sampleTaskfull_partCont->SetIsEmbedding(kTRUE);
sampleTaskfull_clusCont->SetIsEmbedding(kTRUE);
}
if ( pMultSelTask ) {
sampleTaskfull->SetUseNewCentralityEstimation(bIsRun2);
sampleTaskfull->SetNCentBins(5);
}
}
//### CDF task - charged jets
AliAnalysisTaskEmcalJetCDF* anaTaskCDFchg = NULL;
AliAnalysisTaskEmcalJetCDF* anaTaskCDFchg_MC = NULL;
if (bDoCDF && bDoChargedJets) {
anaTaskCDFchg = CDF::AddTaskEmcalJetCDF ( name_tracks.Data(), "", "", "", "CDFchg" );
anaTaskCDFchg->SetHistoBins(600, 0, 300);
anaTaskCDFchg->SelectCollisionCandidates(kSel_chg);
anaTaskCDFchg->SetDebugLevel(debug);
AliParticleContainer* anaTaskCDFchg_partCont = anaTaskCDFchg->GetParticleContainer(0);
anaTaskCDFchg_partCont->SetParticlePtCut(0.15);
if (bDoEmbedding) { anaTaskCDFchg_partCont->SetIsEmbedding(kTRUE); }
if ( pMultSelTask ) {
anaTaskCDFchg->SetUseNewCentralityEstimation(bIsRun2);
anaTaskCDFchg->SetNCentBins(5);
anaTaskCDFchg->SetCentralityEstimator(cent_est_chg.Data());
}
//#################################################
if (isMC){
anaTaskCDFchg_MC = CDF::AddTaskEmcalJetCDF ( mc_container.Data(), "", "", "", "CDFchgMC" );
anaTaskCDFchg_MC->SetHistoBins(600, 0, 300);
anaTaskCDFchg_MC->SelectCollisionCandidates(kSel_chg);
anaTaskCDFchg_MC->SetDebugLevel(debug);
AliParticleContainer* anaTaskCDFchg_partCont_MC = anaTaskCDFchg_MC->GetMCParticleContainer(0);
anaTaskCDFchg_partCont->SetParticlePtCut(0.15);
if (bDoEmbedding) { anaTaskCDFchg_partCont_MC->SetIsEmbedding(kTRUE); }
if ( pMultSelTask ) {
anaTaskCDFchg_MC->SetUseNewCentralityEstimation(bIsRun2);
anaTaskCDFchg_MC->SetNCentBins(5);
anaTaskCDFchg_MC->SetCentralityEstimator(cent_est_chg.Data());
}
}
}
//### CDF task - full jets
AliAnalysisTaskEmcalJetCDF* anaTaskCDFfull = NULL;
if (bDoCDF && bDoFullJets) {
anaTaskCDFfull = CDF::AddTaskEmcalJetCDF ( name_tracks.Data(), name_clusters.Data(), name_cells.Data(), mc_container.Data(), "CDFfull" );
anaTaskCDFfull->SetHistoBins(600, 0, 300);
anaTaskCDFfull->SelectCollisionCandidates(kSel_full);
anaTaskCDFfull->SetDebugLevel(debug);
AliParticleContainer* anaTaskCDFfull_partCont = anaTaskCDFfull->GetParticleContainer(0);
anaTaskCDFfull_partCont->SetParticlePtCut(0.15);
AliClusterContainer* anaTaskCDFfull_clusCont = anaTaskCDFfull->GetClusterContainer(0);
anaTaskCDFfull_clusCont->SetClusECut(0.);
anaTaskCDFfull_clusCont->SetClusPtCut(0.);
anaTaskCDFfull_clusCont->SetClusNonLinCorrEnergyCut(0.);
anaTaskCDFfull_clusCont->SetClusHadCorrEnergyCut(0.30);
anaTaskCDFfull_clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
if (bDoEmbedding) {
anaTaskCDFfull_partCont->SetIsEmbedding(kTRUE);
anaTaskCDFfull_clusCont->SetIsEmbedding(kTRUE);
}
if ( pMultSelTask ) {
anaTaskCDFfull->SetUseNewCentralityEstimation(bIsRun2);
anaTaskCDFfull->SetNCentBins(5);
anaTaskCDFfull->SetCentralityEstimator(cent_est_full.Data());
}
}
//########################
// ANALYSIS TASKS - CONTAINERS SETUP
//########################
// AliEmcalJetTask* pChJet02Task_MC = NULL;
// AliEmcalJetTask* pChJet04Task_MC = NULL;
// add jet containers to CDF task for charged jets
if (bDoChargedJets && bDoCDF) {
AliJetContainer* jetcont_chg = NULL;
for ( Float_t fi = 0 ; fi<=100 ; fi+=10) {
// CHG JETS 0.2
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
// CHG JETS 0.4
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
if (isMC) {
// CHG JETS MC 0.2
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet02Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
// CHG JETS MC 0.4
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet04Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0);
}
}
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet");
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
if (isMC) {
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet02Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet04Task_MC, acc_chgjets);
CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0);
}
jetcont_chg = NULL;
}
// add jet containers to CDF task for full jets
if (bDoFullJets && bDoCDF) {
AliJetContainer* jetcont_full = NULL;
for ( Float_t fi = 0 ; fi<=100 ; fi+=10) {
// FULL JETS 0.2
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 2);
// FULL JETS 0.4
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 2);
if (isMC) {
// CHG JETS MC 0.2
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet02Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 0);
// CHG JETS MC 0.4
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet04Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 0);
}
}
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 2);
jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet");
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 2);
if (isMC) {
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet02Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 0);
jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet04Task_MC, acc_fulljets);
CDF::jetContSetParams (jetcont_full, 1., 500., 0, 0);
}
jetcont_full = NULL;
}
// add jet containers to sample task for charged jets
if (bDoChargedJets && bDoSample) {
AliJetContainer* jetCont02chg_sample = sampleTaskchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet");
AliJetContainer* jetCont04chg_sample = sampleTaskchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet");
if (iBeamType != AliAnalysisTaskEmcal::kpp) {
jetCont02chg_sample->SetRhoName(sRhoChName);
jetCont02chg_sample->SetPercAreaCut(0.6);
jetCont04chg_sample->SetRhoName(sRhoChName);
jetCont04chg_sample->SetPercAreaCut(0.6);
}
}
// add jet containers to sample task for full jets
if (bDoFullJets && bDoSample) {
AliJetContainer* jetCont02full_sample = sampleTaskfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet");
AliJetContainer* jetCont04full_sample = sampleTaskfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet");
if (iBeamType != AliAnalysisTaskEmcal::kpp) {
jetCont02full_sample->SetRhoName(sRhoFuName);
jetCont02full_sample->SetPercAreaCut(0.6);
jetCont04full_sample->SetRhoName(sRhoFuName);
jetCont04full_sample->SetPercAreaCut(0.6);
}
}
TObjArray* tasks_list = pMgr->GetTasks(); TIter task_iter (tasks_list); AliAnalysisTaskSE* task = NULL;
while (( task = dynamic_cast<AliAnalysisTaskSE*>(task_iter.Next()) )) {
if (task->InheritsFrom("AliAnalysisTaskEmcal")) {
Printf("Setting beam type %d for task %s", iBeamType, static_cast<AliAnalysisTaskEmcal*>(task)->GetName());
static_cast<AliAnalysisTaskEmcal*>(task)->SetForceBeamType(iBeamType);
}
}
// Let's start #########################################################################################################
if ( !pMgr->InitAnalysis() ) { std::cout << ">>>>>>>>>>>>>> AliAnalysisManager Initialising FAILED!!! " << std::endl; return NULL; }
std::cout << "##-->> Initialising Analysis :: Status :" << std::endl;
pMgr->PrintStatus();
pMgr->SetUseProgressBar(bUseProgBar, 100);
// task profiling
if ( kUseSysInfo > 0 ) {
for ( int i = 0; i < pMgr->GetTopTasks()->GetEntries(); i++ ) { pMgr->ProfileTask (i); }
}
CDF::SaveManager("train.root");
if ( ManagerMode == AnalysisType::local ) { // start local analysis
// enable class level debugging for these classes
if ( debug > 2 ) {
// pMgr->AddClassDebug("AliJetContainer", 100);
// pMgr->AddClassDebug("AliEmcalJetTask", 100);
if (bDoCDF) { pMgr->AddClassDebug("AliAnalysisTaskEmcalJetCDF", 100); }
if (bDoSample) { pMgr->AddClassDebug("AliAnalysisTaskEmcalJetSample", 100); }
}
TChain* pChain = CDF::CreateChain(kDataSource.Data(), "auto", "", iNumFiles);
if (!pChain) { std::cout << ">>>>>>>>>>>>>> CHAIN NOT CREATED <<<<<<<<<<<<<<" << std::endl; return NULL; }
// start analysis
Printf("Starting LOCAL Analysis...");
pMgr->StartAnalysis( cAnalysisType, pChain, iNumEvents );
}
if ( ManagerMode == AnalysisType::grid ) { // start grid analysis
// start analysis
Printf("Starting GRID Analysis...");
ListLibs += kGridExtraFiles;
if ( ListLibs.Length() ) { plugin->SetAdditionalLibs ( ListLibs.Data() ); }
if ( ListLibsExtra.Length() ) { plugin->SetAdditionalRootLibs ( ListLibsExtra.Data() ); }
if ( PluginMode == PluginType::test )
{ plugin->StartAnalysis(iNumEvents); }
else {
pMgr->SetDebugLevel(0);
plugin->StartAnalysis();
}
}
cout << "END of EmcalJetCDF.C" << std::endl;
return pMgr;
}
void AddAnalysisTasks(const char *cdb_location)
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
mgr->SetCommonFileName("QAresults.root");
// Statistics task
mgr->AddStatisticsTask(kTriggerMask);
//
// CDB connection
//
if (doCDBconnect) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C");
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, run_number);
if (!taskCDB) return;
}
//
// Event Statistics (Jan Fiete)
//
if (doEventStat) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kTRUE /*MC*/);
}
//
// PIDResponse(JENS)
//
if (doPIDResponse) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse(kTRUE);
PIDResponse->SelectCollisionCandidates(kTriggerMask);
}
//
// Centrality (A. Toia)
//
if (doCentrality)
{
if(run_flag >= 1500)
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
AliMultSelectionTask *taskMult = AddTaskMultSelection();
taskMult->SetAlternateOADBforEstimators(periodName);
}
else
// old scheme is only valid for PbPb
if (iCollisionType == kPbPb)
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
taskCentrality->SetMCInput();
}
}
// Vertexing (A. Dainese)
//
if (doVertex) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskVertexESD.C");
// Specific setting for MC
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kTRUE, kTriggerMask);
taskvertexesd->SelectCollisionCandidates(kTriggerMask);
}
// TPC QA (E. Sicking)
//
if (doQAsym) {
// offline trigger in AddTask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
}
//
// VZERO QA (C. Cheshkov)
//
if (doVZERO) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
if (doVZEROPbPb) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/VZERO/AddTaskVZEROPbPb.C");
AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(run_number);
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
}
//
// TPC (Jacek Otwinowski & Michael Knichel)
//
//
// Optionally MC information can be used by setting the 1st argument to true
// Optionally friends information can be switched off by setting the 2st argument
// to false
// Optionally highMult axis can be used by setting the 3st argument to true (for PbPb)
if (doTPC) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
AliPerformanceTask *tpcQA = 0;
if (iCollisionType==kPbPb || iCollisionType == kXeXe) {
// High multiplicity Pb-Pb
tpcQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kTRUE);
} else {
// Low multiplicity (pp)
tpcQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kFALSE);
}
tpcQA->SelectCollisionCandidates(kTriggerMask);
AliPerformanceRes::SetMergeEntriesCut(5000000);
}
// HLT (Alberica Toia)
if (doHLT) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
AliPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kFALSE,0,kTRUE);
hltQA->SelectCollisionCandidates(kTriggerMask);
}
//
// SPD (A. Mastroserio)
//
if (doSPD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSPD* taskspdqa = (AliAnalysisTaskSPD*)AddTaskSPDQA();
// Request from Annalisa
if (iCollisionType==kPbPb || iCollisionType == kXeXe) taskspdqa->SetHeavyIonMode();
taskspdqa->SelectCollisionCandidates(kTriggerMask);
taskspdqa->SetOCDBInfo(run_number, "raw://");
}
//
// SDD (F. Prino)
//
if (doSDD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates(kTriggerMask);
}
//
// SSD dEdx (Marek Chojnacki)
//
if (doSSDdEdx) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates(kTriggerMask);
}
//
// ITS
//
if (doITS) {
// hardcoded non-zero trigger mask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent0010 = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent3050 = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent6080 = 0;
itsQA = AddTaskPerformanceITS(kTRUE);
if(iCollisionType==kPbPb) {
itsQACent0010 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,3500,10000);
itsQACent3050 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,590,1570);
itsQACent6080 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,70,310);
}
else if(iCollisionType==kXeXe) {
itsQACent0010 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,2000,6000);
itsQACent3050 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,350,1000);
itsQACent6080 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,40,200);
}
}
//
// ITS saTracks, align (F.Prino)
//
if (doITSsaTracks) {
// offline trigger in AddTask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskITSsaTracks.C");
AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kTRUE,kFALSE);
itssaTracks->SelectCollisionCandidates(kTriggerMask);
}
if (doITSalign) {
// no offline trigger selection
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskITSAlign.C");
AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
}
//
// Global tracks + V0s QA
//
if(doESDTracks) {
// protection for bug fixed in v5-09-14
Bool_t disable=kTRUE;
if(gSystem->Getenv("ALIEN_JDL_PACKAGES")){
TString packg=gSystem->Getenv("ALIEN_JDL_PACKAGES");
TObjArray* pkgs=packg.Tokenize("##");
Int_t np=pkgs->GetEntries();
Int_t ver,n1,n2;
Char_t str2[20];
for(Int_t i=0; i<np; i++){
TObjString* str=(TObjString*)pkgs->At(i);
TString s=str->GetString();
if(s.Contains("AliPhysics")){
s.ReplaceAll("VO_ALICE@","");
sscanf(s.Data(),"AliPhysics::v%d-%d-%d-%s",&ver,&n1,&n2,str2);
if(ver>=5 && n1>=9 && n2>=14){
printf("%s -> enable ESD track QA\n",s.Data());
disable=kFALSE;
}else{
disable=kTRUE;
printf("%s -> disable ESD track QA\n",s.Data());
}
}
}
}
if(!disable){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckESDTracks.C");
AliAnalysisTaskCheckESDTracks* taskestr=AddTaskCheckESDTracks("QA",kFALSE,kTRUE,kTRUE);
taskestr->SetPtBinning(160,0.,40.);
taskestr->SelectCollisionCandidates(kTriggerMask);
}
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(doTRD) {
// no offline trigger selection
// steer individual TRD tasks
Bool_t
doCheckESD(kTRUE), // AliTRDcheckESD
doCheckDET(kTRUE), // AliTRDcheckDET
doEffic(kTRUE), // AliTRDefficiency
doResolution(kTRUE),// AliTRDresolution
doCheckPID(kFALSE), // AliTRDcheckPID
doV0Monitor(kFALSE);// AliTRDv0Monitor
AliTRDpwgppHelper::AddTrainPerformanceTRD(AliTRDpwgppHelper::Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
// no offline trigger selection
// gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTrainPerformanceTRD.C");
// steer individual TRD tasks
// Bool_t
// doCheckESD(kTRUE), // AliTRDcheckESD
// doCheckDET(kTRUE), // AliTRDcheckDET
// doEffic(kTRUE), // AliTRDefficiency
// doResolution(kTRUE),// AliTRDresolution
// doCheckPID(kFALSE), // AliTRDcheckPID
// doV0Monitor(kFALSE);// AliTRDv0Monitor
// AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
}
//
// ZDC (Chiara Oppedisano)
//
if(doZDC) {
// hardcoded kMB trigger mask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/ZDC/AddTaskZDCQA.C");
AliAnalysisTaskSE *taskZDC = AddTaskZDCQA();
taskZDC->SelectCollisionCandidates(kTriggerMask);
}
//
// Calorimetry (Gustavo Conesa)
//
if(doCALO) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("default");
taskCaloQA->SetDebugLevel(0);
taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetEMCALGeometryName("EMCAL_COMPLETE12SMV1_DCAL_8SM");
taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetImportGeometryFromFile(kFALSE);
taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetNumberOfSuperModulesUsed(20);
AliAnaCalorimeterQA * caloqa = (AliAnaCalorimeterQA*) taskCaloQA->GetAnalysisMaker()->GetListOfAnalysisContainers()->At(0);
AliHistogramRanges* histoRanges = caloqa->GetHistogramRanges();
histoRanges->SetHistoPhiRangeAndNBins(77*TMath::DegToRad(), 330*TMath::DegToRad(), 253) ;
// offline mask set in AddTask to kMB
// taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
// taskCaloQA = AddTaskCalorimeterQA("trigEMC");
// taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
// AliAnalysisTaskCaloTrackCorrelation*taskCaloQA= AddTaskCalorimeterQA("ESD", 2012, kFALSE, kTRUE);
// taskCaloQA->SetDebugLevel(0);
// offline mask set in AddTask to kMB
// taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
// taskCaloQA= AddTaskCalorimeterQA("ESD", 2012, kFALSE, kTRUE, "", "EMC7");
// taskCaloQA->SetDebugLevel(0);
// taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
// AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kTRUE);
// taskCaloQA->SetDebugLevel(0);
// offline mask set in AddTask to kMB
// taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
// taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kTRUE, "", "EMC7");
// taskCaloQA->SetDebugLevel(0);
// taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
}
//
// Muon Trigger
//
if(doMUONTrig) {
// no offline trigger selection
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency(kTRUE);
}
//
// Muon Efficiency (not used)
//
if(doMUONEff)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff *muonEfficiency = AddTaskMUONTrackingEfficiency(kTRUE,kTRUE,"");
if (!isMuonOnly) muonEfficiency->SelectCollisionCandidates(kTriggerMask);
muonEfficiency->UseMCLabel(kTRUE);
}
//
// Muon Performance (Philippe Pillot)
//
//
if (doMUONPerf)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMuonPerformance.C");
AliAnalysisTaskMuonPerformance* muonPerformance = AddTaskMuonPerformance();
if (!isMuonOnly) muonPerformance->SelectCollisionCandidates(kTriggerMask);
muonPerformance->UseMCKinematics(kTRUE);
muonPerformance->SetMCTrigLevelFromMatchTrk(kTRUE);
}
//
// V0-Decay Reconstruction (Ana Marin) (not used)
//
if (doV0) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kTRUE);
}
//
// Impact parameter resolution ([email protected], [email protected])
//
if (doImpParRes) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskImpParRes.C");
AliAnalysisTaskSE* taskimpparres=0;
// Specific setting for MC
if(iCollisionType==kpp || iCollisionType==kpPb || iCollisionType==kPbp) {
taskimpparres= AddTaskImpParRes(kTRUE);
} else {
taskimpparres= AddTaskImpParRes(kTRUE,-1,kTRUE,kFALSE);
}
taskimpparres->SelectCollisionCandidates(kTriggerMask);
}
//
// MUON QA (Philippe Pillot)
//
if (doMUON) {
// trigger analysis internal
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskMuonQA.C");
AliAnalysisTaskMuonQA* taskmuonqa = AddTaskMuonQA(kFALSE);
taskmuonqa->GetTrackCuts()->SetIsMC(kTRUE);
}
//
// TOF (Francesca Bellini)
//
if (doTOF) {
// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
// AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA(kFALSE);
// tofQA->SelectCollisionCandidates(kTriggerMask);
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TOF/AddTaskTOFqaID.C");
AliAnalysisTaskTOFqaID *tofQA = AddTaskTOFqaID(kFALSE, AliVEvent::kAnyINT, 0, kFALSE, "", kTRUE, 0);
// tofQA->SelectCollisionCandidates(kTriggerMask);
}
//
// PIDqa(JENS)
//
if (doPIDqa) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
PIDQA->SelectCollisionCandidates(kTriggerMask);
}
//
// HMPID QA (Giacomo Volpe)
//
if (doHMPID) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/HMPID/AddTaskHmpidQA.C");
AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kTRUE);
// offline mask set in AddTask to kMB
taskhmpidqa->SelectCollisionCandidates(kTriggerMask);
}
// T0 QA (Alla Mayevskaya)
if (doT0) {
// no offline trigger selection
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/T0/AddTaskT0QA.C");
AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
taskt0qa->SelectCollisionCandidates(kTriggerMask);
}
// FMD QA (Christian Holm Christiansen)
if (doFMD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C");
// Parameters: usemc, usecentrality
AliAnalysisTaskSE *forwardQA = (AliAnalysisTaskSE *)AddTaskForwardQA(kTRUE, (Bool_t)doCentrality);
// No offline trigger config. needed (see #84077)
}
//
// PHOS QA (Boris Polishchuk)
//
if (doPHOS) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C");
//AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt");
AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(5, 1, NULL,"PHOSCellsQA_AnyInt");
taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask);
taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
//AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7");
AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(5, 1, NULL,"PHOSCellsQA_PHI7");
taskPHOSCellQA2->SelectCollisionCandidates(AliVEvent::kPHI7);
taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
// Pi0 QA fo PbPb
if (iCollisionType == kPbPb || iCollisionType == kXeXe) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C");
AliAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0);
}
}
if (doPHOSTrig) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_TriggerQA/macros/AddTaskPHOSTriggerQA.C");
AliAnalysisTaskPHOSTriggerQA *taskPHOSTrig = AddTaskPHOSTriggerQA(NULL);
}
//
// EMCAL QA (Gustavo Conesa)
//
if (doEMCAL) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C");
AliAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA();
}
//
// EvTrk QA (Zaida)
//
if (doEvTrk) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EvTrkSelection/AddSingleTrackEfficiencyTaskForAutomaticQA.C");
AliAnalysisTask *task = AddSingleTrackEfficiencyTaskForAutomaticQA();
}
//
// AD QA (Michal Broz))
//
if (doAD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/AD/AddTaskADQA.C");
AliAnalysisTaskADQA *task = AddTaskADQA();
}
//
// FLOW and BF QA (C.Perez && A.Rodriguez)
//
if (doFBFqa) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFBFqa.C");
AliAnalysisTaskSE *qaFBFMB = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE);
qaFBFMB->SelectCollisionCandidates(AliVEvent::kMB);
AliAnalysisTaskSE *qaFBFSC = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFsc",kFALSE);
qaFBFSC->SelectCollisionCandidates(AliVEvent::kSemiCentral);
AliAnalysisTaskSE *qaFBFCE = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE);
qaFBFCE->SelectCollisionCandidates(AliVEvent::kCentral);
}
}
void Hyperon(const char* dataset="collection.xml")
{
/* $Id$ */
TStopwatch timer;
timer.Start();
TStringToken libs("Core,Tree,Geom,VMC,Physics,Minuit,Gui,XMLParser,Minuit2,Proof,STEERBase,ESD,AOD,OADB,ANALYSIS,ANALYSISalice,CDB,RAWDatabase,STEER,CORRFW,PHOSUtils,PHOSbase,PHOSpi0Calib,PHOSrec,PHOSshuttle,PHOSsim", ",");
while( libs.NextToken() )
gSystem->Load( Form("lib%s", libs.Data()) );
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
gSystem->Load("libPWGGAGammaConv");
gSystem->Load("libPWGGAHyperon");
//load analysis framework
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
// Connect to alien
TString token = gSystem->Getenv("GRID_TOKEN") ;
if (1) // token == "OK" )
TGrid::Connect("alien://");
else
AliInfo("You are not connected to the GRID") ;
cout << "Pi0Analysis: processing collection " << dataset << endl;
// Create the chain
TChain* chain = new TChain("aodTree");
TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset));
TAlienResult* result = collection->GetGridResult("",0 ,0);
TList* rawFileList = result->GetFileInfoList();
for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) {
TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(counter)) ;
const char * rawFile = fi->GetCurrentUrl()->GetUrl() ;
printf("Processing %s\n", rawFile) ;
chain->Add(rawFile);
printf("Chain: %d entries.\n",chain->GetEntriesFast());
}
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("Hyperon");
mgr->SetCommonFileName("histos.root");
// AOD input handler
AliAODInputHandler* aodH = new AliAODInputHandler();
mgr->SetInputEventHandler(aodH);
// Debug level
mgr->SetDebugLevel(2);
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask* taskCentrality = AddTaskCentrality();
if (analysisMC)
taskCentrality->SetMCInput();
// // Update it for Hyperon (YK 22.01.2015)
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
// AliEPSelectionTask *taskEP = AddTaskEventplane() ;
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
// AliVZEROEPSelectionTask *selTask = AddTaskVZEROEPSelection();
// Add my task
AliAnalysisHyperon* task = new AliAnalysisHyperon();
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPb/AddTaskPHOSPi0Flow.C"); // Update it for Hyperon (YK 22.01.2015)
// task = AddTaskPHOSPi0Flow();
// // Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("Hyperon",TList::Class(),AliAnalysisManager::kOutputContainer,"HyperonHist.root");
// // Connect input/output
mgr->ConnectInput(task , 0, cinput);
mgr->ConnectOutput(task, 1, coutput1);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
timer.Stop();
timer.Print();
}
void runFlowTaskCentralityKinkTrain( Int_t mode = mLocal,
Bool_t useFlowParFiles = kFALSE,
Bool_t DATA = kTRUE,
const Char_t* dataDir="fileList",
Int_t nEvents = 1e4,
Int_t offset=0 )
{
// Time:
TStopwatch timer;
timer.Start();
// Load needed libraries:
LoadLibraries(mode,useFlowParFiles);
// Create analysis manager:
AliAnalysisManager *mgr = new AliAnalysisManager("FlowAnalysisManager");
// Chains:
if(mode == mLocal)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGUD/macros/CreateESDChain.C");
TChain* chain = CreateESDChain(dataDir, nEvents, offset);
//TChain* chain = CreateAODChain(dataDir, nEvents, offset);
}
// Connect plug-in to the analysis manager:
if(mode == mGrid)
{
gROOT->LoadMacro("CreateAlienHandler.C");
AliAnalysisGrid *alienHandler = CreateAlienHandler(useFlowParFiles);
if(!alienHandler) return;
mgr->SetGridHandler(alienHandler);
}
// Event handlers:
AliVEventHandler* esdH = new AliESDInputHandler;
mgr->SetInputEventHandler(esdH);
if (!DATA)
{
AliMCEventHandler *mc = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mc);
}
// Task to check the offline trigger:
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AddTaskPhysicsSelection(!DATA);
//Add the centrality determination task
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask* centSelTask = AddTaskCentrality();
if (!DATA) centSelTask->SetMCInput();
//add the PID response task
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse* pidresponsetask = AddTaskPIDResponse(!DATA);
//Add the TOF tender
//gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/AddTaskTenderTOF.C");
//AddTaskTenderTOF();
// Setup kink analysis per centrality bin:
gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityKink.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Float_t lowCentralityBinEdge = centralityArray[i];
Float_t highCentralityBinEdge = centralityArray[i+1];
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
-1,2,kTRUE );
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
1,2,kTRUE );
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
-1,3 );
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
1,3 );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
// Setup kaon analysis per centrality bin:
gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityPID.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Float_t lowCentralityBinEdge = centralityArray[i];
Float_t highCentralityBinEdge = centralityArray[i+1];
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
-1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
-1,3 );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
1,3 );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
// Setup He3 analysis per centrality bin:
gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityPID.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Float_t lowCentralityBinEdge = centralityArray[i];
Float_t highCentralityBinEdge = centralityArray[i+1];
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
-1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
-1,3 );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
1,3 );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
// Enable debug printouts:
mgr->SetDebugLevel(2);
// Run the analysis:
if(!mgr->InitAnalysis()) return;
mgr->PrintStatus();
if(mode == mLocal)
{
mgr->StartAnalysis("local",chain);
}
else if(mode == mPROOF)
{
mgr->StartAnalysis("proof",dataDir,nEvents,offset);
}
else if(mode == mGrid)
{
mgr->StartAnalysis("grid");
}
// Print real and CPU time used for analysis:
timer.Stop();
timer.Print();
} // end of void runFlowTaskCentralityPIDTrain(...)
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;
}