/**
* 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;
}
void run(Char_t* data, Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 0, Bool_t isMC = 0,
Int_t centrBin = 0, const char * centrEstimator = "VOM", Int_t useOtherCentralityCut = 0, Int_t trackMin=0, Int_t trackMax=10000,
const char* option = "",TString customSuffix = "", Int_t workers = -1, Bool_t useSingleBin=kTRUE, const char * runList = 0)
{
// runMode:
//
// 0 local
// 1 proof
if (nev < 0)
nev = 1234567890;
InitAndLoadLibs(runMode,workers,debug);
// Create the analysis manager
mgr = new AliAnalysisManager;
// Add ESD handler
AliESDInputHandler* esdH = new AliESDInputHandler;
// Do I need any of this?
esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks");
mgr->SetInputEventHandler(esdH);
if(isMC) {
AliMCEventHandler* handler = new AliMCEventHandler;
handler->SetPreReadMode(AliMCEventHandler::kLmPreRead);
mgr->SetMCtruthEventHandler(handler);
}
// Parse option strings
TString optionStr(option);
// remove SAVE option if set
// This is copied from a macro by Jan. The reason I kept it is that I may want to pass textual options to the new task at some point
Bool_t doSave = kFALSE;
TString optionStr(option);
if (optionStr.Contains("SAVE"))
{
optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
doSave = kTRUE;
}
AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE);
TString pathsuffix = "";
if(!useSingleBin) pathsuffix += "_AllCentr";
if (optionStr.Contains("DCA")) {
delete cuts;
// cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
cout << ">>>> USING DCA cut" << endl;
cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
cuts->SetMaxChi2TPCConstrainedGlobal(); // remove golden cut
pathsuffix+="_DCAcut";
}
if (optionStr.Contains("ITSsa")) {
delete cuts;
cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009();
cout << ">>>> USING ITS sa tracks" << endl;
pathsuffix+="_ITSsa";
}
if (optionStr.Contains("TPC")) {
delete cuts;
cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
cout << ">>>> USING TPC only tracks" << endl;
pathsuffix+="_TPC";
}
if(optionStr.Contains("NoElectrons")) pathsuffix +="_NoElectrons";
Bool_t useMCKinematics = isMC;
if (optionStr.Contains("NOMCKIN")) {
cout << ">>>> Ignoring MC kinematics" << endl;
useMCKinematics=kFALSE;
pathsuffix+="_NOMCKIN";
}
// If we are running on grid, we need the alien handler
if (runMode == kMyRunModeGRID) {
// Create and configure the alien handler plugin
gROOT->LoadMacro("CreateAlienHandler.C");
AliAnalysisGrid *alienHandler = CreateAlienHandler(data, runList, pathsuffix.Data(), listToLoad, "full", isMC); // full
if (!alienHandler) {
cout << "Cannot create alien handler" << endl;
exit(1);
}
mgr->SetGridHandler(alienHandler);
}
// Add tasks
// physics selection
gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
physicsSelectionTask = AddTaskPhysicsSelection(isMC);
//PID
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AddTaskPIDResponse(isMC);
// // PID QA:
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
// AddTaskPIDqa();
// Centrality
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentr = AddTaskCentrality();
// OBSOLETE
const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root";
const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root";
// END of OBSOLETE
if(isMC) taskCentr-> SetMCInput();
taskCentr->SetPass(2);
// Create my own centrality selector
AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector();
centrSelector->SetIsMC(isMC);
centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only
centrSelector->SetCentralityBin(centrBin);
if (!useSingleBin) centrSelector->SetCentralityBin(0); // FIXME: ok?
centrSelector->SetCentralityEstimator(centrEstimator);
if(useOtherCentralityCut == 1){
cout << "Setting centrality by MULT" << endl;
centrSelector->SetUseMultRange();
centrSelector->SetMultRange(trackMin,trackMax);
}
if(useOtherCentralityCut == 2){
cout << "Setting centrality by V0" << endl;
centrSelector->SetUseV0Range();
centrSelector->SetMultRange(trackMin,trackMax);
}
if(useOtherCentralityCut == 3){
cout << "Setting centrality by SPD outer" << endl;
centrSelector->SetUseSPDOuterRange();
centrSelector->SetMultRange(trackMin,trackMax);
}
// load my task
if (useSingleBin) {
gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C");
AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector);
task->SetIsMC(useMCKinematics);
task->SetOfflineTrigger(AliVEvent::kMB);
if(optionStr.Contains("TPC")) task->SetTPCOnly();
if(optionStr.Contains("NoElectrons")) task->RejectElectrons(kTRUE);
if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC");
if(customSuffix!=""){
cout << "Setting custom suffix: " << customSuffix << endl;
task->GetHistoManager()->SetSuffix(customSuffix);
}
} else {
gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracksAllCentrality.C");
centrSelector->SetUseV0Range(kTRUE);
Int_t ncentr = 11;
const Float_t minCentr[] = {0 ,79 ,239,559 ,1165,2135,3555,5525,8213 ,12191,15079};
const Float_t maxCentr[] = {79,239,559,1165,2135,3555,5525,8213,12191,15079,21000};
AliAnalysisTaskMultPbTracks ** tasks = AddTaskMultPbPbTracksAllCentrality("multPbPbtracks.root", cuts, centrSelector, ncentr,minCentr,maxCentr);
for(Int_t icentr = 0; icentr < ncentr; icentr++){
tasks[icentr]->Print();
cout << "MC KINEMATICS:" << useMCKinematics << endl;
tasks[icentr]->SetIsMC(useMCKinematics);
tasks[icentr]->SetOfflineTrigger(AliVEvent::kMB);
if(optionStr.Contains("TPC")) tasks[icentr]->SetTPCOnly();
if(optionStr.Contains("NoElectrons")) task[icentr]->RejectElectrons(kTRUE);
if(useMCKinematics) tasks[icentr]->GetHistoManager()->SetSuffix("MC");
if(customSuffix!=""){
cout << "Setting custom suffix: " << customSuffix+long(icentr) << endl;
tasks[icentr]->GetHistoManager()->SetSuffix(customSuffix+long(icentr));
}
}
}
// Init and run the analy
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
if (runMode == kMyRunModeLocal ) {
// If running in local mode, create chain of ESD files
cout << "RUNNING LOCAL, CHAIN" << endl;
TChain * chain = GetAnalysisChain(data);
chain->Print();
mgr->StartAnalysis("local",chain,nev);
} else if (runMode == kMyRunModeProofLite) {
TChain * chain = GetAnalysisChain(data);
mgr->StartAnalysis("proof",chain,nev);
}
else if (runMode == kMyRunModeCAF) {
mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev);
} else if (runMode == kMyRunModeGRID) {
mgr->StartAnalysis("grid");
} else {
cout << "ERROR: unknown run mode" << endl;
}
if (!useOtherCentralityCut) {
pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin);
} else if(useOtherCentralityCut==1){
pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax);
} else if(useOtherCentralityCut==2){
pathsuffix = pathsuffix + "_V0Range_" + long(trackMin) + "_" + long(trackMax);
} else if(useOtherCentralityCut==3){
pathsuffix = pathsuffix + "_SPDOutRange_" + long(trackMin) + "_" + long(trackMax);
}
pathsuffix += customSuffix;
if (doSave) MoveOutput(data, pathsuffix.Data());
}
//______________________________________________________________________________
void 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();
}