/**
* Create the MC input handler. Overwritten here to allow setting
* the pre-read mode.
*
* @param type Input type
* @param mc True for MC
*
* @return The MC input handler
*/
AliVEventHandler* CreateMCHandler(UShort_t type, bool mc)
{
AliMCEventHandler* ret =
static_cast<AliMCEventHandler*>(TrainSetup::CreateMCHandler(type,mc));
if (ret) ret->SetPreReadMode(AliMCEventHandler::kLmPreRead);
return ret;
}
AliAnalysisTaskPsEfficiency* AddTaskPsEfficiency(bool isMC=true,TString suffix = ""){
// Creates, configures and attaches to the train the task for pi, K , p spectra
// with ITS standalone tracks
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
::Info("AddTaskPsEfficiency","Adding a new task with this settings isMC = %i",isMC);
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskPsEfficiency", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskPsEfficiency", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
if(type.Contains("ESD")){
::Error("AddTaskPsEfficiency", "This task requires to run on AOD");
return NULL;
}
// Add MC handler (for kinematics)
if(isMC){
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
}
// Create and configure the task
TString tskname = "Pentaquark";
tskname.Append(Form("%s",suffix.Data()));
AliAnalysisTaskPsEfficiency *taskPs = new AliAnalysisTaskPsEfficiency(tskname);
//taskPs->SetMC(isMC);
mgr->AddTask(taskPs);
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
TString outputFileName = AliAnalysisManager::GetCommonFileName();
outputFileName += ":AODpentaquark";
AliAnalysisDataContainer *coutput =0x0;
coutput = mgr->CreateContainer(Form("lbariogl_%s",tskname.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
AliAnalysisManager::GetCommonFileName());
mgr->ConnectInput(taskPs, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(taskPs, 1, coutput);
return taskPs;
}
void RunLinkToMCAnalysisExample(const char* esdFile = "./AliESDs.root")
{
// Load needed libraries
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libPWGHFbase");
gSystem->Load("libPWGmuon");
// Create the TChain for esdTrees in the AliESDs.root file.
TChain* chain = new TChain("esdTree");
chain->Add(esdFile);
if (!chain) return;
// Create the analysis manager and event handlers.
AliAnalysisManager* mgr = new AliAnalysisManager("Analysis Train", "An example analysis train setup for AliAnalysisTaskLinkToMC.");
AliESDInputHandler* esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetReadTR(kTRUE);
AliAODHandler* aodHandler = new AliAODHandler();
mgr->SetOutputEventHandler(aodHandler);
aodHandler->SetOutputFileName("AliAOD.root");
// Create the analysis task and setup the parameters.
AliAnalysisTaskLinkToMC* linktask = new AliAnalysisTaskLinkToMC("Task to link ESD tracks to corresponding MC tracks.");
linktask->MinClusters(6);
linktask->HardCutLimitX(4);
linktask->HardCutLimitY(4);
linktask->SigmaCut(5.);
linktask->MinClustersInSt45(3);
linktask->StationMustMatch(1, true); // At least one cluster in station 1 must match.
linktask->StationMustMatch(2, true); // At least one cluster in station 2 must match.
linktask->StationMustMatch(3, true); // At least one cluster in station 3 must match.
linktask->GenerateHistograms(true);
mgr->AddTask(linktask);
// Create the input and output containers and connect them up to the analysis task.
AliAnalysisDataContainer* cinEsd = mgr->GetCommonInputContainer();
AliAnalysisDataContainer* coutAod = mgr->GetCommonOutputContainer();
AliAnalysisDataContainer* coutHists = mgr->CreateContainer("cHists", TList::Class(), AliAnalysisManager::kOutputContainer, "hists.root");
mgr->ConnectInput(linktask, 0, cinEsd);
mgr->ConnectOutput(linktask, 0, coutAod);
mgr->ConnectOutput(linktask, 1, coutHists);
if (mgr->InitAnalysis())
{
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
}
AliAnalysisTaskDG* AddAnalysisTaskDG(Bool_t isMC,
TString branchNames,
TString trackCutType,
TString triggerSelection,
TString triggerSelectionSPD="",
Int_t maxTracksSave=4)
{
// create manager
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) mgr = new AliAnalysisManager("My test train");
if (isMC) {
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
}
AliAnalysisTaskDG* task = new AliAnalysisTaskDG;
// task->SelectCollisionCandidates(AliVEvent::kMB);
task->SetIsMC(isMC);
task->SetBranchNames(branchNames);
task->SetTrackCutType(trackCutType);
task->SetTriggerSelection(triggerSelection);
task->SetTriggerSelectionSPD(triggerSelectionSPD);
task->SetMaxTracksSave(maxTracksSave);
Printf("created task");
// OUTPUT --------------------------------------------------------------------
AliAnalysisDataContainer* output1 =
mgr->CreateContainer(task->GetListName(), TList::Class(), AliAnalysisManager::kOutputContainer,
TString(AliAnalysisManager::GetCommonFileName())+":"+task->GetResultsFileName());
AliAnalysisDataContainer* output2 =
mgr->CreateContainer(task->GetTreeName(), TTree::Class(), AliAnalysisManager::kOutputContainer,
TString(AliAnalysisManager::GetCommonFileName())+":"+task->GetResultsFileName());
mgr->AddTask(task);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output1);
mgr->ConnectOutput(task, 2, output2);
Printf("set up task connections");
Printf("--------------------------------------------------------------------------------");
return task;
}
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());
}
//______________________________________________________________________________
// creates an AliAnalysisTaskCEP and the output containers
//
AliAnalysisTaskSE* AddTaskCEPAnalysis (
TString taskname = TString("CEPAnalysis"),
UInt_t taskconfig = AliCEPBase::kBitConfigurationSet,
Int_t rnummin,
Int_t rnummax,
Int_t numTracksMax = 6,
Double_t fracDG = 1.0,
Double_t fracNDG = 0.0,
UInt_t ETmaskDG = AliCEPBase::kETBaseLine,
UInt_t ETpatternDG = AliCEPBase::kETBaseLine,
UInt_t ETmaskNDG = AliCEPBase::kETBaseLine,
UInt_t ETpatternNDG = AliCEPBase::kETBaseLine,
UInt_t TTmask = AliCEPBase::kTTBaseLine,
UInt_t TTpattern = AliCEPBase::kTTBaseLine
)
{
// get the manager and task
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
// check for MonteCarlo
Bool_t isMC = (taskconfig&AliCEPBase::kBitisMC)==AliCEPBase::kBitisMC;
if (isMC) {
AliMCEventHandler* MChandler = new AliMCEventHandler;
MChandler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(MChandler);
}
// create the analysis task
AliAnalysisTaskCEP *task = new AliAnalysisTaskCEP (
taskname.Data(),taskconfig,
rnummin,rnummax,
numTracksMax,
fracDG,fracNDG,
ETmaskDG,ETpatternDG,ETmaskNDG,ETpatternNDG,TTmask,TTpattern
);
// get input and output managers
AliAnalysisDataContainer *aadci = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *aadco1 = mgr->CreateContainer
(
Form("CEPHist"),
TList::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s", AliAnalysisManager::GetCommonFileName())
);
AliAnalysisDataContainer *aadco2 = mgr->CreateContainer
(
Form("CEPTree"),
TTree::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s", AliAnalysisManager::GetCommonFileName())
);
// add task and connect input and output managers
mgr->AddTask(task);
mgr->ConnectInput (task,0,aadci);
mgr->ConnectOutput(task,1,aadco1);
mgr->ConnectOutput(task,2,aadco2);
// return pointer to Task
return task;
}
void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Int_t aProof = kFALSE, Int_t requiredData = 1, const char* option = "")
{
// runWhat options: 0 = AlidNdEtaTask
// 1 = AlidNdEtaCorrectionTask
// 2 = both
//
// aProof option: 0 no proof
// 1 proof with chain
// 2 proof with dataset
//
// requiredData option: 0 = only ESD
// 1 = ESD+MC
// 2 = RAW (ESD+check on event type)
//
// option is passed to the task(s)
// option SAVE is removed and results in moving the output files to maps/<ds name>/<trigger>/<det>
//
TString taskName;
if (runWhat == 0 || runWhat == 2)
{
Printf("Running AlidNdEtaTask");
}
if (runWhat == 1 || runWhat == 2)
{
Printf("Running AlidNdEtaCorrectionTask");
if (requiredData != 1)
{
Printf("AlidNdEtaCorrectionTask needs MC. Exiting...");
return;
}
}
if (nRuns < 0)
nRuns = 1234567890;
if (aProof)
{
TProof::Open("alice-caf");
Bool_t fullAliroot = kFALSE;
// Enable the needed package
if (1)
{
gProof->UploadPackage("$ALICE_ROOT/STEERBase");
gProof->EnablePackage("$ALICE_ROOT/STEERBase");
gProof->UploadPackage("$ALICE_ROOT/ESD");
gProof->EnablePackage("$ALICE_ROOT/ESD");
gProof->UploadPackage("$ALICE_ROOT/AOD");
gProof->EnablePackage("$ALICE_ROOT/AOD");
gProof->UploadPackage("$ALICE_ROOT/ANALYSIS");
gProof->EnablePackage("$ALICE_ROOT/ANALYSIS");
gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice");
gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice");
}
else if (!fullAliroot)
{
gProof->UploadPackage("$ALICE_ROOT/AF-v4-18-12-AN.par");
gProof->EnablePackage("AF-v4-18-12-AN");
}
else
{
// needed if ITS recpoints are accessed, see AlidNdEtaTask, FULLALIROOT define statement
gProof->UploadPackage("$ALICE_ROOT/v4-18-15-AN-all.par");
gProof->EnablePackage("v4-18-15-AN-all");
gProof->Exec("TGrid::Connect(\"alien://\")", kTRUE);
// TODO add this to loadlibs.C
gProof->Exec("gSystem->Load(\"libXMLParser\")", kTRUE);
}
gProof->UploadPackage("$ALICE_ROOT/PWG0base");
gProof->EnablePackage("$ALICE_ROOT/PWG0base");
}
else
{
gSystem->AddIncludePath("-I${ALICE_ROOT}/include/ -I${ALICE_ROOT}/PWG0/ -I${ALICE_ROOT}/PWG0/dNdEta/");
gSystem->Load("libVMC");
gSystem->Load("libTree");
gSystem->Load("libProof");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libPWG0base");
}
// Create the analysis manager
mgr = new AliAnalysisManager;
// Add ESD handler
if (fullAliroot)
AliESDInputHandler* esdH = new AliESDInputHandlerRP; // for RecPoints
else
AliESDInputHandler* esdH = new AliESDInputHandler;
esdH->SetInactiveBranches("FMD AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks MuonTracks TrdTracks");
mgr->SetInputEventHandler(esdH);
AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn;
//AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn | AliPWG0Helper::kSPDOnlyL0;
//AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPCITS | AliPWG0Helper::kFieldOn;
AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kAcceptAll | AliTriggerAnalysis::kOfflineFlag;
//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kAcceptAll | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle;
//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kSPDGFOBits | AliTriggerAnalysis::kOfflineFlag;
//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kSPDGFOBits | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle;
//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0AND | AliTriggerAnalysis::kOfflineFlag;
//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0OR | AliTriggerAnalysis::kOfflineFlag;
//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0OR | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle;
AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kMCFlags;
//AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kE710Cuts;
AliPWG0Helper::PrintConf(analysisMode, trigger, diffTreatment);
AliESDtrackCuts* esdTrackCuts = 0;
if (!(analysisMode & AliPWG0Helper::kSPD))
{
// selection of esd tracks
gROOT->ProcessLine(".L ../CreateStandardCuts.C");
esdTrackCuts = CreateTrackCuts(analysisMode);
if (!esdTrackCuts)
{
printf("ERROR: esdTrackCuts could not be created\n");
return;
}
esdTrackCuts->SetHistogramsOn(kTRUE);
}
cInput = mgr->GetCommonInputContainer();
// remove SAVE option if set
Bool_t save = kFALSE;
TString optStr(option);
if (optStr.Contains("SAVE"))
{
optStr = optStr(0,optStr.Index("SAVE")) + optStr(optStr.Index("SAVE")+4, optStr.Length());
save = kTRUE;
}
// physics selection
gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
physicsSelectionTask = AddTaskPhysicsSelection((requiredData == 2) ? kFALSE : kTRUE);
// 900 GeV
if (0 && requiredData == 2)
{
physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #769 #3119");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL #446 #2554");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1C-ABCE-NOPF-ALL #1334 #2228");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1-E-NOPF-ALL #790");
}
// 7 TeV, run 114783
if (0 && requiredData == 2)
{
physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #345");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL #2130");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1C-ABCE-NOPF-ALL #3018");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1-E-NOPF-ALL #1238");
}
// 7 TeV, run 114786,98
if (0 && requiredData == 2)
{
physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #346");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL #2131");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1C-ABCE-NOPF-ALL #3019");
physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1-E-NOPF-ALL #1238");
//physicsSelectionTask->GetPhysicsSelection()->Initialize(114786);
}
// FO efficiency (for MC)
if (0 && requiredData != 2)
{
//const char* fastORFile = "spdFOEff_run104824_52.root";
//const char* fastORFile = "spdFOEff_run104867_92.root";
//const char* fastORFile = "spdFOEff_run105054_7.root";
const char* fastORFile = "spdFOEff_run114931.root";
Printf("NOTE: Simulating FAST-OR efficiency on the analysis level using file %s", fastORFile);
TFile::Open(fastORFile);
spdFOEff = (TH1F*) gFile->Get("spdFOEff");
physicsSelectionTask->GetPhysicsSelection()->Initialize(114931);
physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis()->SetSPDGFOEfficiency(spdFOEff);
}
// V0 syst. study
if (0)
{
Printf("NOTE: Systematic study for VZERO enabled!");
physicsSelectionTask->GetPhysicsSelection()->Initialize(104867);
for (Int_t i=0; i<1; i++)
{
// for MC and data
//physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(15, 61.5, 86.5);
physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(6);
// only for MC
//physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(0, 0, 125);
//physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(0);
}
}
// BG study
//physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1A-ABCE-NOPF-ALL");
//physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1C-ABCE-NOPF-ALL");
// Create, add task
if (runWhat == 0 || runWhat == 2)
{
Load("AlidNdEtaTask", aDebug);
task = new AlidNdEtaTask(optStr);
if (requiredData == 1)
task->SetReadMC();
//physicsSelectionTask->GetPhysicsSelection()->SetBin0Callback("AlidNdEtaTask");
// syst. error flags
//task->SetUseMCVertex();
//task->SetUseMCKine();
//task->SetOnlyPrimaries();
//task->SetFillPhi();
//task->SetSymmetrize();
// INEL>0 definition
if (trigger & AliTriggerAnalysis::kOneParticle)
task->SetMultAxisEta1();
task->SetTrigger(trigger);
task->SetAnalysisMode(analysisMode);
task->SetTrackCuts(esdTrackCuts);
//task->SetDeltaPhiCut(0.064);
task->SetDiffTreatment(diffTreatment);
mgr->AddTask(task);
// Attach input
mgr->ConnectInput(task, 0, cInput);
// Attach output
cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer);
mgr->ConnectOutput(task, 1, cOutput);
}
if (runWhat == 1 || runWhat == 2)
{
Load("AlidNdEtaCorrectionTask", aDebug);
task2 = new AlidNdEtaCorrectionTask(optStr);
// syst. error flags
//task2->SetFillPhi();
//task2->SetOnlyPrimaries();
//task2->SetSymmetrize();
// to account for gaps in real life SPD geometry
task2->SetSkipParticles();
// INEL>0 definition
if (trigger & AliTriggerAnalysis::kOneParticle)
task2->SetMultAxisEta1();
task2->SetTrigger(trigger);
task2->SetAnalysisMode(analysisMode);
task2->SetTrackCuts(esdTrackCuts);
//task2->SetDeltaPhiCut(0.064);
task2->SetDiffTreatment(diffTreatment);
mgr->AddTask(task2);
// Attach input
mgr->ConnectInput(task2, 0, cInput);
// Attach output
cOutput = mgr->CreateContainer("cOutput2", TList::Class(), AliAnalysisManager::kOutputContainer);
mgr->ConnectOutput(task2, 0, cOutput);
}
if (requiredData == 1)
{
// Enable MC event handler
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
}
// Enable debug printouts
if (aDebug)
mgr->SetDebugLevel(2);
// Run analysis
mgr->InitAnalysis();
mgr->PrintStatus();
if (aProof == 2)
{
// process dataset
mgr->StartAnalysis("proof", data, nRuns, offset);
if (save)
{
TString path("maps/");
path += TString(data).Tokenize("/")->Last()->GetName();
UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags;
switch (triggerNoFlags)
{
case AliTriggerAnalysis::kMB1: path += "/mb1"; break;
case AliTriggerAnalysis::kMB2: path += "/mb2"; break;
case AliTriggerAnalysis::kMB3: path += "/mb3"; break;
case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break;
case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break;
case AliTriggerAnalysis::kAcceptAll: path += "/all"; break;
case AliTriggerAnalysis::kV0AND: path += "/v0and"; break;
case AliTriggerAnalysis::kV0OR: path += "/v0or"; break;
case AliTriggerAnalysis::kNSD1: path += "/nsd1"; break;
case AliTriggerAnalysis::kMB1Prime: path += "/mb1prime"; break;
default: Printf("ERROR: Trigger undefined for path to files"); return;
}
if (trigger & AliTriggerAnalysis::kOneParticle)
path += "-onepart";
if (strlen(requireClass) > 0 && strlen(rejectClass) == 0)
{
path += Form("/%s", requireClass);
}
else if (strlen(rejectClass) > 0)
path += Form("/%s--%s", requireClass, rejectClass);
if (analysisMode & AliPWG0Helper::kSPD)
path += "/spd";
if (analysisMode & AliPWG0Helper::kSPDOnlyL0)
path += "onlyL0";
if (analysisMode & AliPWG0Helper::kTPC)
path += "/tpc";
if (analysisMode & AliPWG0Helper::kTPCITS)
path += "/tpcits";
gSystem->mkdir(path, kTRUE);
if (runWhat == 0 || runWhat == 2)
{
gSystem->Rename("analysis_esd_raw.root", path + "/analysis_esd_raw.root");
if (requiredData == 1)
gSystem->Rename("analysis_mc.root", path + "/analysis_mc.root");
}
if (runWhat == 1 || runWhat == 2)
{
if (optStr.Contains("process-types"))
gSystem->Rename("correction_mapprocess-types.root", path + "/correction_mapprocess-types.root");
else
gSystem->Rename("correction_map.root", path + "/correction_map.root");
}
gSystem->Rename("event_stat.root", path + "/event_stat.root");
Printf(">>>>> Moved files to %s", path.Data());
}
}
else if (aProof == 3)
{
gROOT->ProcessLine(".L CreateChainFromDataSet.C");
ds = gProof->GetDataSet(data)->GetStagedSubset();
chain = CreateChainFromDataSet(ds, "esdTree", nRuns);
mgr->StartAnalysis("local", chain, 1234567890, offset);
}
else
{
// Create chain of input files
gROOT->LoadMacro("../CreateESDChain.C");
chain = CreateESDChain(data, nRuns, offset);
//chain = CreateChain("TE", data, nRuns, offset);
mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain);
}
}
AliAnalysisTaskHypCrossCheck *AddTaskHypCrossCheck(Bool_t readMC=kFALSE,
Bool_t fillTree=kFALSE,
Bool_t fillGen=kFALSE,
TString suffix = ""){
// Creates, configures and attaches to the train the task for pi, K , p spectra
// with ITS standalone tracks
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
::Info("AddTaskHypCrossCheck","Adding a new task with this settings readMC = %i",readMC);
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskHypCrossCheck", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskHypCrossCheck", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
if(type.Contains("AOD")){
::Error("AddTaskHypCrossCheck", "This task requires to run on ESD");
return NULL;
}
// Add MC handler (for kinematics)
if(readMC){
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
}
// Create and configure the task
TString tskname = "hypertriton";
tskname.Append(Form("%s",suffix.Data()));
AliAnalysisTaskHypCrossCheck *taskhyp = new AliAnalysisTaskHypCrossCheck();
Float_t p[5] = {7.25105e-01,4.99820e+01,2.35714e-10,2.49196e+00,1.41570e+01};
taskhyp->SetCustomTPCpid(p,0.08f);
mgr->AddTask(taskhyp);
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
TString outputFileName = AliAnalysisManager::GetCommonFileName();
outputFileName += ":ESDHypertriton";
AliAnalysisDataContainer *coutput =0x0;
coutput = mgr->CreateContainer(Form("strogolo_%s",tskname.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
AliAnalysisManager::GetCommonFileName());
mgr->ConnectInput(taskhyp, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(taskhyp, 1, coutput);
if(fillTree){
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("trogolo_HyperTree", TTree::Class(),
AliAnalysisManager::kOutputContainer,
"trogolo_HyperNt.root");
coutput2->SetSpecialOutput();
mgr->ConnectOutput(taskhyp,2, coutput2);
}
if(fillGen){
AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("trogolo_HyperGen",TTree::Class(),
AliAnalysisManager::kOutputContainer,
"trogolo_HyperGen.root");
coutput3->SetSpecialOutput();
mgr->ConnectOutput(taskhyp,3,coutput3);
}
return taskhyp;
}
void QAtrainAOD(Bool_t isMC=kFALSE, Int_t iCollisionType=0){
if(gSystem->Getenv("ALIEN_JDL_LPMINTERACTIONTYPE")){
for (Int_t icoll = 0; icoll < kNSystem; icoll++)
if (strcmp(gSystem->Getenv("ALIEN_JDL_LPMINTERACTIONTYPE"), CollisionSystem[icoll]) == 0){
iCollisionType = icoll;
break;
}
}
printf("--------------------------------------\n");
if(isMC) printf("Run the AOD QA train for Monte Carlo\n");
else printf("Run the AOD QA train for data\n");
printf("Collision System is %s\n",CollisionSystem[iCollisionType]);
printf("--------------------------------------\n");
UInt_t kTriggerMask = AliVEvent::kINT7 | AliVEvent::kINT8;
if(gSystem->Getenv("ALIEN_JDL_LPMANCHORYEAR"))
{
Int_t year = atoi(gSystem->Getenv("ALIEN_JDL_LPMANCHORYEAR"));
if(year <= 2015)
kTriggerMask = AliVEvent::kAnyINT;
}
// Create manager
AliAnalysisManager *mgr = new AliAnalysisManager("QAtrainAOD", "AOD QA train");
mgr->SetCacheSize(0);
mgr->SetCommonFileName("QAresults_AOD.root");
// Input handler
AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
AliAODInputHandler* aodHandler = new AliAODInputHandler();
mgr->SetInputEventHandler(aodHandler);
if(isMC){
AliMCEventHandler* MChandler = new AliMCEventHandler;
MChandler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(MChandler);
}
TString macroName="";
// Physics selection
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC);
mgr->AddStatisticsTask(kTriggerMask);
AliAnalysisDataContainer *cstatsout = (AliAnalysisDataContainer*)mgr->GetOutputs()->FindObject("cstatsout");
cstatsout->SetFileName("EventStat_temp_AOD.root");
// PID response
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskSE *setupTask = AddTaskPIDResponse(isMC);
// PIDqa
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
PIDQA->SelectCollisionCandidates(AliVEvent::kAny);
// MultSelection
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
AliMultSelectionTask *taskMult = AddTaskMultSelection();
if(isMC){
if (gSystem->Getenv("CONFIG_PERIOD")){
TString periodName = gSystem->Getenv("CONFIG_PERIOD");
taskMult->SetAlternateOADBforEstimators(periodName);
}
}
// Vertex QA
macroName="$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckVertexAOD.C";
if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){
gROOT->LoadMacro(macroName.Data());
Double_t maxMult=500.;
if(iCollisionType==kPbPb || iCollisionType==kXeXe) maxMult=10000.;
AliAnalysisTaskCheckVertexAOD *taskVert = AddTaskCheckVertexAOD("QA",maxMult,AliVEvent::kAnyINT,isMC);
}else{
printf("Macro %s not found -> task will not be executed\n",macroName.Data());
}
// Track QA
macroName="$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckAODTracks.C";
if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){
gROOT->LoadMacro(macroName.Data());
Bool_t usMCtruthForPID=isMC;
AliAnalysisTaskCheckAODTracks* taskAODtr = AddTaskCheckAODTracks("QA",isMC,usMCtruthForPID);
if(iCollisionType==kPbPb || iCollisionType==kXeXe) taskAODtr->SetUpperMultiplicity(10000.);
}else{
printf("Macro %s not found -> task will not be executed\n",macroName.Data());
}
// HF deltaAOD QA
macroName="$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskBasicHFQA.C";
if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){
gROOT->LoadMacro(macroName.Data());
AliAnalysisTaskSEHFQA* dqaHF = AddTaskBasicHFQA(AliAnalysisTaskSEHFQA::kD0toKpi,isMC,"QA");
}else{
printf("Macro %s not found -> task will not be executed\n",macroName.Data());
}
if(isMC){
macroName="$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskDmesonMCPerform.C";
if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){
gROOT->LoadMacro(macroName.Data());
AliAnalysisTaskDmesonMCPerform* dMCp = AddTaskDmesonMCPerform("QA");
}else{
printf("Macro %s not found -> task will not be executed\n",macroName.Data());
}
}
TChain *chainAOD = new TChain("aodTree");
TChain *chainAODfriend = new TChain("aodTree");
chainAOD->Add("AliAOD.root");
chainAODfriend->Add("AliAOD.VertexingHF.root");
chainAOD->AddFriend(chainAODfriend);
TStopwatch timer;
timer.Start();
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->SetSkipTerminate(kTRUE);
mgr->StartAnalysis("local", chainAOD);
}
gSystem->Exec("rm TreeOfAODTracks.root");
timer.Print();
}
//_____________________________________________________________________________
void RunPerformanceTrain(Char_t *file="esd.root", Int_t runNumber = 2, const char* triggerClass ="CINT1B-ABCE-NOPF-ALL", Bool_t bUseMCInfo=kFALSE, Bool_t bUseESDfriend=kTRUE, Bool_t bGrid=kFALSE)
{
//
// Grid settings
// use GSI::SE
if(bGrid) {
gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE");
TGrid * alien = TGrid::Connect("alien://",0,0,"t");
gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE");
}
//
// Train Configuration
//
Int_t iPWGPPperfTPC = 1; // Test TPC performance
Int_t iPWGPPperfTRD = 0; // Test TRD performance
Int_t iPWGPPperfITS = 0; // Test ITS performance
Int_t iPWGPPperfCalo = 0; // Test Calo performance
Int_t iPWGPPperfMuonTrig = 0; // Test Muon Trigger performance
Int_t iPWGPPperfMuonEff = 0; // Test Muon Efficiency performance
Int_t iPWGPPperfTOF = 0; // Test TOF-TPC matching performance
Int_t iPWGPPperfPrimVertex = 0; // Test Primary Vertex performance
Int_t iPWGPPv0QA = 0; // V0 algorithm QA task
//
// Load Libraries
//
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libTender");
gSystem->Load("libCORRFW");
gSystem->Load("libTPCcalib");
gSystem->Load("libPWGPP");
gSystem->Load("libPHOSUtils");
gSystem->Load("libEMCALUtils");
gSystem->Load("libPWG4PartCorrBase");
gSystem->Load("libPWG4PartCorrDep");
gSystem->Load("libPWGmuon"); // The class is here
//
// OCDB Configuration
//
AliCDBManager *cdbManager = AliCDBManager::Instance();
cdbManager->SetDefaultStorage("local:///lustre/alice/alien/alice/data/2009/OCDB");
//cdbManager->SetDefaultStorage("local://$ALICE_PHYSICS/OCDB");
//cdbManager->SetSpecificStorage("GRP/GRP/Data", Form("local://%s",gSystem->pwd()));
cdbManager->SetRun(runNumber);
//cdbManager->SetCacheFlag(kFALSE);
// initialize magnetic field from the GRP manager.
//if(magField==0) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", 0., 0., AliMagF::k2kG));
//if(magField==1) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1., AliMagF::k2kG));
//if(magField==2) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1., AliMagF::k5kG));
/*
AliGRPManager grpMan;
grpMan.ReadGRPEntry();
grpMan.SetMagField();
AliRunInfo *runInfo = grpMan.GetRunInfo();
//
// Load geometry
//
*/
AliGeomManager::LoadGeometry();
//
// Swtich off all AliInfo (too much output!)
//
AliLog::SetGlobalLogLevel(AliLog::kError);
//
// Create input ESD chain
//
/*
gROOT->LoadMacro("$ALICE_PHYSICS/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain(list,nFiles,fistFile);
if(!chain) {
Error("RunPerformanceTrain","ESD chain not created!");
return;
}
*/
TChain *chain = new TChain("esdTree");
if(!chain) {
Error("RunPerformanceTrain","ESD chain not created!");
return;
}
chain->Add(file);
chain->Lookup();
//
// Create analysis manager
//
AliAnalysisManager *mgr = new AliAnalysisManager;
if(!mgr) {
Error("RunPerformanceTrain","AliAnalysisManager not set!");
return;
}
//
// Set ESD input handler
//
AliESDInputHandler* esdH = new AliESDInputHandler;
if(!esdH) {
Error("RunPerformanceTrain","AliESDInputHandler not created!");
return;
}
if(bUseESDfriend) esdH->SetActiveBranches("ESDfriend");
mgr->SetInputEventHandler(esdH);
/*
//
// Set RecPoints and ESD input handler
//
AliESDInputHandlerRP* rpH = new AliESDInputHandlerRP;
if(!rpH) {
Error("RunPerformanceTrain","AliESDInputHandlerRP not created!");
return;
}
if(bUseESDfriend) rpH->SetActiveBranches("ESDfriend");
mgr->SetInputEventHandler(rpH);
*/
//
// Set MC input handler
//
if(bUseMCInfo) {
AliMCEventHandler* mcH = new AliMCEventHandler;
if(!mcH) {
Error("RunPerformanceTrain","AliMCEventHandler not created!");
return;
}
mcH->SetReadTR(kTRUE);
mgr->SetMCtruthEventHandler(mcH);
}
//
// Add task to AliAnalysisManager
//
//
// TPC performance
//
if(iPWGPPperfTPC) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceTPC.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPC(bUseMCInfo,bUseESDfriend,triggerClass);
if(!tpcQA) {
Error("RunPerformanceTrain","AliPerformanceTask not created!");
return;
}
}
else {
Printf("RunPerformanceTrain: TPC Performance - EXCLUDED!");
}
//
// TRD perormance
//
if(iPWGPPperfTRD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTrainPerformanceTRD.C");
if(!AddTrainPerformanceTRD(bUseMCInfo,bUseESDfriend)) {
Error("RunPerformanceTrain","TrainPerformanceTRD not created!");
return;
}
} else {
Printf("RunPerformanceTrain: TRD TrainPerformanceTRD - EXCLUDED!");
}
//
// ITS performance
//
if(iPWGPPperfITS) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(bUseMCInfo);
if(!itsQA) {
Error("RunPerformanceTrain","AliAnalysisTaskITSTrackingCheck not created!");
return;
}
}
else {
Printf("RunPerformanceTrain: AliAnalysisTaskITSTrackingCheck - EXCLUDED!");
}
//
// Calorimeter Performance
//
if(iPWGPPperfCalo) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWG4/macros/AddTaskCalorimeterQA.C");
AliAnalysisTaskParticleCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD",bUseMCInfo,kFALSE);
if(!taskCaloQA) {
Error("RunPerformanceTrain","AliAnalysisTaskParticleCorrelation not created!");
return;
}
mgr->AddTask(taskCaloQA);
}
else {
Printf("RunPerformanceTrain: AliAnalysisTaskParticleCorrelation - EXCLUDED!");
}
//
// Muon Trigger
//
if(iPWGPPperfMuonTrig) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
if(!taskMuonTrig) {
Error("RunPerformanceTrain","AliAnalysisTaskTrigChEff not created!");
return;
}
mgr->AddTask(taskMuonTrig);
}
else {
Printf("RunPerformanceTrain: AliAnalysisTaskTrigChEff - EXCLUDED!");
}
//
// Muon Efficiency
//
if(iPWGPPperfMuonEff) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWG3/muondep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff *taskMuonTrackEff = AliAnalysisTaskMuonTrackingEff();
if(!taskMuonTrackEff) {
Error("RunPerformanceTrain","AliAnalysisTaskMuonTrackingEff not created!");
return;
}
mgr->AddTask(taskMuonTrackEff);
}
else {
Printf("RunPerformanceTrain: Muon Efficiency - EXCLUDED!");
}
//
// TOF performance
//
if(iPWGPPperfTOF) {
//
}
else {
Printf("RunPerformanceTrain: TOF - EXCLUDED!");
}
//
// PWGPP Primary Vertex
//
if(iPWGPPperfPrimVertex) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD *taskPrimVertex = AddTaskVertexESD();
if(!taskPrimVertex) {
Error("RunPerformanceTrain","AliAnalysisTaskVertexESD not created!");
return;
}
}
else {
Printf("RunPerformanceTrain: AliAnalysisTaskVertexESD - EXCLUDED!");
}
//
// PWGPP V0 QA
//
if (iPWGPPv0QA) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(bUseMCInfo);
if(!taskv0QA) {
Error("RunPerformanceTrain","AliAnalysisTaskV0QA not created!");
return;
}
}
else {
Printf("RunPerformanceTrain: AliAnalysisTaskV0QA - EXCLUDED!");
}
//
// Disable debug printouts
//
mgr->SetDebugLevel(0);
if (!mgr->InitAnalysis())
return;
mgr->PrintStatus();
//mgr->StartAnalysis("local",chain, nEvents, firstEvent);
mgr->StartAnalysis("local",chain);
}
//______________________________________________________________________________
void AODtrain(Int_t merge=0)
{
// Main analysis train macro.
ProcessEnvironment();
UpdateFlags();
PrintSettings();
if (merge || doCDBconnect) {
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("AODtrain", "No grid connection");
return;
}
}
// Set temporary merging directory to current one
gSystem->Setenv("TMPDIR", gSystem->pwd());
// Set temporary compilation directory to current one
gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
printf("==================================================================\n");
printf("=========== RUNNING FILTERING TRAIN ==========\n");
printf("=========== Collision System is %s ==========\n",CollisionSystem[iCollision]);
printf("==================================================================\n");
printf("= Configuring analysis train for: =\n");
if (usePhysicsSelection) printf("= Physics selection =\n");
if (useTender) printf("= TENDER =\n");
if (iESDfilter) printf("= ESD filter =\n");
if (iMUONcopyAOD) printf("= MUON copy AOD =\n");
if (iJETAN) printf("= Jet analysis =\n");
if (iJETANdelta) printf("= Jet delta AODs =\n");
if (iPWGHFvertexing) printf("= PWGHF vertexing =\n");
if (iPWGDQJPSIfilter) printf("= PWGDQ j/psi filter =\n");
if (iPWGHFd2h) printf("= PWGHF D0->2 hadrons QA =\n");
// Make the analysis manager and connect event handlers
AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train");
mgr->SetCacheSize(0);
if (useSysInfo) {
//mgr->SetNSysInfo(100);
AliSysInfo::SetVerbose(kTRUE);
}
// Create input handler (input container created automatically)
// ESD input handler
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
// Monte Carlo handler
if (useMC) {
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetReadTR(useTR);
}
// AOD output container, created automatically when setting an AOD handler
if (iAODhandler) {
// AOD output handler
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName("AliAOD.root");
mgr->SetOutputEventHandler(aodHandler);
}
// Debugging if needed
if (useDBG) mgr->SetDebugLevel(3);
AddAnalysisTasks(cdbPath);
if (merge) {
AODmerge();
mgr->InitAnalysis();
mgr->SetGridHandler(new AliAnalysisAlien);
mgr->StartAnalysis("gridterminate",0);
return;
}
// Run the analysis
//
TChain *chain = CreateChain();
if (!chain) return;
TStopwatch timer;
timer.Start();
mgr->SetSkipTerminate(kTRUE);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
timer.Print();
}
//______________________________________________________________________________
void QAtrainsim(Int_t run = 0,
const char *xmlfile = "wn.xml",
Int_t stage = 0, /*0 = QA train, 1...n - merging stage*/
const char *cdb = "raw://")
{
run_number = run;
ProcessEnvironment();
//
// set OCDB source
TString ocdbConfig = "default,snapshot";
if (gSystem->Getenv("CONFIG_OCDB"))
ocdbConfig = gSystem->Getenv("CONFIG_OCDB");
if (stage != 0) {
//
gSystem->Setenv("CONFIG_RUN", gSystem->Getenv("ALIEN_JDL_LPMRUNNUMBER"));
// set OCDB
gROOT->LoadMacro("$ALIDPG_ROOT/MC/OCDBConfig.C");
OCDBDefault(1);
}
else if (ocdbConfig.Contains("alien") || ocdbConfig.Contains("cvmfs")) {
// set OCDB
gROOT->LoadMacro("$ALIDPG_ROOT/MC/OCDBConfig.C");
OCDBDefault(1);
}
else {
// set OCDB snapshot mode
AliCDBManager *cdbm = AliCDBManager::Instance();
cdbm->SetSnapshotMode("OCDBrec.root");
}
printf("------ Run QAtrainsim.C for collision type %s ------\n",CollisionSystem[iCollisionType]);
UpdateFlags();
TString cdbString(cdb);
if (cdbString.Contains("raw://") && !ocdbConfig.Contains("cvmfs")) {
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("QAtrain", "No grid connection");
return;
}
}
// gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_PHYSICS -I$ALICE_PHYSICS/include -I$ALICE_PHYSICS/PWGPP/TRD/macros");
// Set temporary merging directory to current one
gSystem->Setenv("TMPDIR", gSystem->pwd());
// Set temporary compilation directory to current one
gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
// Load libraries
// LoadLibraries();
printf("Include path: %s\n", gSystem->GetIncludePath());
// Create manager
AliAnalysisManager *mgr = new AliAnalysisManager("PilotAnalysis_sim", "Production train");
mgr->SetRunFromPath(run_number);
// Input handler
AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
esdHandler->SetReadFriends(kTRUE);
esdHandler->SetActiveBranches("ESDfriend");
mgr->SetInputEventHandler(esdHandler);
mgr->SetDebugLevel(debug_level);
// Monte Carlo handler
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetPreReadMode(1);
mcHandler->SetReadTR(kTRUE);
// subsidiary handler for mc-to-mc embedding
TString bgDir = gSystem->Getenv("CONFIG_BGEVDIR");
if (!bgDir.IsNull()) { // add extra handler for underlaying event
if (bgDir.BeginsWith("alien://") && !gGrid && !TGrid::Connect("alien://")) {
printf("Failed to create a grid connection\n");
abort();
}
if (!bgDir.EndsWith("/")) bgDir += "/";
AliMCEventHandler* mcHandlerBg = new AliMCEventHandler();
mcHandlerBg->SetInputPath(bgDir.Data());
mcHandlerBg->SetPreReadMode(1);
mcHandlerBg->SetReadTR(kTRUE);
mcHandler->AddSubsidiaryHandler(mcHandlerBg);
}
// AnalysisTasks
// mgr->Lock();
mgr->SetFileInfoLog("fileinfo.log");
AddAnalysisTasks(cdb);
// mgr->UnLock();
// mcHandler = (AliMCEventHandler*)mgr->GetMCtruthEventHandler();
// mcHandler->SetReadTR(kTRUE);
// mcHandler->SetPreReadMode(1);
if (stage>0) {
QAmerge(xmlfile, stage);
return;
}
// Input chain
TChain *chain = new TChain("esdTree");
chain->Add("AliESDs.root");
TStopwatch timer;
timer.Start();
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->SetSkipTerminate(kTRUE);
// mgr->SetNSysInfo(1);
mgr->StartAnalysis("local", chain);
}
timer.Print();
}
void runTask(Float_t etamax=0.5,const char * incollection = 0, const char * outfile = "dndeta.root", Bool_t skipNorm = kFALSE)
{
// for running with root only
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
// load analysis framework
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
TChain * chain = new TChain ("TE");
if (incollection == 0) {
chain->Add("galice.root");
}
else if (TString(incollection).Contains("xml")){
TGrid::Connect("alien://");
TAlienCollection * coll = TAlienCollection::Open (incollection);
while(coll->Next()){
chain->Add(TString("alien://")+coll->GetLFN());
}
} else {
ifstream file_collect(incollection);
TString line;
while (line.ReadLine(file_collect) ) {
chain->Add(line.Data());
}
}
chain->GetListOfFiles()->Print();
// for includes use either global setting in $HOME/.rootrc
// ACLiC.IncludePaths: -I$(ALICE_ROOT)/include
// or in each macro
gSystem->AddIncludePath("-I$ALICE_ROOT/include");
// Create the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("dNdeta");
AliVEventHandler* esdH = new AliESDInputHandler;
((AliESDInputHandler*)esdH)->SetReadFriends(kFALSE);
mgr->SetInputEventHandler(esdH);
// Create tasks
gROOT->LoadMacro("AliAnalysisTaskdNdetaMC.cxx++g");
AliAnalysisTask *task1 = new AliAnalysisTaskdNdetaMC("TaskdNdeta");
((AliAnalysisTaskdNdetaMC*)task1)->SetEtaMax(etamax);
if (skipNorm) ((AliAnalysisTaskdNdetaMC*)task1)->SkipNormalization();
// Enable MC event handler
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
// Add tasks
mgr->AddTask(task1);
// Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, outfile);
// Connect input/output
mgr->ConnectInput(task1, 0, cinput);
mgr->ConnectOutput(task1, 1, coutput1);
// Enable debug printouts
mgr->SetDebugLevel(0);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
void runLocalSim() {
TStopwatch timer;
timer.Start();
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gROOT->LoadMacro("AliAnalysisEt.cxx+g");
gROOT->LoadMacro("AliAnalysisEtReconstructed.cxx+g");
gROOT->LoadMacro("AliAnalysisEtMonteCarlo.cxx+g");
gROOT->LoadMacro("AliAnalysisEtReconstructedPhos.cxx+g");
gROOT->LoadMacro("AliAnalysisEtMonteCarloPhos.cxx+g");
gROOT->LoadMacro("AliAnalysisTaskTotEt.cxx+g");
//____________________________________________//
/*AliTagAnalysis *TagAna = new AliTagAnalysis("ESD");
TagAna->ChainLocalTags("../Tags");
AliRunTagCuts *runCuts = new AliRunTagCuts();
AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
AliEventTagCuts *evCuts = new AliEventTagCuts();
// evCuts->SetMultiplicityRange(11,12);
evCuts->SetNPHOSClustersRange(0,10000);
TChain* chain = 0x0;
chain = TagAna->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
*/// chain->SetBranchStatus("*Calo*",0);
TChain *chain = new TChain("esdTree");
//chain->Add("/media/wd/data/LHC10b/10000116134019.10/AliESDs.root");
// chain->Add("../ESDs/140012/001/AliESDs.root");
// chain->Add("../ESDs/140012/002/AliESDs.root");
// chain->Add("../ESDs/140012/003/AliESDs.root");
// chain->Add("../ESDs/140012/004/AliESDs.root");
// chain->Add("../ESDs/140012/005/AliESDs.root");
// chain->Add("../ESDs/140012/006/AliESDs.root");
// chain->Add("../ESDs/140012/007/AliESDs.root");
// chain->Add("../ESDs/140012/008/AliESDs.root");
// chain->Add("../ESDs/140012/009/AliESDs.root");
// chain->Add("../ESDs/140012/010/AliESDs.root");
// chain->Add("../ESDs/140012/011/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/088/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/081/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/065/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/050/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/010/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/013/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/025/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/021/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/072/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/011/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/092/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/043/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/002/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/008/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/059/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/107/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/017/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/085/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/103/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/091/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/034/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/084/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/071/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/079/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/087/AliESDs.root");
chain->Add("/media/wd/data/LHC10a/140009/067/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/028/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/068/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/051/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/020/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/102/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/066/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/063/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/047/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/105/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/040/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/053/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/083/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/069/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/016/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/006/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/039/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/077/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/100/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/003/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/052/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/009/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/026/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/062/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/095/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/070/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/106/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/027/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/054/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/073/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/022/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/044/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/012/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/056/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/031/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/086/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/023/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/075/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/093/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/005/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/035/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/057/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/019/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/042/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/046/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/048/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/024/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/018/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/014/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/064/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/032/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/104/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/029/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/082/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/108/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/074/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/041/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/058/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/089/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/080/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/101/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/055/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/098/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/096/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/038/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/1000/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/033/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/094/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/004/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/060/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/076/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/078/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/061/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/090/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/097/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140009/099/AliESDs.root");
//
// chain->Add("/media/wd/data/LHC10a/140010/081/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/065/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/050/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/010/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/013/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/025/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/021/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/072/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/011/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/092/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/043/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/002/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/001/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/015/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/008/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/059/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/017/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/045/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/103/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/091/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/034/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/084/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/071/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/079/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/087/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/067/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/028/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/068/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/051/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/020/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/102/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/066/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/063/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/047/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/105/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/040/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/053/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/083/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/069/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/016/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/006/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/039/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/077/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/100/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/036/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/003/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/052/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/007/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/009/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/026/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/062/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/030/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/095/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/070/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/027/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/054/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/073/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/022/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/044/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/012/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/056/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/031/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/086/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/023/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/075/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/093/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/005/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/035/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/057/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/019/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/042/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/046/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/048/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/024/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/018/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/014/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/064/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/032/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/104/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/029/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/082/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/058/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/089/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/080/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/101/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/055/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/098/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/096/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/038/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/1000/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/033/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/094/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/004/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/060/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/076/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/078/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/061/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/090/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/037/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/097/AliESDs.root");
// chain->Add("/media/wd/data/LHC10a/140010/099/AliESDs.root");
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("TotEtManager");
AliVEventHandler* esdH = new AliESDInputHandler;
mgr->SetInputEventHandler(esdH);
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
AliAnalysisTaskTotEt *task1 = new AliAnalysisTaskTotEt("TaskTotEt");
mgr->AddTask(task1);
// Create containers for input/output
//AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1", TChain::Class(),AliAnalysisManager::kInputContainer);
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("out1", TList::Class(), AliAnalysisManager::kOutputContainer,"Et.ESD.sim.root");
//____________________________________________//
mgr->ConnectInput(task1,0,cinput1);
mgr->ConnectOutput(task1,1,coutput1);
mgr->SetDebugLevel(1);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
mgr->StartAnalysis("local",chain);
timer.Stop();
timer.Print();
}
//________________________
/// Main execution method.
//________________________
void anaM()
{
// Main
//--------------------------------------------------------------------
// Load analysis libraries
// Look at the method below,
// change whatever you need for your analysis case
// ------------------------------------------------------------------
LoadLibraries() ;
//-------------------------------------------------------------------------------------------------
// Create chain from ESD and from cross sections files, look below for options.
//-------------------------------------------------------------------------------------------------
if(kInputData == "ESD") kTreeName = "esdTree" ;
else if(kInputData == "AOD") kTreeName = "aodTree" ;
else if (kInputData == "MC") kTreeName = "TE" ;
else {
cout<<"Wrong data type "<<kInputData<<endl;
break;
}
TChain * chain = new TChain(kTreeName) ;
CreateChain(mode, chain);//, chainxs);
cout<<"Chain created"<<endl;
if( chain )
{
AliLog::SetGlobalLogLevel(AliLog::kError);//Minimum prints on screen
//--------------------------------------
// Make the analysis manager
//-------------------------------------
AliAnalysisManager *mgr = new AliAnalysisManager("Manager", "Manager");
// MC handler
if( (kMC && (kInputData == "ESD")) || kInputData == "MC"){
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mcHandler->SetReadTR(kFALSE);//Do not search TrackRef file
mgr->SetMCtruthEventHandler(mcHandler);
if( kInputData == "MC") mgr->SetInputEventHandler(NULL);
}
// // AOD output handler
// AliAODHandler* aodoutHandler = new AliAODHandler();
// aodoutHandler->SetOutputFileName("AliAOD.root");
// mgr->SetOutputEventHandler(aodoutHandler);
//input
Int_t maxiterations = 1;
AliEventPoolLoop* pool = new AliEventPoolLoop(maxiterations);
pool->SetChain(chain);
Int_t eventsInPool = 10;
AliMultiEventInputHandler *inpHandler = NULL ;
if(kInputData == "ESD"){
// ESD handler
printf("ESD MultiInput \n");
inpHandler = new AliMultiEventInputHandler(eventsInPool, 0);
}
if(kInputData == "AOD"){
// AOD handler
inpHandler = new AliMultiEventInputHandler(eventsInPool, 1);
}
mgr->SetInputEventHandler(inpHandler);
cout<<"Input handler "<<mgr->GetInputEventHandler()<<endl;
mgr->SetEventPool(pool);
inpHandler->SetEventPool(pool);
//mgr->SetDebugLevel(-1); // For debugging, do not uncomment if you want no messages.
// select triigger events for physics run
// if(!kMC){
// gROOT->LoadMacro("AddTaskPhysicsSelection.C");
// AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
// mgr->AddTask(physSelTask);
// }
//-------------------------------------------------------------------------
//Define task, put here any other task that you want to use.
//-------------------------------------------------------------------------
//correlation analysis
gROOT->LoadMacro("AddTaskCaloTrackCorrM.C");
AliAnalysisTaskCaloTrackCorrelationM *taskEMCAL = AddTaskCaloTrackCorrM(kInputData,"EMCAL",kFALSE);
mgr->AddTask(taskEMCAL);
AliAnalysisTaskCaloTrackCorrelationM *taskPHOS = AddTaskCaloTrackCorrM(kInputData,"PHOS", kFALSE);
mgr->AddTask(taskPHOS);
//gROOT->LoadMacro("AddTaskChargeCorr.C");
AliAnalysisTaskCaloTrackCorrelationM *taskCharge = AddTaskCaloTrackCorrM(kInputData, "CTS",kFALSE);
// if(!kMC)
// taskCharge->SelectCollisionCandidates();
mgr->AddTask(taskCharge);
//-----------------------
// Run the analysis
//-----------------------
//mgr->ResetAnalysis();
mgr->InitAnalysis();
mgr->PrintStatus();
mgr->StartAnalysis("mix",chain);
cout <<" Analysis ended sucessfully "<< endl ;
}
else cout << "Chain was not produced ! "<<endl;
}
//_____________________________________________________________________________
void RunPerformanceTaskResEffMC(TChain *chain, Bool_t bUseMCInfo=kTRUE, Bool_t bUseESDfriend=kTRUE, Bool_t bProof=kTRUE)
{
if(!chain)
{
AliDebug(AliLog::kError, "ERROR: No input chain available");
return;
}
//
// Swtich off all AliInfo (too much output!)
//
AliLog::SetGlobalLogLevel(AliLog::kError);
//
// Create analysis manager
//
AliAnalysisManager *mgr = new AliAnalysisManager;
if(!mgr) {
Error("runTPCQA","AliAnalysisManager not set!");
return;
}
//
// Set ESD input handler
//
AliESDInputHandler* esdH = new AliESDInputHandler;
if(!esdH) {
Error("runTPCQA","AliESDInputHandler not created!");
return;
}
if(bUseESDfriend) esdH->SetActiveBranches("ESDfriend");
mgr->SetInputEventHandler(esdH);
//
// Set MC input handler
//
if(bUseMCInfo) {
AliMCEventHandler* mcH = new AliMCEventHandler;
if(!esdH) {
Error("runTPCQA","AliMCEventHandler not created!");
return;
}
mcH->SetReadTR(kTRUE);
mgr->SetMCtruthEventHandler(mcH);
}
//
// Create task
//
AliPerformanceTask *task = new AliPerformanceTask("Performance","TPC Performance");
if (!task) {
Error("AddTaskPerformanceTPC", "TPC performance task cannot be created!");
return NULL;
}
task->SetUseMCInfo(bUseMCInfo);
task->SetUseESDfriend(bUseESDfriend);
//
// Add task to analysis manager
//
mgr->AddTask(task);
//
// Create TPC-ESD track reconstruction cuts
// MB tracks
//
AliRecInfoCuts *pRecInfoCutsTPC = new AliRecInfoCuts("pRecInfoCutsTPC");
if(pRecInfoCutsTPC) {
pRecInfoCutsTPC->SetMaxDCAToVertexXY(3.0);
pRecInfoCutsTPC->SetMaxDCAToVertexZ(30.0);
//pRecInfoCutsTPC->SetMaxDCAToVertexZ(3.0);
pRecInfoCutsTPC->SetRequireSigmaToVertex(kFALSE);
pRecInfoCutsTPC->SetRequireTPCRefit(kFALSE);
pRecInfoCutsTPC->SetAcceptKinkDaughters(kTRUE);
pRecInfoCutsTPC->SetMinNClustersTPC(50);
pRecInfoCutsTPC->SetMaxChi2PerClusterTPC(1000000.);
pRecInfoCutsTPC->SetDCAToVertex2D(kFALSE);
pRecInfoCutsTPC->SetHistogramsOn(kFALSE);
}
else {
Error("AddTaskPerformanceTPC", "AliRecInfoCutsTPC cannot be created!");
return NULL;
}
//
// Create TPC-ESD track reconstruction cuts
// MATCH tracks
//
AliRecInfoCuts *pRecInfoCutsMATCH = new AliRecInfoCuts("pRecInfoCutsMATCH");
if(pRecInfoCutsMATCH) {
pRecInfoCutsMATCH->SetMaxDCAToVertexXY(3.0);
pRecInfoCutsMATCH->SetMaxDCAToVertexZ(3.0);
pRecInfoCutsMATCH->SetRequireSigmaToVertex(kFALSE);
pRecInfoCutsMATCH->SetRequireTPCRefit(kFALSE);
pRecInfoCutsMATCH->SetAcceptKinkDaughters(kTRUE);
pRecInfoCutsMATCH->SetMinNClustersTPC(50);
pRecInfoCutsMATCH->SetMaxChi2PerClusterTPC(1000000.);
pRecInfoCutsMATCH->SetDCAToVertex2D(kFALSE);
pRecInfoCutsMATCH->SetTPCITSMatchingRadius(70);
pRecInfoCutsMATCH->SetTPCTRDMatchingRadius(260);
pRecInfoCutsMATCH->SetMinNClustersITS(3);
pRecInfoCutsMATCH->SetHistogramsOn(kFALSE);
}
else {
Error("AddTaskPerformanceTPC", "AliRecInfoCutsTPC cannot be created!");
return NULL;
}
//
// Create TPC-ESD track reconstruction cuts
// standard cuts
AliRecInfoCuts *pRecInfoCuts = new AliRecInfoCuts("pRecInfoCuts");
if(pRecInfoCuts) {
pRecInfoCuts->SetMaxDCAToVertexXY(3.0);
pRecInfoCuts->SetMaxDCAToVertexZ(3.0);
pRecInfoCuts->SetMinNClustersTPC(50);
pRecInfoCuts->SetMinNClustersITS(2);
pRecInfoCuts->SetHistogramsOn(kFALSE);
pRecInfoCuts->SetTPCITSMatchingRadius(70);
pRecInfoCuts->SetTPCTRDMatchingRadius(260);
}
else {
Error("AddTaskPerformanceTPC", "AliRecInfoCuts cannot be created!");
return NULL;
}
//
// Create TPC-MC track reconstruction cuts
//
AliMCInfoCuts *pMCInfoCuts = new AliMCInfoCuts("pMCInfoCuts");
if(pMCInfoCuts) {
pMCInfoCuts->SetMinTrackLength(70);
}
else {
Error("AddTaskPerformanceTPC", "AliMCInfoCuts cannot be created!");
return NULL;
}
//
// Create performance objects for TPC and set cuts
//
enum { kTPC = 0, kTPCITS, kConstrained, kTPCInner, kTPCOuter, kTPCSec };
//
// Resolution
//
AliPerformanceRes *pCompRes0 = new AliPerformanceRes("AliPerformanceRes","AliPerformanceRes",kTPC,kFALSE);
if(!pCompRes0) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceRes");
}
pCompRes0->SetAliRecInfoCuts(pRecInfoCuts);
pCompRes0->SetAliMCInfoCuts(pMCInfoCuts);
AliPerformanceRes *pCompRes3 = new AliPerformanceRes("AliPerformanceResTPCInner","AliPerformanceResTPCInner",kTPCInner,kFALSE);
if(!pCompRes3) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceResTPCInner");
}
pCompRes3->SetAliRecInfoCuts(pRecInfoCuts);
pCompRes3->SetAliMCInfoCuts(pMCInfoCuts);
AliPerformanceRes *pCompRes4 = new AliPerformanceRes("AliPerformanceResTPCOuter","AliPerformanceResTPCOuter",kTPCOuter,kFALSE);
if(!pCompRes4) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceResTPCOuter");
}
pCompRes4->SetAliRecInfoCuts(pRecInfoCuts);
pCompRes4->SetAliMCInfoCuts(pMCInfoCuts);
//
// Efficiency
//
AliPerformanceEff *pCompEff0 = new AliPerformanceEff("AliPerformanceEff","AliPerformanceEff",kTPC,kFALSE);
if(!pCompEff0) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceEff");
}
pCompEff0->SetAliRecInfoCuts(pRecInfoCuts);
pCompEff0->SetAliMCInfoCuts(pMCInfoCuts);
//
// dEdx
//
AliPerformanceDEdx *pCompDEdx3 = new AliPerformanceDEdx("AliPerformanceDEdxTPCInner","AliPerformanceDEdxTPCInner",kTPCInner,kFALSE);
if(!pCompDEdx3) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceDEdxTPCInner");
}
pCompDEdx3->SetAliRecInfoCuts(pRecInfoCuts);
pCompDEdx3->SetAliMCInfoCuts(pMCInfoCuts);
//
// DCA
//
AliPerformanceDCA *pCompDCA0 = new AliPerformanceDCA("AliPerformanceDCA","AliPerformanceDCA",kTPC,kFALSE);
if(!pCompDCA0) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceDCA");
}
pCompDCA0->SetAliRecInfoCuts(pRecInfoCuts);
pCompDCA0->SetAliMCInfoCuts(pMCInfoCuts);
//
// TPC performance
//
AliPerformanceTPC *pCompTPC0 = new AliPerformanceTPC("AliPerformanceTPC","AliPerformanceTPC",kTPC,kFALSE);
if(!pCompTPC0) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceTPC");
}
pCompTPC0->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompTPC0->SetAliMCInfoCuts(pMCInfoCuts);
//
// TPC+ITS matching performance
//
AliPerformanceMatch *pCompMatch0 = new AliPerformanceMatch("AliPerformanceMatchTPCITS","AliPerformanceMatchTPCITS",0,kFALSE);
if(!pCompMatch0) {
Error("AddTaskPerformanceMatch", "Cannot create AliPerformanceMatchTPCITS");
}
pCompMatch0->SetAliRecInfoCuts(pRecInfoCutsMATCH);
pCompMatch0->SetAliMCInfoCuts(pMCInfoCuts);
//
// TPC+TRD matching performance
//
AliPerformanceMatch *pCompMatch1 = new AliPerformanceMatch("AliPerformanceMatchTPCTRD","AliPerformanceMatchTPCTRD",1,kFALSE);
if(!pCompMatch1) {
Error("AddTaskPerformanceMatch", "Cannot create AliPerformanceMatchTPCTRD");
}
pCompMatch1->SetAliRecInfoCuts(pRecInfoCutsMATCH);
pCompMatch1->SetAliMCInfoCuts(pMCInfoCuts);
AliPerformanceMatch *pCompMatch2 = new AliPerformanceMatch("AliPerformanceMatchTPCEFF","AliPerformanceMatchTPCEFF",2,kFALSE);
if(!pCompMatch2) {
Error("AddTaskPerformanceMatch", "Cannot create AliPerformanceMatchTPCEFF");
}
pCompMatch2->SetAliRecInfoCuts(pRecInfoCutsMATCH);
pCompMatch2->SetAliMCInfoCuts(pMCInfoCuts);
//
// Add components to the performance task
//
//task->AddPerformanceObject( pCompDEdx3 );
//task->AddPerformanceObject( pCompDCA0 );
//task->AddPerformanceObject( pCompTPC0 );
//task->AddPerformanceObject( pCompMatch0 );
//task->AddPerformanceObject( pCompMatch1 );
//task->AddPerformanceObject( pCompMatch2 );
//
if(bUseMCInfo) {
task->AddPerformanceObject( pCompRes0 );
//task->AddPerformanceObject( pCompRes3 );
//task->AddPerformanceObject( pCompRes4 );
task->AddPerformanceObject( pCompEff0 );
}
//
if(!bUseMCInfo) {
pCompDEdx3->SetTriggerClass(triggerClass);
pCompDCA0->SetTriggerClass(triggerClass);
pCompTPC0->SetTriggerClass(triggerClass);
pCompMatch0->SetTriggerClass(triggerClass);
pCompMatch1->SetTriggerClass(triggerClass);
pCompMatch2->SetTriggerClass(triggerClass);
}
//
// Create containers for input
//
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
//
// Create containers for output
//
AliAnalysisDataContainer *coutput_tpc = mgr->CreateContainer("TPCMC", TList::Class(), AliAnalysisManager::kOutputContainer, Form("TPC.MC.%s.root", task->GetName()));
mgr->ConnectOutput(task, 1, coutput_tpc);
// Enable debug printouts
mgr->SetDebugLevel(0);
if (!mgr->InitAnalysis())
return;
mgr->PrintStatus();
if(bProof) mgr->StartAnalysis("proof",chain);
else mgr->StartAnalysis("local",chain);
}
//______________________________________________________________________________
void AODtrainsim(Int_t merge=0)
{
// Main analysis train macro.
// merge = 0: production
// merge = 1: intermediate merging
// merge = 2: final merging + terminate
// merge = 3: terminate only
if (merge) {
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("AODtrainsim.C", "No grid connection");
return;
}
}
// Set temporary merging directory to current one
gSystem->Setenv("TMPDIR", gSystem->pwd());
// Set temporary compilation directory to current one
gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
printf("==================================================================\n");
printf("=========== RUNNING FILTERING TRAIN ==========\n");
printf("==================================================================\n");
printf("= Configuring analysis train for: =\n");
if (usePhysicsSelection) printf("= Physics selection =\n");
if (iESDfilter) printf("= ESD filter =\n");
if (iMUONcopyAOD) printf("= MUON copy AOD =\n");
// Load common libraries and set include path
gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_PHYSICS/include");
// Make the analysis manager and connect event handlers
AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train");
if (useSysInfo) mgr->SetNSysInfo(100);
// Load ParFiles
if (!LoadAnalysisLibraries()) {
::Error("AODtrainsim.C", "Could not load analysis libraries");
return;
}
// Create input handler (input container created automatically)
// ESD input handler
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
// Monte Carlo handler
if (useMC) {
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetReadTR(useTR);
}
// AOD output container, created automatically when setting an AOD handler
if (iAODhandler) {
// AOD output handler
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName("AliAOD.root");
mgr->SetOutputEventHandler(aodHandler);
}
// Debugging if needed
if (useDBG) mgr->SetDebugLevel(3);
AddAnalysisTasks(merge);
if (merge) {
if (merge < 3) AODmerge();
if (merge > 1) {
mgr->InitAnalysis();
mgr->SetGridHandler(new AliAnalysisAlien());
mgr->StartAnalysis("grid terminate",0);
}
return;
}
// Run the analysis
//
TChain *chain = CreateChain();
if (!chain) return;
TStopwatch timer;
timer.Start();
mgr->SetSkipTerminate(kTRUE);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
timer.Print();
}
AliAnalysisTaskOmegaOmegaOX *AddTaskOmegaOmegaOX(TString finname="",
Bool_t readMC=kFALSE,
Bool_t additionalChecks=kFALSE,
TString suffix = ""){
//------------------------------------------------------------------------------------------
// version 2.10 (2016/02/11)
//------------------------------------------------------------------------------------------
Bool_t stdcuts=kFALSE;
TFile* filecuts;
if( finname.EqualTo("") ) {
stdcuts=kTRUE;
} else {
filecuts=TFile::Open(finname.Data());
if(!filecuts ||(filecuts&& !filecuts->IsOpen())){
AliFatal("Input file not found : check your cut object");
}
}
// Creates, configures and attaches to the train the task for pi, K , p spectra
// with ITS standalone tracks
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
::Info("AddTaskOmegaOmegaOX","Adding a new task with this settings readMC = %i",readMC);
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskOmegaOmegaOX", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskOmegaOmegaOX", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
if(type.Contains("AOD")){
::Error("AddTaskOmegaOmegaOX", "This task requires to run on ESD");
return NULL;
}
// Add MC handler (for kinematics)
if(readMC){
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(handler);
}
// Create and configure the task
TString taskname = "OmegaOmegaOX";
TString combinedName;
combinedName.Form("OmegaOmegaOX%s", suffix.Data());
AliAnalysisTaskOmegaOmegaOX *task = new AliAnalysisTaskOmegaOmegaOX(combinedName);
task->SetMC(readMC);
mgr->AddTask(task);
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
TString outputFileName = AliAnalysisManager::GetCommonFileName();
outputFileName += ":Dibaryon";
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(Form("CutPar_%s",combinedName.Data()), TTree::Class(),AliAnalysisManager::kOutputContainer,outputFileName.Data());
mgr->ConnectOutput(task, 1, coutput1);
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(Form("Vertex_%s",combinedName.Data()), TTree::Class(),AliAnalysisManager::kOutputContainer,outputFileName.Data());
// coutput2->SetSpecialOutput();
mgr->ConnectOutput(task, 2, coutput2);
return task;
}
//________________________________________________________________
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 runTaskFlowHigherOrdersAllPID(
const char* runtype = "local", // local, proof or grid
const char *gridmode = "terminate", // Set the run mode (can be "full", "test", "offline", "submit" or "terminate"). Full & Test work for proof
const Int_t bunchN = 0,
const bool bAOD = 1, // 1 = AOD ANALYSIS, 0 = ESD ANALYSIS
const bool bMCtruth = 0, // 1 = MCEvent handler is on (MC truth), 0 = MCEvent handler is off (MC reconstructed/real data)
const bool bMCphyssel = 1, // 1 = looking at MC truth or reconstructed, 0 = looking at real data
const Long64_t nentries = 50000, // for local and proof mode, ignored in grid mode. Set to 1234567890 for all events.
const Long64_t firstentry = 0, // for local and proof mode, ignored in grid mode
TString proofdataset = "bunchPROOF", // path to dataset on proof cluster, for proof analysis
const char *proofcluster = "*****@*****.**", // which proof cluster to use in proof mode
const char *taskname = "BF_Syst_Test" // sets name of grid generated macros
)
{
// check run type
if(runtype != "local" && runtype != "proof" && runtype != "grid") {
Printf("\n\tIncorrect run option, check first argument of run macro");
Printf("\tint runtype = local, proof or grid\n");
return;
}
Printf("%s analysis chosen",runtype);
// load libraries
gSystem->Load("libCore");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
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("libPWGTools");
gSystem->Load("libPWGCFebye");
gSystem->Load("libPWGflowBase");
gSystem->Load("libPWGflowTasks");
// additional
// compile standalone stuff
//gROOT->LoadMacro("AliBalance.cxx++g");
//gROOT->LoadMacro("AliAnalysisTaskBF.cxx++g");
// add aliroot indlude path
//gROOT->ProcessLine(".include $PWD/.");
//gROOT->ProcessLine(Form(".include %s/include",gSystem->ExpandPathName("$ALICE_ROOT")));
gROOT->SetStyle("Plain");
// analysis manager
AliAnalysisManager* mgr = new AliAnalysisManager(Form("%s%i",taskname,bunchN));
// create the alien handler and attach it to the manager
if(runtype == "grid") {
AliAnalysisGrid *plugin = CreateAlienHandler(bAOD,bunchN,Form("%s%i",taskname,bunchN), gridmode, proofcluster, Form("%s_%d.txt",proofdataset.Data(),bunchN));
mgr->SetGridHandler(plugin);
}
else if(runtype == "local") {
TString filename;
TChain* chain = 0x0;
if((!bAOD)&&(!bMCtruth)) {
chain = new TChain("esdTree");
for(Int_t i = 0; i < 4; i++) {
filename = "/data/alice2/pchrist/HeavyIons/Data/2011/Set";
filename += i; filename += "/AliESDs.root";
chain->Add(filename.Data());
}
}
else if((bAOD)&&(!bMCtruth)) {
chain = new TChain("aodTree");
for(Int_t i = 0; i < 10; i++) {
filename = "/glusterfs/alice1/alice2/pchrist/HeavyIons/Data/2011/Set";
filename += i; filename += "/AliAOD.root";
chain->Add(filename.Data());
}
}
else if((!bAOD)&&(bMCtruth)) {
chain = new TChain("TE");
for(Int_t i = 10; i < 99; i++) {
filename = "/project/alice/users/alisrm/Efficiency_Contamination/LHC13b3_HIJING_pA_AOD/";
filename += i;
filename += "/galice.root";
chain->Add(filename.Data());
}
}
else if((bAOD)&&(bMCtruth)) { //used for MCAOD
chain = new TChain("aodTree");
for(Int_t i = 10; i < 99; i++) {
filename = "/project/alice/users/alisrm/Efficiency_Contamination/LHC13b3_HIJING_pA_AOD/";
filename += i;
filename += "/AliAOD.root";
chain->Add(filename.Data());
}
}
}//local mode
// input handler (ESD or AOD)
AliVEventHandler* inputH = NULL;
if(!bAOD){
inputH = new AliESDInputHandler();
}
else{
inputH = new AliAODInputHandler();
}
mgr->SetInputEventHandler(inputH);
// mc event handler
if(bMCtruth) {
AliMCEventHandler* mchandler = new AliMCEventHandler();
// Not reading track references
mchandler->SetReadTR(kFALSE);
mgr->SetMCtruthEventHandler(mchandler);
}
// AOD output handler
//AliAODHandler* aodoutHandler = new AliAODHandler();
//aodoutHandler->SetOutputFileName("aod.root");
//mgr->SetOutputEventHandler(aodoutHandler);
// === Physics Selection Task ===
//
// In SelectCollisionCandidate(), default is kMB, so the task UserExec()
// function is only called for these events.
// Options are:
// kMB Minimum Bias trigger
// kMBNoTRD Minimum bias trigger where the TRD is not read out
// kMUON Muon trigger
// kHighMult High-Multiplicity Trigger
// kUserDefined For manually defined trigger selection
//
// Multiple options possible with the standard AND/OR operators && and ||
// These all have the usual offline SPD or V0 selections performed.
//
// With a pointer to the physics selection object using physSelTask->GetPhysicsSelection(),
// one can manually set the selected and background classes using:
// AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL")
// AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL");
//
// One can also specify multiple classes at once, or require a class to NOT
// trigger, for e.g.
// AddBGTriggerClass("+CSMBA-ABCE-NOPF-ALL -CSMBB-ABCE-NOPF-ALL");
//
// NOTE that manually setting the physics selection overrides the standard
// selection, so it must be done in completeness.
//
// ALTERNATIVELY, one can make the physics selection inside the task
// UserExec().
// For this case, comment out the task->SelectCol.... line,
// and see AliBasicTask.cxx UserExec() function for details on this.
//gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
//AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(bMCphyssel);
//if(!physSelTask) { Printf("no physSelTask"); return; }
//AliPhysicsSelection *physSel = physSelTask->GetPhysicsSelection();
//physSel->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL");// #3119 #769");
// create task
//Add the centrality determination task and the physics selection
// (only on ESD level, in AODs centrality is already in header and events are selected)
// if((!bAOD)&&(!bMCtruth)){
// gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
// AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
// Add physics selection task (NOT needed for AODs)
// gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
// AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(bMCphyssel);
// }
/////////////////////////////////////////
//Add flow centrality bayesian
gROOT->LoadMacro("AddTaskFlowHigherOrdersAllPID.C");
//gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/AddTaskFlowHigherOrdersAllPID.C");
// gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/AddTaskFlowCentralityBayesian.C");
// gROOT->LoadMacro("~/Desktop/work/PhD/flow/AddTaskFlowCentralityBayesian.C");
AliAnalysisTaskFlowEvent* FlowTask = AddTaskFlowHigherOrdersAllPID(AliVEvent::kCentral | AliVEvent::kSemiCentral | AliVEvent::kMB,0.,80.,"AnalysisResults",kTRUE,768,768,AliPID::kPion,AliFlowTrackCuts::kTOFbayesian,0,kFALSE,-0.8,0.8,"");
/////////////////////////////////////////
//Add the PID response
// if((kUsePID)||(kNSigmaElectronRejection)) {
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
// AddTaskPIDResponse(bMCphyssel);
// }
//Add the VZERO event plane task
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
// AliVZEROEPSelectionTask* epSelTask = AddTaskVZEROEPSelection();
//Add the BF task (all centralities)
// gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/EBYE/macros/AddTaskBalancePsiCentralityTrain.C");
// AliAnalysisTaskBFPsi *taskBF = AddTaskBalancePsiCentralityTrain(0, 500, kFALSE, kTRUE, kFALSE, "V0M", 10, -1, -1, 0.2, 20.0, -0.8, 0.8, -1, -1, kUsePID, kFALSE, kTRUE, 0.02, kFALSE, 0.04, kTRUE, 0.1, 128, 1, "AnalysisResults","TE","Multiplicity","AOD",kTRUE, kNSigmaElectronRejection);
//taskBF->SetDebugLevel();
// enable debug printouts
//mgr->SetDebugLevel(2);
//mgr->SetUseProgressBar(1,100);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
// start analysis
Printf("Starting Analysis....");
if(runtype == "local")
mgr->StartAnalysis("local",chain);
else
mgr->StartAnalysis(runtype,nentries,firstentry);
}
