Bool_t InputHandlerSetup(TString format = "esd", Bool_t useKine = kTRUE)
{
format.ToLower();
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
IlcAnalysisDataContainer *cin = mgr->GetCommonInputContainer();
if (cin) return;
if (!format.CompareTo("esd"))
{
IlcESDInputHandler *esdInputHandler =
dynamic_cast<IlcESDInputHandler*>(IlcAnalysisManager::GetAnalysisManager()->
GetInputEventHandler());
if (!esdInputHandler)
{
Info("CustomAnalysisTaskInputSetup", "Creating esdInputHandler ...");
esdInputHandler = new IlcESDInputHandler();
mgr->SetInputEventHandler(esdInputHandler);
}
if (useKine)
{
IlcMCEventHandler* mcInputHandler =
dynamic_cast<IlcMCEventHandler*>(IlcAnalysisManager::GetAnalysisManager()->
GetMCtruthEventHandler());
if (!mcInputHandler)
{
Info("CustomAnalysisTaskInputSetup", "Creating mcInputHandler ...");
IlcMCEventHandler* mcInputHandler = new IlcMCEventHandler();
mgr->SetMCtruthEventHandler(mcInputHandler);
}
}
}
else if (!format.CompareTo("aod"))
{
IlcAODInputHandler *aodInputHandler =
dynamic_cast<IlcAODInputHandler*>(IlcAnalysisManager::GetAnalysisManager()->
GetInputEventHandler());
if (!aodInputHandler)
{
Info("CustomAnalysisTaskInputSetup", "Creating aodInputHandler ...");
aodInputHandler = new IlcAODInputHandler();
mgr->SetInputEventHandler(aodInputHandler);
}
}
else
{
IlcWarning("Wrong input format!!! Only ESD and AOD are supported. Skipping Task ...");
return kFALSE;
}
return kTRUE;
}
void SetupAnalysis(TString mode,
TString analysisMode="full",
Bool_t useMC = kFALSE,
Int_t nEvents=1.0*1e9,
Int_t nEventsSkip=0,
TString format="esd")
{
// ILC stuff
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
if (!mgr) mgr = new IlcAnalysisManager("CAF train");
// Create and configure the alien handler plugin
gROOT->LoadMacro("CreateAnalysisPlugin.C");
IlcAnalysisGrid *alienHandler = CreateAnalysisPlugin(analysisMode);
if (!alienHandler) return;
mgr->SetGridHandler(alienHandler);
// input handler for esd or AOD, real or MC data
InputHandlerSetup(format,useMC);
// physics selection
if(!format.CompareTo("esd")){
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
IlcPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE);
if(useMC) physSelTask->GetPhysicsSelection()->SetAnalyzeMC();
IlcPhysicsSelection* physSel = physSelTask->GetPhysicsSelection();
physSel->AddBackgroundIdentification(new IlcBackgroundSelection());
}
gROOT->ProcessLine(Form(".include %s/include",gSystem->ExpandPathName("$ILC_ROOT")));
gROOT->LoadMacro("IlcAnalysisTaskEfficiency.cxx+g");
// load and run AddTask macro
gROOT->LoadMacro("AddTaskEfficiency.C");
IlcAnalysisTaskSE* task1 = AddTaskEfficiency(-1);
if(!task1){
Printf("AddTask could not be run.");
}
// Run analysis
mgr->InitAnalysis();
if ((!mode.CompareTo("proof")) ||(!mode.CompareTo("local"))) {
mgr->StartAnalysis(mode.Data(),nEvents,nEventsSkip);
}
else {
mgr->StartAnalysis(mode.Data());
}
}
IlcAnalysisTask* AddTaskBaseLine()
{
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskPhysicsSelection", "No analysis manager to connect to.");
return NULL;
}
IlcAnalysisTask *task = new IlcAnalysisTaskBaseLine("baseline");
mgr->AddTask(task);
return task;
}
IlcCentralitySelectionTask *AddTaskCentrality(Bool_t fillHistos=kTRUE)
{
// Macro to connect a centrality selection task to an existing analysis manager.
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskCentrality", "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("AddTaskCentrality", "This task requires an input event handler");
return NULL;
}
TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
if (inputDataType != "ESD") {
::Error("AddTaskCentrality", "This task works only on ESD analysis");
return NULL;
}
IlcCentralitySelectionTask *centralityTask = new IlcCentralitySelectionTask("CentralitySelection");
centralityTask->SelectCollisionCandidates(IlcVEvent::kAny);
mgr->AddTask(centralityTask);
mgr->ConnectInput(centralityTask, 0, mgr->GetCommonInputContainer());
if (fillHistos) {
centralityTask->SetFillHistos();
IlcAnalysisDataContainer *coutput1 = mgr->CreateContainer("CentralityStat",
TList::Class(),
IlcAnalysisManager::kOutputContainer,
"EventStat_temp.root");
mgr->ConnectOutput(centralityTask,1,coutput1);
}
return centralityTask;
}
IlcMCEventHandler* AddMCHandler(Bool_t readTrackRef = kFALSE)
{
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddMCHandler", "No analysis manager to connect to.");
return NULL;
}
IlcMCEventHandler* handler = new IlcMCEventHandler();
mgr->SetMCtruthEventHandler(handler);
handler->SetReadTR(readTrackRef);
return handler;
}
void QAtrain(Int_t run = 0,
const char *xmlfile = "wn.xml",
Int_t stage = 0) /*0 = QA train, 1...n - merging stage*/
{
run_number = run;
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("QAtrain", "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);
// Load libraries
LoadLibraries();
printf("Include path: %s\n", gSystem->GetIncludePath());
// Create manager
IlcAnalysisManager *mgr = new IlcAnalysisManager("PilotAnalysis_sim", "Production train");
mgr->SetRunFromPath(run_number);
// Input handler
IlcESDInputHandlerRP *esdHandler = new IlcESDInputHandlerRP();
esdHandler->SetReadFriends(kTRUE);
esdHandler->SetActiveBranches("ESDfriend");
mgr->SetInputEventHandler(esdHandler);
mgr->SetDebugLevel(debug_level);
// Monte Carlo handler
IlcMCEventHandler* mcHandler = new IlcMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetPreReadMode(1);
mcHandler->SetReadTR(kTRUE);
// AnalysisTasks
AddAnalysisTasks();
if (stage>0) {
QAmerge(xmlfile, stage);
return;
}
// Input chain
TChain *chain = new TChain("esdTree");
chain->Add("IlcESDs.root");
TStopwatch timer;
timer.Start();
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->SetSkipTerminate(kTRUE);
// mgr->SetNSysInfo(1);
mgr->StartAnalysis("local", chain);
}
timer.Print();
}
IlcAODHandler* AddAODOutputHandler()
{
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddAODOutputHandler", "No analysis manager to connect to.");
return NULL;
}
IlcAODHandler* handler = new IlcAODHandler();
handler->SetOutputFileName("IlcAOD.root");
mgr->SetOutputEventHandler(handler);
IlcAnalysisDataContainer* cout_aod = mgr->GetCommonOutputContainer();
cout_aod->SetSpecialOutput();
return handler;
}
void QAmerge(const char *suffix, const char *dir, Int_t stage)
{
// Merging method
TStopwatch timer;
timer.Start();
TString outputDir = dir;
TString outputFiles = Form("QAresults%s.root,EventStat_temp%s.root,RecoQAresults%s.root",suffix,suffix,suffix);
TString mergeExcludes = "";
TObjArray *list = outputFiles.Tokenize(",");
TIter *iter = new TIter(list);
TObjString *str;
TString outputFile;
Bool_t merged = kTRUE;
while((str=(TObjString*)iter->Next())) {
outputFile = str->GetString();
// Skip already merged outputs
if (!gSystem->AccessPathName(outputFile)) {
printf("Output file <%s> found. Not merging again.",outputFile.Data());
continue;
}
if (mergeExcludes.Contains(outputFile.Data())) continue;
merged = IlcAnalysisAlien::MergeOutput(outputFile, outputDir, 10, stage);
if (!merged && !outputFile.Contains("RecoQAresults")) {
printf("ERROR: Cannot merge %s\n", outputFile.Data());
return;
}
}
// read the analysis manager from file
if (!outputDir.Contains("Stage")) {
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
return;
}
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
mgr->SetRunFromPath(mgr->GetRunFromAlienPath(dir));
mgr->SetSkipTerminate(kFALSE);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
IlcLog::SetGlobalLogLevel(IlcLog::kError);
TTree *tree = NULL;
mgr->StartAnalysis("gridterminate", tree);
if (strlen(suffix)) {
if (gSystem->Exec(Form("mv trending.root trending%s.root", suffix)))
::Error("QAmerge", "File trending.root was not produced");
if (gSystem->Exec(Form("mv event_stat.root event_stat%s.root", suffix)))
::Error("QAmerge", "File trending.root was not produced");
}
ofstream out;
out.open("outputs_valid", ios::out);
out.close();
timer.Print();
}
void DphiAnalysis()
{
gSystem->Load("libTree.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libGeom.so");
gSystem->Load("libVMC.so");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libSTEERBase.so");
gSystem->Load("libAOD.so");
gSystem->Load("libESD.so");
gSystem->Load("libANALYSISilc.so");
//
if (gApplication) gApplication->InitializeGraphics();
// Create the chain
//
//TString path("/afs/cern.ch/user/m/morsch/public/");
TString path("./");
TChain* chain = new TChain("aodTree");
chain->Add(Form("%s/%s",path.Data(),"IlcAOD.root"));
///////////////////////////////////////////////////////////////////////////////////
// Create the analysis manager
//
// Input
IlcMultiEventInputHandler* inpHandler = new IlcMultiEventInputHandler(2, 1);
// Pool
IlcEventPoolOTF* pool = new IlcEventPoolOTF("event pool", "AOD");
pool->SetTagDirectory(path.Data());
pool->SetMultiplicityBin(0, 100, 100);
pool->Init();
IlcAnalysisManager *mgr = new IlcAnalysisManager("Jet Manager", "Jet Manager");
mgr->SetInputEventHandler (inpHandler);
mgr->SetEventPool(pool);
inpHandler->SetEventPool(pool);
mgr->SetDebugLevel(10);
///////////////////////////////////////////////////////////////////////////////////
gROOT->LoadMacro("IlcAnalysisTaskPhiCorr.cxx++g");
IlcAnalysisTaskPhiCorr *dphiana = new IlcAnalysisTaskPhiCorr("Phi Correlation Analysis");
dphiana->SetDebugLevel(10);
mgr->AddTask(dphiana);
//
// Create containers for input/output
IlcAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain",TChain::Class(),
IlcAnalysisManager::kInputContainer);
IlcAnalysisDataContainer *coutput1 = mgr->CreateContainer("tree", TTree::Class(),
IlcAnalysisManager::kExchangeContainer, "default");
IlcAnalysisDataContainer *coutput2 = mgr->CreateContainer("histos", TList::Class(),
IlcAnalysisManager::kOutputContainer, "histos.root");
mgr->ConnectInput (dphiana, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput (dphiana, 0, coutput1 );
mgr->ConnectOutput (dphiana, 1, coutput2 );
//
// Run the analysis
//
mgr->InitAnalysis();
mgr->PrintStatus();
mgr->StartAnalysis("mix",chain, 1000);
}
void runCentralitySelection(const char *mode="local")
{
// Load common libraries
gSystem->Load("libCore.so");
gSystem->Load("libTree.so");
gSystem->Load("libGeom.so");
gSystem->Load("libVMC.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISilc");
gSystem->Load("libCORRFW");
gSystem->Load("libPWGHFbase");
gSystem->Load("libPWGmuon");
// Use IlcRoot includes to compile our task
gROOT->ProcessLine(".include $ILC_ROOT/include");
// filename
TChain* chain = new TChain("esdTree");
chain->AddFile("/home/alberica/analysis/centrality/data/ilc/sim/LHC10a12/104157/998/root_archive.zip#IlcESDs.root");
// Create the analysis manager
IlcAnalysisManager *mgr = new IlcAnalysisManager("AnalysisManager");
mgr->SetDebugLevel(10);
// My task
gROOT->LoadMacro("IlcCentralitySelectionTask.cxx++g");
IlcCentralitySelectionTask *task = new IlcCentralitySelectionTask("CentralitySelection");
task->SetPercentileFile("test_IlcCentralityBy1D.root");
task->SetCentralityMethod("V0");
mgr->AddTask(task);
// My dummy task
gROOT->LoadMacro("IlcDummy.cxx++g");
IlcDummy *dummytask = new IlcDummy("Dummy");
mgr->AddTask(dummytask);
IlcMCEventHandler* mcHandler = new IlcMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
IlcESDInputHandler* esdH = new IlcESDInputHandler();
mgr->SetInputEventHandler(esdH);
// Create containers for input/output
mgr->ConnectInput (task,0, mgr->GetCommonInputContainer());
mgr->ConnectInput (dummytask,0, mgr->GetCommonInputContainer());
// mgr->ConnectOutput(task,0, mgr->GetCommonOutputContainer());
// Enable debug printouts
mgr->SetDebugLevel(2);
if(!mgr->InitAnalysis()) return;
mgr->PrintStatus();
// Start analysis in grid.
mgr->StartAnalysis(mode, chain);
};
void JetAnalysisManagerKine()
{
gSystem->Load("libTree.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libGeom.so");
gSystem->Load("libVMC.so");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libSTEERBase.so");
gSystem->Load("libAOD.so");
gSystem->Load("libESD.so");
gSystem->Load("libANALYSISilc.so");
gSystem->Load("libJETAN.so");
//
if (gApplication) gApplication->InitializeGraphics();
// Create the chain
//
gROOT->LoadMacro("CreateESDChain.C");
TChain* chain = new TChain("TE");
chain->Add("/Users/kleinb/ilc/sim/PDC_08/LHC08v/280039/999/gilc.root");
///////////////////////////////////////////////////////////////////////////////////
// Create the analysis manager
//
// Output
IlcAODHandler* aodHandler = new IlcAODHandler();
aodHandler->SetOutputFileName("aod.root");
// MC Truth
IlcMCEventHandler* mcHandler = new IlcMCEventHandler();
IlcAnalysisManager *mgr = new IlcAnalysisManager("Jet Manager", "Jet Manager");
mgr->SetOutputEventHandler (aodHandler);
mgr->SetMCtruthEventHandler(mcHandler);
mgr->SetDebugLevel(10);
IlcAnalysisTaskKineFilter *kinefilter = new IlcAnalysisTaskKineFilter("Kine Filter");
mgr->AddTask(kinefilter);
IlcAnalysisTaskJets *jetana = new IlcAnalysisTaskJets("JetAnalysis");
jetana->SetConfigFile("ConfigJetAnalysisMC.C");
jetana->SetDebugLevel(10);
mgr->AddTask(jetana);
//
// Create containers for input/output
IlcAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain",TChain::Class(),
IlcAnalysisManager::kInputContainer);
IlcAnalysisDataContainer *coutput1 = mgr->CreateContainer("tree", TTree::Class(),
IlcAnalysisManager::kOutputContainer, "default");
IlcAnalysisDataContainer *coutput2 = mgr->CreateContainer("histos", TList::Class(),
IlcAnalysisManager::kOutputContainer, "histos.root");
mgr->ConnectInput (kinefilter, 0, cinput1 );
mgr->ConnectOutput (kinefilter, 0, coutput1 );
mgr->ConnectInput (jetana, 0, cinput1 );
mgr->ConnectOutput (jetana, 0, coutput1 );
mgr->ConnectOutput (jetana, 1, coutput2 );
//
// Run the analysis
//
mgr->InitAnalysis();
mgr->PrintStatus();
mgr->StartAnalysis("local",chain);
}
//______________________________________________________________________________
void AODtrain(Int_t merge=0)
{
// Main analysis train macro.
if (merge) {
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("QAtrain", "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 (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");
// Load common libraries and set include path
if (!LoadCommonLibraries()) {
::Error("AnalysisTrain", "Could not load common libraries");
return;
}
// Make the analysis manager and connect event handlers
IlcAnalysisManager *mgr = new IlcAnalysisManager("Analysis Train", "Production train");
if (useSysInfo) mgr->SetNSysInfo(100);
// Load analysis specific libraries
if (!LoadAnalysisLibraries()) {
::Error("AnalysisTrain", "Could not load analysis libraries");
return;
}
// Create input handler (input container created automatically)
// ESD input handler
IlcESDInputHandler *esdHandler = new IlcESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
// Monte Carlo handler
if (useMC) {
IlcMCEventHandler* mcHandler = new IlcMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetReadTR(useTR);
}
// AOD output container, created automatically when setting an AOD handler
if (iAODhandler) {
// AOD output handler
IlcAODHandler* aodHandler = new IlcAODHandler();
aodHandler->SetOutputFileName("IlcAOD.root");
mgr->SetOutputEventHandler(aodHandler);
}
// Debugging if needed
if (useDBG) mgr->SetDebugLevel(3);
AddAnalysisTasks();
if (merge) {
AODmerge();
mgr->InitAnalysis();
mgr->SetGridHandler(new IlcAnalysisAlien);
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 AddAnalysisTasks(){
// Add all analysis task wagons to the train
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
//
// Tender and supplies. Needs to be called for every event.
//
IlcAnalysisManager::SetCommonFileName("AODQA.root");
if (useTender) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/TenderSupplies/AddTaskTender.C");
// IF V0 tender needed, put kTRUE below
IlcAnalysisTaskSE *tender = AddTaskTender(useV0tender);
// tender->SetDebugLevel(2);
}
if (usePhysicsSelection) {
// Physics selection task
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
mgr->RegisterExtraFile("event_stat.root");
IlcPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(useMC);
// IlcOADBPhysicsSelection * oadbDefaultPbPb = CreateOADBphysicsSelection();
// physSelTask->GetPhysicsSelection()->SetCustomOADBObjects(oadbDefaultPbPb,0,0);
mgr->AddStatisticsTask(IlcVEvent::kAny);
}
// Centrality (only Pb-Pb)
if (iCollision && useCentrality) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
IlcCentralitySelectionTask *taskCentrality = AddTaskCentrality();
taskCentrality->SelectCollisionCandidates(IlcVEvent::kAny);
}
if (iESDfilter) {
// ESD filter task configuration.
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
if (iMUONcopyAOD) {
printf("Registering delta AOD file\n");
mgr->RegisterExtraFile("IlcAOD.Muons.root");
mgr->RegisterExtraFile("IlcAOD.Dimuons.root");
IlcAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, kTRUE, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,IlcESDpid::kTOF_T0,kTRUE,kFALSE,kFALSE,run_flag);
} else {
IlcAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, kFALSE, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,IlcESDpid::kTOF_T0,kTRUE,kFALSE,kFALSE,run_flag); // others
}
}
// ********** PWG3 wagons ******************************************************
// PWGHF vertexing
if (iPWGHFvertexing) {
gROOT->LoadMacro("$ILC_ROOT/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C");
if (!iPWGHFd2h) TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
IlcAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF();
if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "IlcAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("IlcAOD.VertexingHF.root");
taskvertexingHF->SelectCollisionCandidates(0);
}
// PWGDQ JPSI filtering (only pp)
if (iPWGDQJPSIfilter && (iCollision==0)) {
gROOT->LoadMacro("$ILC_ROOT/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C");
IlcAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter();
if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "IlcAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("IlcAOD.Dielectron.root");
taskJPSIfilter->SelectCollisionCandidates(0);
}
// PWGHF D2h
if (iPWGHFd2h) {
gROOT->LoadMacro("$ILC_ROOT/PWGHF/vertexingHF/AddD2HTrain.C");
TFile::Cp(gSystem->ExpandPathName(configPWGHFd2h.Data()), "file:ConfigVertexingHF.C");
AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0);
}
// ********** PWG4 wagons ******************************************************
// Jet analysis
// Configurations flags, move up?
TString kDeltaAODJetName = "IlcAOD.Jets.root"; //
Bool_t kIsPbPb = (iCollision==0)?false:true; // can be more intlligent checking the name of the data set
TString kDefaultJetBackgroundBranch = "";
TString kJetSubtractBranches = "";
UInt_t kHighPtFilterMask = 128;// from esd filter
UInt_t iPhysicsSelectionFlag = IlcVEvent::kMB;
if (iJETAN) {
gROOT->LoadMacro("$ILC_ROOT/PWGJE/macros/AddTaskJets.C");
// Default jet reconstructor running on ESD's
IlcAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
if (!taskjets) ::Fatal("AnalysisTrainNew", "IlcAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
if (iJETANdelta) {
// AddTaskJetsDelta("IlcAOD.Jets.root"); // need to modify this accordingly in the add task jets
mgr->RegisterExtraFile(kDeltaAODJetName.Data());
TString cTmp("");
if(kIsPbPb){
// UA1 intrinsic background subtraction
taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
// SICONE
taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later....
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
cTmp = taskjets->GetNonStdBranch();
if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
// Add the clusters..
gROOT->LoadMacro("$ILC_ROOT/PWGJE/macros/AddTaskJetCluster.C");
IlcAnalysisTaskJetCluster *taskCl = 0;
Float_t fCenUp = 0;
Float_t fCenLo = 0;
Float_t fTrackEtaWindow = 0.9;
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetNRandomCones(10);
taskCl->SetCentralityCut(fCenLo,fCenUp);
taskCl->SetGhostEtamax(fTrackEtaWindow);
kDefaultJetBackgroundBranch = Form("%s_%s",IlcAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
taskCl->SetNRandomCones(10);
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
// DO THE BACKGROUND SUBTRACTION
if(kIsPbPb&&kJetSubtractBranches.Length()){
gROOT->LoadMacro("$ILC_ROOT/PWGJE/macros/AddTaskJetBackgroundSubtract.C");
IlcAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d");
taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
}
}
}
void AddAnalysisTasks(const char *suffix)
{
TString ss(suffix);
ss.ToLower();
Bool_t ibarrel = (ss.Contains("barrel"))?kTRUE:kFALSE;
IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager();
mgr->SetCommonFileName(Form("QAresults%s.root",suffix));
// Statistics task
mgr->AddStatisticsTask(kTriggerMask);
//
// CDB connection
//
if (doCDBconnect) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
IlcTaskCDBconnect *taskCDB = AddTaskCDBconnect();
if (!taskCDB) return;
IlcCDBManager *cdb = IlcCDBManager::Instance();
cdb->SetDefaultStorage("raw://");
taskCDB->SetRunNumber(run_number);
}
//
// Event Statistics (Jan Fiete)
//
if (doEventStat) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
IlcPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE /*MC*/);
IlcAnalysisDataContainer *cstatsout = (IlcAnalysisDataContainer*)mgr->GetOutputs()->FindObject("cstatsout");
cstatsout->SetFileName(Form("EventStat_temp%s.root", suffix));
}
//
// Centrality (A. Toia)
//
if (doCentrality) {
if (!iCollisionType) {
printf("Disabling centrality task for p-p\n");
doCentrality = kFALSE;
} else {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
IlcCentralitySelectionTask *taskCentrality = AddTaskCentrality();
}
}
// Vertexing (A. Dainese)
//
if (doVertex) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskVertexESD.C");
IlcAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kFALSE, kTriggerMask);
taskvertexesd->SelectCollisionCandidates(kTriggerMask);
}
// TPC QA (E. Sicking)
//
if (doQAsym) {
// offline trigger in AddTask
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
IlcAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
}
//
// VZERO QA (C. Cheshkov)
//
if (doVZERO && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
IlcAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
if (doVZEROPbPb && iCollisionType==1) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/VZERO/AddTaskVZEROPbPb.C");
IlcAnaVZEROPbPb* taskV0PbPb = (IlcAnaVZEROPbPb*)AddTaskVZEROPbPb(0);
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-");
taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
}
//
// TPC (Jacek Otwinowski & Michael Knichel)
//
//
// Optionally MC information can be used by setting the 1st argument to true
// Optionally friends information can be switched off by setting the 2st argument
// to false
// Optionally highMult axis can be used by setting the 3st argument to true (for PbPb)
if (doTPC && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
IlcPerformanceTask *tpcQA = 0;
if (iCollisionType) {
// High multiplicity Pb-Pb
tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kTRUE);
} else {
// Low multiplicity (pp)
tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE);
}
tpcQA->SelectCollisionCandidates(kTriggerMask);
}
// HLT (Alberica Toia)
if (doHLT && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
IlcPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE,0,kTRUE);
hltQA->SelectCollisionCandidates(kTriggerMask);
}
//
// SPD (A. Mastroserio)
//
if (doSPD) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
IlcAnalysisTaskSPD* taskspdqa = (IlcAnalysisTaskSPD*)AddTaskSPDQA();
// Request from Annalisa
if (iCollisionType) taskspdqa->SetHeavyIonMode();
taskspdqa->SelectCollisionCandidates(kTriggerMask);
taskspdqa->SetOCDBInfo(run_number, "raw://");
}
//
// SDD (F. Prino)
//
if (doSDD) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
IlcAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates(kTriggerMask);
}
//
// SSD dEdx (Marek Chojnacki)
//
if (doSSDdEdx) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
IlcAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates(kTriggerMask);
}
//
// ITS
//
if (doITS) {
// hardcoded non-zero trigger mask
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
IlcAnalysisTaskITSTrackingCheck *itsQA = 0;
IlcAnalysisTaskITSTrackingCheck *itsQACent0010 = 0;
IlcAnalysisTaskITSTrackingCheck *itsQACent3050 = 0;
IlcAnalysisTaskITSTrackingCheck *itsQACent6080 = 0;
if(iCollisionType==0) {
itsQA = AddTaskPerformanceITS(kFALSE);
} else {
itsQA = AddTaskPerformanceITS(kFALSE);
itsQACent0010 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,3500,10000);
itsQACent3050 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,590,1570);
itsQACent6080 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,70,310);
}
}
//
// ITS saTracks, align (F.Prino)
//
if (doITSsaTracks) {
// offline trigger in AddTask
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskITSsaTracks.C");
IlcAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kFALSE,kFALSE);
itssaTracks->SelectCollisionCandidates(kTriggerMask);
}
if (doITSalign) {
// no offline trigger selection
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskITSAlign.C");
IlcAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(doTRD && ibarrel) {
// no offline trigger selection
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
// steer individual TRD tasks
Bool_t
doCheckESD(kTRUE), // IlcTRDcheckESD
doCheckDET(kTRUE), // IlcTRDcheckDET
doEffic(kTRUE), // IlcTRDefficiency
doResolution(kTRUE),// IlcTRDresolution
doCheckPID(kTRUE), // IlcTRDcheckPID
doV0Monitor(kFALSE);// IlcTRDv0Monitor
AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
}
//
// ZDC (Chiara Oppedisano)
//
if(doZDC && ibarrel) {
// hardcoded kMB trigger mask
gROOT->LoadMacro("$ILC_ROOT/PWGPP/ZDC/AddTaskZDCQA.C");
IlcAnalysisTaskSE *taskZDC = AddTaskZDCQA();
taskZDC->SelectCollisionCandidates(kTriggerMask);
}
//
// Calorimetry (Gustavo Conesa)
//
if(doCALO) {
gROOT->LoadMacro("$ILC_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
IlcAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE);
taskCaloQA->SetDebugLevel(0);
// offline mask set in AddTask to kMB
taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE, "", "EMC7");
taskCaloQA->SetDebugLevel(0);
taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
}
//
// Muon Trigger
//
if(doMUONTrig) {
// no offline trigger selection
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
IlcAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
//
// Impact parameter resolution ([email protected], [email protected])
//
if (doImpParRes && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskImpParRes.C");
IlcAnalysisTaskSE* taskimpparres=0;
if(iCollisionType==0) {
taskimpparres= AddTaskImpParRes();
} else {
taskimpparres= AddTaskImpParRes(kFALSE,-1,kFALSE,kFALSE);
}
taskimpparres->SelectCollisionCandidates(kTriggerMask);
}
//
// MUON QA (Philippe Pillot)
//
if (doMUON) {
// trigger analysis internal
gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskMuonQA.C");
IlcAnalysisTaskSE* taskmuonqa= AddTaskMuonQA();
}
//
// TOF (Francesca Bellini)
//
if (doTOF && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
IlcAnalysisTaskTOFqa *tofQA = AddTaskTOFQA();
tofQA->SelectCollisionCandidates(kTriggerMask);
}
//
// PIDResponse(JENS)
//
if (doPIDResponse && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
IlcAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
PIDResponse->SelectCollisionCandidates(kTriggerMask);
}
//
// PIDqa(JENS)
//
if (doPIDqa && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
IlcAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
PIDQA->SelectCollisionCandidates(kTriggerMask);
}
//
// HMPID QA (Giacomo Volpe)
//
if (doHMPID && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/HMPID/AddTaskHmpidQA.C");
IlcAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kFALSE);
// offline mask set in AddTask to kMB
taskhmpidqa->SelectCollisionCandidates(kTriggerMask);
}
// T0 QA (Alla Mayevskaya)
if (doT0 && ibarrel) {
// no offline trigger selection
gROOT->LoadMacro("$ILC_ROOT/PWGPP/T0/AddTaskT0QA.C");
IlcT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
taskt0qa->SelectCollisionCandidates(kTriggerMask);
}
// FMD QA (Christian Holm Christiansen)
if (doFMD && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C");
// Parameters: usemc, usecentrality
IlcAnalysisTaskSE *forwardQA = (IlcAnalysisTaskSE *)AddTaskForwardQA(kFALSE, kFALSE);
// No offline trigger config. needed (see #84077)
}
//
// PHOS QA (Boris Polishchuk)
//
if (doPHOS) {
gROOT->LoadMacro("$ILC_ROOT/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C");
IlcAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt");
taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask);
taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
IlcAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7");
taskPHOSCellQA2->SelectCollisionCandidates(IlcVEvent::kPHI7);
taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
// Pi0 QA fo PbPb
if (iCollisionType) {
gROOT->LoadMacro("$ILC_ROOT/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C");
IlcAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0);
}
}
if (doPHOSTrig) {
gROOT->LoadMacro("$ILC_ROOT/PWGGA/PHOSTasks/PHOS_TriggerQA/macros/AddTaskPHOSTriggerQA.C");
IlcAnalysisTaskPHOSTriggerQA *taskPHOSTrig = AddTaskPHOSTriggerQA(NULL);
}
//
// EMCAL QA (Gustavo Conesa)
//
if (doEMCAL) {
gROOT->LoadMacro("$ILC_ROOT/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C");
IlcAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA();
}
//
// FLOW and BF QA (C.Perez && A.Rodriguez)
//
if (doFBFqa && ibarrel) {
gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskFBFqa.C");
IlcAnalysisTaskSE *qaFBFMB = (IlcAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE);
qaFBFMB->SelectCollisionCandidates(IlcVEvent::kMB);
IlcAnalysisTaskSE *qaFBFSC = (IlcAnalysisTaskSE*) AddTaskFBFqa("qaFBFsc",kFALSE);
qaFBFSC->SelectCollisionCandidates(IlcVEvent::kSemiCentral);
IlcAnalysisTaskSE *qaFBFCE = (IlcAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE);
qaFBFCE->SelectCollisionCandidates(IlcVEvent::kCentral);
}
}
