//___________________________________________________________
void runAlien(TString data, TString mode = "test", Bool_t MC = kFALSE){
if(!gSystem->Getenv("ALICE_ROOT")){
printf("AliRoot has to be initialized\n");
return;
}
// check for valid modes
const int kModes = 5;
TString allowed_modes[kModes] = {"proof", "prooftest", "test", "full", "submit"};
Bool_t isValid = kFALSE;
mode.ToLower();
for(int imode = 0; imode < kModes; imode++){
if(!mode.CompareTo(allowed_modes[imode])) isValid = kTRUE;
}
if(!isValid){
printf("invalid analysis mode selected\n");
return;
}
analysis_mode = mode;
Bool_t proofmode = mode.Contains("proof");
// libraries to be loaded
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libCORRFW");
gSystem->Load("libPWGhfe");
// Create Analysis Manager
AliAnalysisManager *runAnalysis = new AliAnalysisManager("Heavy Flavour Electron Analysis");
runAnalysis->SetCommonFileName(output_file.Data());
runAnalysis->SetInputEventHandler(new AliESDInputHandler);
if(MC) runAnalysis->SetMCtruthEventHandler(new AliMCEventHandler);
AliAnalysisAlien *alienhandler = CreateAlienHandler(proofmode);
printf("alienhandler %p\n", alienhandler);
runAnalysis->SetGridHandler(alienhandler);
//return;
// Specify input (runs or dataset)
if(!proofmode){
// Query sample ID and runs
TString sample;
TArrayI listofruns;
DecodeDataString(data, sample, listofruns);
AddInput(alienhandler, sample, listofruns, MC);
} else {
alienhandler->SetProofDataSet(data);
}
// Add Tasks
gROOT->LoadMacro(Form("%s/OADB/macros/AddTaskPhysicsSelection.C", gSystem->Getenv("ALICE_ROOT")));
gROOT->LoadMacro(Form("%s/PWG3/hfe/macros/AddTaskHFE.C", gSystem->Getenv("ALICE_ROOT")));
AddTaskPhysicsSelection(MC);
AddTaskHFE(); // @TODO: MC and PbPb flag to be fixed
// Run Analysis
TString anamode = proofmode ? "proof" : "grid";
if(runAnalysis->InitAnalysis()){
runAnalysis->PrintStatus();
runAnalysis->StartAnalysis(anamode);
}
}
void SetupUtil(bool isMC, bool isAOD){
//
// Setup utility packages
//
// 1. Physics Selection (ESD only)
// 2. Tender (ESD only)
// 3. PID Response (always)
// 4. Centrality Task (ESD only)
//
//===== ADD PID RESPONSE: ===
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AddTaskPIDResponse(isMC);
//==== Add tender ====
if(!isAOD){
gROOT->LoadMacro("$ALICE_ROOT/TENDER/TenderSupplies/AddTaskTender.C");
//AddTaskTender();
}
//==== Physics Selection ====
if(!isAOD){
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC);
}
//===== ADD CENTRALITY: ===
if(!isAOD){
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
AddTaskCentrality();
}
}
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());
}
}
Bool_t AddAMEventMixingTest(TString analysisSource = "proof", TString analysisMode = "test",TString input="aod",TString inputMC="", TString postfix = "",TString idStr="0")
{
Bool_t useEventMixingPar = 1;
Int_t usePhysSel = 1;
Bool_t useMC = !inputMC.CompareTo("mc");
input.ToLower();
// ALICE stuff
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) { Printf("Error[AddAMEventMixingTest] mgr is null !!!"); return kFALSE; }
AliAnalysisGrid *analysisPlugin = mgr->GetGridHandler();
if (!analysisPlugin) { Printf("Error[AddAMEventMixingTest] : analysisPlugin is null !!!"); return kFALSE; }
TString myAdditionalLibs;
if (useEventMixingPar) { AliAnalysisAlien::SetupPar("EventMixing"); myAdditionalLibs += " EventMixing.par"; }
else { gSystem->Load("libEventMixing.so"); myAdditionalLibs += " libEventMixing.so"; }
gROOT->LoadMacro("AliAnalysisTaskEx02.cxx++g");
analysisPlugin->SetAnalysisSource("AliAnalysisTaskEx02.cxx+");
myAdditionalLibs+=" AliAnalysisTaskEx02.h AliAnalysisTaskEx02.cxx";
analysisPlugin->SetAdditionalLibs(myAdditionalLibs.Data());
AliMultiInputEventHandler *multiInputHandler = mgr->GetInputEventHandler();
if (usePhysSel && !input.CompareTo("esd")) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
AddTaskPhysicsSelection(useMC);
// maybe we can put it in $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C
AliMultiInputEventHandler *multiIH = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
if (multiIH){
AliESDInputHandler *esdIH = dynamic_cast<AliESDInputHandler *>(multiIH->GetFirstInputEventHandler());
if (esdIH) esdIH->SetEventSelection(multiIH->GetEventSelection());
AliAODInputHandler *aodIH = dynamic_cast<AliAODInputHandler *>(multiIH->GetFirstInputEventHandler());
if (aodIH) aodIH->SetEventSelection(multiIH->GetEventSelection());
}
}
// add mixing handler (uncomment to turn on Mixnig)
gROOT->LoadMacro("AddMixingHandler.C");
AddMixingHandler(multiInputHandler, input, useMC,postfix);
// load and run AddTask macro
gROOT->LoadMacro("AddEventMixingTestTask.C");
AddEventMixingTestTask(input, useMC, postfix);
return kTRUE;
}
void AddPhysicsSelection(Bool_t isMC=kFALSE)
{
// physics selection a la Michele
printf("Requesting physics selection in %s mode\n",isMC ? "MC":"Data");
gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
//isMC is true when processing monte carlo, the second 0 disables the cluster vs tracklets
AliPhysicsSelectionTask* physicsSelectionTask = AddTaskPhysicsSelection(isMC,0);
if(!isMC) {
AliPhysicsSelection * physSel = physicsSelectionTask->GetPhysicsSelection();
physSel->AddCollisionTriggerClass("+CMBAC-B-NOPF-ALL");
/*
physSel->AddCollisionTriggerClass("+CMBS1C-B-NOPF-ALL");
physSel->AddCollisionTriggerClass("+CMBS1A-B-NOPF-ALL");
*/
//
physSel->AddCollisionTriggerClass("+CMBS2C-B-NOPF-ALL");
physSel->AddCollisionTriggerClass("+CMBS2A-B-NOPF-ALL");
//
// This are needed only to fill the statistics tables
physSel->AddBGTriggerClass("+CMBAC-C-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBAC-A-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBAC-E-NOPF-ALL");
//
/*
physSel->AddBGTriggerClass("+CMBS1C-C-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS1C-A-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS1C-E-NOPF-ALL");
//
physSel->AddBGTriggerClass("+CMBS1A-C-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS1A-A-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS1A-E-NOPF-ALL");
//
*/
/*
//
physSel->AddBGTriggerClass("+CMBS2C-C-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS2C-A-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS2C-E-NOPF-ALL");
//
physSel->AddBGTriggerClass("+CMBS2A-C-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS2A-A-NOPF-ALL");
physSel->AddBGTriggerClass("+CMBS2A-E-NOPF-ALL");
*/
}
// if you use the following line, your task only gets the selected events
// task->SelectCollisionCandidates(AliVEvent::kUserDefined);
//
//Alternatively, in the UserExec of your task:
//Bool_t isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kUserDefined);
//
}
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);
}
}
void runCPVAnalysis(const char *runmode = "full")
{
// set if you want to run the analysis locally (kTRUE), or on grid (kFALSE)
// Bool_t local = kFALSE;
Bool_t local = kTRUE;
// if you run on grid, specify test mode (kTRUE) or full grid model (kFALSE)
// Bool_t gridTest = kTRUE;
Bool_t gridTest = kFALSE;
// since we will compile a class, tell root where to look for headers
gROOT->ProcessLine(".include $ROOTSYS/include");
gROOT->ProcessLine(".include $ALICE_ROOT/include");
// create the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("AnalysisTaskCPV");
AliESDInputHandler *esdH = new AliESDInputHandler();
mgr->SetInputEventHandler(esdH);
//PID task
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTask *taskPID = AddTaskPIDResponse(/*Bool_t isMC=*/ kFALSE, /*Bool_t autoMCesd=*/kTRUE,
/*Bool_t tuneOnData=*/kTRUE);
// // Add physics selection
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
physSelTask->GetPhysicsSelection()->SetUseBXNumbers(kFALSE);// ---> ???
// load the addtask macro
gROOT->LoadMacro("AddTaskCPV.C");
// create an instance of your analysis task
AliAnalysisTaskCPV *task = AddTaskCPV();
task->SetRCPV(428.3);
task->SelectCollisionCandidates(AliVEvent::kINT7);
if(!mgr->InitAnalysis()) return;
mgr->SetDebugLevel(2);
mgr->PrintStatus();
mgr->SetUseProgressBar(1, 25);
if(local) {
// if you want to run locally, we need to define some input
TChain* chain = new TChain("esdTree");
// add a few files to the chain (change this so that your local files are added)
TGrid::Connect("alien://");
chain->Add("alien:///alice/data/2015/LHC15n/000244340/pass2/15000244340020.100/AliESDs.root");
// start the analysis locally, reading the events from the tchain
mgr->StartAnalysis("local", chain);
} else {
// if we want to run on grid, we create and configure the plugin
AliAnalysisAlien *alienHandler = new AliAnalysisAlien();
alienHandler->SetCheckCopy(kFALSE);
// also specify the include (header) paths on grid
alienHandler->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_PHYSICS/include");
// select the aliphysics version. all other packages
// are LOADED AUTOMATICALLY!
alienHandler->SetAliPhysicsVersion("vAN-20170215-1");
// set the Alien API version
alienHandler->SetAPIVersion("V1.1x");
// select the input data
alienHandler->SetGridDataDir("/alice/data/2015/LHC15n");
alienHandler->SetDataPattern("/pass2/*/AliESDs.root");
const Int_t runList[] = {244340, 244343};
const Int_t nRuns = 2;
// const Int_t runList[] = {244340, 244343, 244351, 244355, 244359,
// 244364, 244377, 244411, 244416, 244418,
// 244421, 244453, 244480, 244481, 244482,
// 244483, 244484, 244531, 244540, 244542,
// 244617, 244618, 244627, 244628};
// const Int_t nRuns = 24;
// MC has no prefix, data has prefix 000
alienHandler->SetRunPrefix("000");
// runnumber
for (Int_t iRun=0; iRun<nRuns; iRun++) {
alienHandler->AddRunNumber(runList[iRun]);
}
// number of files per subjob
alienHandler->SetSplitMaxInputFileNumber(50);
alienHandler->SetExecutable("CPVTask.sh");
// specify how many seconds your job may take
alienHandler->SetTTL(36000);
alienHandler->SetJDLName("CPVTask.jdl");
alienHandler->SetOutputToRunNo(kTRUE);
alienHandler->SetKeepLogs(kTRUE);
// merging: run with kTRUE to merge on grid
// after re-running the jobs in SetRunMode("terminate")
// (see below) mode, set SetMergeViaJDL(kFALSE)
// to collect final results
alienHandler->SetMaxMergeStages(2);
alienHandler->SetMergeViaJDL(kTRUE);
// define the output folders
alienHandler->SetGridWorkingDir("CPVWorkingDir");
alienHandler->SetGridOutputDir("CPVOutputDir_R428");
// connect the alien plugin to the manager
mgr->SetGridHandler(alienHandler);
if(gridTest) {
// speficy on how many files you want to run
alienHandler->SetNtestFiles(1);
// and launch the analysis
alienHandler->SetRunMode("test");
mgr->StartAnalysis("grid");
} else {
// else launch the full grid analysis
alienHandler->SetRunMode(runmode);
mgr->StartAnalysis("grid");
}
}
}
AliAnalysisTaskPHOSNeutralMeson* AddTaskAliAnalysisTaskPHOSNeutralMeson(
TString taskName,
TString collisionCandidates,
Bool_t usePhysicsSelection,
Bool_t usePHOSTender,
Int_t clusterMinCells,
Float_t clusterMinE,
Float_t clusterMinM02,
Float_t distToBadCellOnCellLevel,
Float_t distToBadCell,
Bool_t doTimingCut,
Float_t timingCutMin,
Float_t timingCutMax,
Float_t zVertexCut,
TString recalOption,
Double_t recalFactorMod1,
Double_t recalFactorMod2,
Double_t recalFactorMod3,
TString mPtHistoMode,
Bool_t applyBadMap_manually,
Bool_t useIsVertexSelected2013pA,
TString badMapName = "defaultTenderBM",
Bool_t fillMCHistos = kFALSE,
Bool_t analyseAddedSignals = kFALSE,
TString mcParticleToAnalyse = "pi0",
Double_t expoPara1 = 0.0,
Double_t expoPara2 = 0.0,
Double_t expoPara3 = 0.0,
Double_t expoPara4 = 0.0,
TString additionalFileNameString = "",
Bool_t fillHitMapsAddedS = kFALSE,
Bool_t fillDecayInfoAddedS = kFALSE,
Char_t *suffix = "")
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskAliFraNeutralMeson", "No analysis manager to connect to.");
return NULL;
}
// ******************************************************
// ***** SETTINGS ***** ***** ***** ***** ***** *****
// for possible bad maps see alien:///alice/cern.ch/user/m/mhecker/BadMaps/:
// BM13c_6_15_allMd_all_noMod2 = BM_d_13c_22_6_2015_allMod_allMod2Off.root (old name)
// defaultTenderBM (switches off SetForceUsingBadMap for Tender!)
// BM_d_13c_22_6_2015_allMod_all.root BM_d_13c_28_4_15
Bool_t DoDistToBadCell = false;
if (distToBadCell > 0.00001) DoDistToBadCell = true;
Bool_t DoDistToBadCellOnCellLevel = false;
if (distToBadCellOnCellLevel > 0) DoDistToBadCellOnCellLevel = true;
// ***** ***** ***** ***** ***** ***** ***** ***** *****
// ******************************************************
TString ContName = "contPHOSNeutralMeson";
TString combinedName;
combinedName.Form("%s%s",ContName.Data(), suffix);
TString pathToBadMap;
if (badMapName !="defaultTenderBM") {
gSystem->Exec(Form("alien_cp alien:///alice/cern.ch/user/m/mhecker/BadMaps/%s.root .",badMapName.Data()));
pathToBadMap = Form("%s/",gSystem->pwd());
pathToBadMap += badMapName;
pathToBadMap += ".root";
}
// **** PHOS TENDER ***********
if(usePHOSTender) {
cout<<"###### PHOS TENDER ! ######"<<endl;
// ~~~~~~~~~~~~~ Loading Tender for AODs ~~~~~~~~~~~~~~~~~~
Int_t tenderPassNumber = 1; // does not matter (just has to be >= 0). tender then finds the correct pass itself
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_PbPb/AddAODPHOSTender.C");
AliPHOSTenderTask *tenderPHOS = AddAODPHOSTender("PHOSTenderTask","PHOStender","",tenderPassNumber);
AliPHOSTenderSupply *PHOSSupply = tenderPHOS->GetPHOSTenderSupply();
if(badMapName !="defaultTenderBM") {
printf("Setting Tender-BadMap to private BM \n");
PHOSSupply->ForceUsingBadMap(pathToBadMap.Data());
} else printf("Running Tender with its default BadMap \n");
}
// ********** PHYSICS SELECTION ******************
if(usePhysicsSelection) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
printf(" ********* AliPhysicsSelectionTask configured ********* ");
}
// Initialize Task
AliAnalysisTaskPHOSNeutralMeson *task = new AliAnalysisTaskPHOSNeutralMeson(taskName.Data());
// Set variables for Outputfile Name
if(usePHOSTender) {
task->SetSelectedSelectedTenderForOutputName("PHSTndr");
} else {
task->SetSelectedSelectedTenderForOutputName("noTndr");
}
if(usePhysicsSelection) {
task->SetSelectedPhysSelectionForOutputName("AliPhySl");
} else {
task->SetSelectedPhysSelectionForOutputName("noPhySl");
}
task->SetUsedBadmapForOutputName(badMapName);
// ******* SET BAD MAP ******************
task->SetApplyBadMapManually(applyBadMap_manually);
if(applyBadMap_manually) {
if (badMapName == "defaultTenderBM") AliError("Cannot apply default tender bad map in task, now applying empty bad map. Specify own bad map to fix it.");
else {
TFile *fBadMap = TFile::Open(pathToBadMap.Data());
if(fBadMap->IsOpen()){
printf("\n\n...Adding PHOS bad channel map (MANUALY) \n") ;
gROOT->cd();
Char_t key[55] ;
for(Int_t mod=1;mod<4; mod++){
sprintf(key,"PHOS_BadMap_mod%d",mod) ;
TH2I * h = (TH2I*)fBadMap->Get(key) ;
if(h)
task->SetPHOSBadMap(mod,h) ;
}
fBadMap->Close() ;
}
}
}
// ***** END OF SET BAD MAP ***************
//~~~~~~~ Geometry ~~~~~~~~~~~~~~
//task->SetEtaAccMinMax(-0.14, 0.14);
//task->SetPhiAccMinMax(-1.72568, -0.72635);
task->SetEtaAccMinMax(-0.13, 0.13); // Set Min and Max of eta for PHOS acceptance (MC)
Double_t phiMin = 260 * (TMath::Pi()/180);
Double_t phiMax = 320 * (TMath::Pi()/180);
task->SetPhiAccMinMax(phiMin,phiMax); //60 degrees (in rad)
//~~~~~~~~ MC related ~~~~~~~~~~~~~
task->SetfFillMCHistos(fillMCHistos);
task->SetAnalyseAddedSignals(analyseAddedSignals);
//task->SetFillFeedDownHistos(true);
task->SetAnalyseMCPi0OrEta(mcParticleToAnalyse); //pi0 eta both
task->SetExponentialParameters(expoPara1, expoPara2, expoPara3, expoPara4); //for weighing added signals
task->SetAdditionalFileNameString(additionalFileNameString); //String appears at the end of the filname.
task->SetFillClusterHitmapsAddedSignals(fillHitMapsAddedS);
task->SetFillDecayPhotonInfoAddedSig(fillDecayInfoAddedS);
task->SetFillNDaughtersVsPtAndR(kFALSE); //implement bool to list of arguments of AddTask if needed
task->SetFillMPtForSingleOrMultContrClus(kFALSE); //implement bool to list of arguments of AddTask if needed
// ~~~~~~ Event Cuts ~~~~~~~~~~~~~
task->SetUseOnlyCINT1events(kFALSE);
task->SetDoZvertexCut(kTRUE);
task->SetUseIsVertexSelected2013pA(useIsVertexSelected2013pA);
task->SetZvertexCut(zVertexCut); // 10.0
// ~~~~~~ Cluster Cuts ~~~~~~~~~~~
task->SetClusterMinCells(clusterMinCells); //3
task->SetClusterMinE(clusterMinE); //0.3 GeV
task->SetClusterMinM02(clusterMinM02); //0.2
task->SetDoTimingCut(doTimingCut); //for MC: false
task->SetTimingCutMinMax(timingCutMin, timingCutMax); //-0.10e-6,0.10e-6
task->SetDoDistToBadCellCut(DoDistToBadCell);
task->SetDistToBadCell(distToBadCell); // [cm]
task->SetDoDistToBadCellCutOnCellLevel(DoDistToBadCellOnCellLevel);
task->SetDistToBadCellOnCellLevel(distToBadCellOnCellLevel);
// ~~~~~~~~ Filling options ~~~~~~
task->SetFillCellIdVsE(false); //Neccessary for QA (BadMap) (increases Outputfile-size)
task->SetFillTimingHistos(true); //Neccessary to determine timing cut values.
task->SetFillClusterHitmaps(true); // To check the BadMaps and cluster distributions
if (mPtHistoMode != "nrmlMptHst") {
if (mPtHistoMode == "hMPTvsMod") task->SetFillhMassPtModules(true); // For module-wise pi0 analysis
else if (mPtHistoMode == "hMPTvsTim") task->SetFillhMassPtTiming(true); // For calculation of timing efficiency
else if (mPtHistoMode == "hMPTnewAsy") task->SetFillNewAsymmClasses(true);
else mPtHistoMode = "nrmlMptHst"; // if none of the implemented (above) modes is set, the string is set to default
}
task->SetFillNTupelClusterEnergy(false); //Neccesary to calculate module dependent energy recal factors
// ~~~~ recalibration options ~~~~
//task->SetDoClusterEnergyRecalibration(false);
task->SetRecalibrationOption(recalOption); // look in .cxx for possible options
task->SetRecalibrateModuleWise(false);
task->SetModuleWiseRecalibrationFactors(recalFactorMod1,recalFactorMod2,recalFactorMod3);
//task->SetModuleWiseRecalibrationFactors(0.9942,0.9822,1.0072); //pp
// SelectCollisionCandidates according to collisionCandidates set in Settings (line 14)
if(collisionCandidates == "kPHI7") {
task->SelectCollisionCandidates(AliVEvent::kPHI7);
task->SetSelectedCollCandidatesForOutputName("kPHI7");
}
if(collisionCandidates == "kINT7") {
task->SelectCollisionCandidates(AliVEvent::kINT7);
task->SetSelectedCollCandidatesForOutputName("kINT7");
}
if(collisionCandidates == "kAny") {
task->SelectCollisionCandidates(AliVEvent::kAny);
task->SetSelectedCollCandidatesForOutputName("kAny");
}
if(collisionCandidates == "kMB") {
task->SelectCollisionCandidates(AliVEvent::kMB);
task->SetSelectedCollCandidatesForOutputName("kMB");
}
if(collisionCandidates == "kERT1") {
task->SelectCollisionCandidates(AliVEvent::kERT1);
task->SetSelectedCollCandidatesForOutputName("kERT1");
}
// ********************* IMPORTANT: ****************************
// The OutputfileName cannot be to long!
// The Gridjobs crash in a ERROR_RE if it is too long
// It has been successfully tested with a filename length of 135 symbols
// *************************************************************
// make OutPutFileName after making all Settings
TString OutPutFileName = task->MakeOutputFileName();
mgr->AddTask(task);
AliAnalysisDataContainer *coutput0 = mgr->CreateContainer(Form("%s:%s", ContName.Data(),OutPutFileName.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:dirNeutralMeson", mgr->GetCommonFileName()));
mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(task,1,coutput0);
return task;
}
void CPVanalysis(const TString dataset="")
{
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
//load analysis framework
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_ROOT/PHOS");
// A task can be compiled dynamically with AClic
gROOT->LoadMacro("AliAnalysisTaskCPV.cxx+g");
// Connect to alien
TString token = gSystem->Getenv("GRID_TOKEN") ;
token="OK";
if ( token == "OK" )
TGrid::Connect("alien://");
else
Printf("You are not connected to the GRID") ;
// AliInfo("You are not connected to the GRID") ;
cout << "CPVanalysis: processing collection " << dataset << endl;
// Create the chain
TChain* chain;
if (dataset.Contains(".txt")) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/CreateESDChain.C");
chain = CreateESDChain(dataset.Data(), 1000);
}
else if (dataset.Contains(".xml")) {
chain = new TChain("esdTree");
TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset));
TAlienResult* result = collection->GetGridResult("",0 ,0);
TList* rawFileList = result->GetFileInfoList();
for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) {
TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(counter)) ;
const char * rawFile = fi->GetCurrentUrl()->GetUrl() ;
printf("Processing %s\n", rawFile) ;
chain->Add(rawFile);
printf("Chain: %d entries.\n",chain->GetEntries());
}
}
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("CPVanalysis");
// ESD input handler
AliESDInputHandler* esdH = new AliESDInputHandler();
esdH->SetReadFriends(kFALSE);
mgr->SetInputEventHandler(esdH);
// Debug level
mgr->SetDebugLevel(0);
//PID task
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTask *taskPID = AddTaskPIDResponse(/*Bool_t isMC=*/ kFALSE, /*Bool_t autoMCesd=*/kTRUE,
/*Bool_t tuneOnData=*/kTRUE);
// // Add physics selection
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
physSelTask->GetPhysicsSelection()->SetUseBXNumbers(kFALSE);// ---> ???
// Add my task
AliAnalysisTaskCPV *task1 = new AliAnalysisTaskCPV("CPVanalysis");
// task1->SelectCollisionCandidates(AliVEvent::kMB);
mgr->AddTask(task1);
// Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("histCPV1",TList::Class(),AliAnalysisManager::kOutputContainer,"CPVanalysis.root");
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("histCPV2",TList::Class(),AliAnalysisManager::kOutputContainer,"CPVanalysis.root");
((AliInputEventHandler*)mgr->GetInputEventHandler())->SetNeedField(1);
// Connect input/output
mgr->ConnectInput(task1 , 0, cinput);
mgr->ConnectOutput(task1, 1, coutput1);
mgr->ConnectOutput(task1, 2, coutput2);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
}
//______________________________________________________________________________
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 anaCaloFilter(Int_t mode=mLocal)
{
// Main
char cmd[200] ;
sprintf(cmd, ".! rm -rf AliAOD.root") ;
gROOT->ProcessLine(cmd) ;
//--------------------------------------------------------------------
// Load analysis libraries
// Look at the method below,
// change whatever you need for your analysis case
// ------------------------------------------------------------------
LoadLibraries(mode) ;
//-------------------------------------------------------------------------------------------------
//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 {
cout<<"Wrong data type "<<kInputData<<endl;
break;
}
TChain *chain = new TChain(kTreeName) ;
CreateChain(mode, chain);
if(chain){
AliLog::SetGlobalLogLevel(AliLog::kError);//Minimum prints on screen
//--------------------------------------
// Make the analysis manager
//-------------------------------------
AliAnalysisManager *mgr = new AliAnalysisManager("Manager", "Manager");
// AOD output handler
AliAODHandler* aodoutHandler = new AliAODHandler();
aodoutHandler->SetOutputFileName("AliAOD.root");
////aodoutHandler->SetCreateNonStandardAOD();
mgr->SetOutputEventHandler(aodoutHandler);
//input
if(kInputData == "ESD")
{
// ESD handler
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
esdHandler->SetReadFriends(kFALSE);
cout<<"ESD handler "<<mgr->GetInputEventHandler()<<endl;
}
if(kInputData == "AOD")
{
// AOD handler
AliAODInputHandler *aodHandler = new AliAODInputHandler();
mgr->SetInputEventHandler(aodHandler);
cout<<"AOD handler "<<mgr->GetInputEventHandler()<<endl;
}
// mgr->SetDebugLevel(1);
//-------------------------------------------------------------------------
//Define task, put here any other task that you want to use.
//-------------------------------------------------------------------------
// ESD physics selection task
if(kInputData == "ESD" && kUsePhysSel)
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
}
gROOT->LoadMacro("AddTaskCaloFilter.C");
AliAnalysisTaskCaloFilter* filter = AddTaskCaloFilter();
//AliAnalysisTaskCaloFilter * filter = new AliAnalysisTaskCaloFilter();
//filter->SetConfigFileName("ConfigCaloFilter.C");
//mgr->AddTask(filter);
// Create containers for input/output
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer();
AliAnalysisDataContainer *coutntuple = mgr->CreateContainer("EventNtuple", TNtuple::Class(),
AliAnalysisManager::kOutputContainer, "eventselection.root");
mgr->ConnectInput (filter, 0, cinput1);
mgr->ConnectOutput (filter, 0, coutput1 );
mgr->ConnectOutput (filter, 1, coutntuple );
//-----------------------
// Run the analysis
//-----------------------
TString smode = "";
if (mode==mLocal || mode == mLocalCAF)
smode = "local";
else if (mode==mPROOF)
smode = "proof";
else if (mode==mGRID)
smode = "local";
mgr->InitAnalysis();
mgr->PrintStatus();
mgr->StartAnalysis(smode.Data(),chain);
cout <<" Analysis ended sucessfully "<< endl ;
}
else cout << "Chain was not produced ! "<<endl;
//sprintf(cmd, ".! rm -rf CorrectionFiles") ;
}
//______________________________________________________________________________
void runPmdTask(Bool_t isGrid = 0,
Bool_t isMC = 0,
const char *gridmode = "test") {
if (isGrid) {
Printf("Strating the Grid Job ");
Printf("Grid Mode %s",gridmode);
if (isMC) Printf("It is Data Type Run");
if (!isMC) Printf("It is MC Type Run");
}
// Load the needed libraries most of
// them already loaded by aliroot
//--------------------------------------
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libXMLIO");
gSystem->Load("libPhysics");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
// Use AliRoot includes to compile our task
gROOT->ProcessLine(".include $ALICE_INSTALL/include");
AliAnalysisManager *mgr = new AliAnalysisManager("PMDAnalysis");
if(isGrid) {
gROOT->LoadMacro("CreateAlienHandler.C");
AliAnalysisGrid *alienHandler = CreateAlienHandler(gridmode);
if (!alienHandler) return;
mgr->SetGridHandler(alienHandler);
}
// TChain * chain;
// if(!isGrid) {
// gROOT->LoadMacro("CreateESDChain.C"); // use it if you know it
// chain = CreateESDChain("file.txt", 10);
// }
TChain * chain = new TChain("esdTree");
if(!isGrid) {
ifstream file_collect(incollection);
TString line;
while (line.ReadLine(file_collect) ) {
chain->Add(line.Data());
}
}
if(isMC) {
AliVEventHandler* esdH = new AliESDInputHandler();
mgr->SetInputEventHandler(esdH);
AliMCEventHandler *mc = new AliMCEventHandler();
//mc->SetReadTR(kTRUE);
mgr->SetMCtruthEventHandler(mc);
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(isMC);
physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC();
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *centralityTask = AddTaskCentrality();
} else {
AliVEventHandler* esdH = new AliESDInputHandler();
mgr->SetInputEventHandler(esdH);
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(isMC);
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *centralityTask = AddTaskCentrality();
}
gROOT->LoadMacro("AliPMDAnalysisTaskPbPb.cxx++g");
gROOT->LoadMacro("AddAliPMDAnalysisTaskPbPb.C");
AddAliPMDAnalysisTaskPbPb("MyTask",isMC);
// Enable debug printouts
mgr->SetDebugLevel(0);
if (!mgr->InitAnalysis())
return;
mgr->PrintStatus();
if(isGrid)
mgr->StartAnalysis("grid");
else
mgr->StartAnalysis("local",chain);
};
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());
}
//
// This is an example of steering macro for running RSN analysis task
// locally with a collection of files written in a text file
//
// Allowed inputs:
// - ESD + MC (MC is included automatically)
// - AOD
//
// All settings are specified as arguments in the main macro,
// which is at the end of this script.
//
void RunAnalysisPhi900GeV
(
Int_t nReadFiles = 2,
Int_t nSkipFiles = 0,
const char *dataType = "900GeV_pass4_sim",
const char *inputSource = "list.txt",
const char *outName1 = "Phi900GeV_all.root",
const char *outName2 = "Phi900GeV_true.root",
const char *outName3 = "Phi900GeV_info.root"
)
{
// convert the last argument into a BOOL variable
Bool_t isMC = kTRUE;
if (!strcmp(dataType, "900GeV_pass4_data")) isMC = kFALSE;
if (!strcmp(dataType, "7TeV_pass1_data")) isMC = kFALSE;
// message on aliroot version
cout << "*** ALIROOT PATH = " << gSystem->Getenv("ALICE_ROOT") << " ***" << endl;
cout << "*** MC " << (isMC ? "" : "NOT") << " INCLUDED ***" << endl;
// check extension of input to distinguish between XML and TXT
TString sInput(inputSource);
sInput.ToLower();
Bool_t isTXT = (!strcmp(sInput(sInput.Length() - 3, 3).Data(), "txt"));
cout << "Input = " << (isTXT ? "TXT" : "XML") << endl;
// load compiled libraries (for aliroot session)
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libPWG2resonances.so");
// if input is XML, connect to AliEn
if (!isTXT) TGrid::Connect("alien://");
// create analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("MyTaskManager");
// create handlers for input
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
// if required, create also MC handler
if (isMC)
{
AliMCEventHandler *mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
}
// add event selection for data
gROOT->LoadMacro("AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC);
// add task macro
AliRsnAnalysisPhi900GeV *task = new AliRsnAnalysisPhi900GeV("taskphi900gev");
task->SelectCollisionCandidates();
task->SetTPCparams(isMC);
task->SetMaxChi2(4.0);
task->SetMaxDCAr(0.5);
task->SetMaxDCAz(3.0);
task->SetMinNTPC(80);
task->SetUseMC(kFALSE);
if (!strcmp(dataType, "900GeV_pass4_data"))
{
task->SetTOFESD(kFALSE);
task->SetTOFSigma(130.0);
task->SetTOFSettings(AliTOFT0makerANA::kPass4);
}
if (!strcmp(dataType, "7TeV_pass1_data"))
{
task->SetTOFESD(kFALSE);
task->SetTOFSigma(130.0);
task->SetTOFSettings(AliTOFT0makerANA::kPass4);
}
else if (!strcmp(dataType, "900GeV_pass4_sim"))
{
task->SetTOFESD(kTRUE);
task->SetTOFSigma(130.0);
task->SetTOFSettings(AliTOFT0makerANA::kNone);
}
mgr->AddTask(task);
// create containers for input/output
AliAnalysisDataContainer *out1 = mgr->CreateContainer("tracks", TTree::Class(), AliAnalysisManager::kOutputContainer, outName1);
AliAnalysisDataContainer *out2 = mgr->CreateContainer("rsn" , TTree::Class(), AliAnalysisManager::kOutputContainer, outName2);
AliAnalysisDataContainer *out3 = mgr->CreateContainer("info" , TList::Class(), AliAnalysisManager::kOutputContainer, outName3);
mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, out1);
mgr->ConnectOutput(task, 2, out2);
mgr->ConnectOutput(task, 3, out3);
// create TChain of input events
TChain *analysisChain = 0x0;
if (isTXT) analysisChain = CreateChainFromText(inputSource, "esdTree", nReadFiles, nSkipFiles);
else analysisChain = CreateChainFromXML (inputSource, "esdTree", nReadFiles, nSkipFiles);
// start analysis
if (!analysisChain)
{
Error("runLocal", "Analysis chain not properly initialized");
return;
}
mgr->InitAnalysis();
mgr->PrintStatus();
if (isTXT) mgr->StartAnalysis("local", analysisChain);
else mgr->StartAnalysis("alien", analysisChain);
}
void runNorm(TString inputFileName = "AliAOD.root", Int_t nEvents = 1e6, TString beamConf = "p-Pb", Bool_t isESD = kFALSE, Bool_t isMC = kFALSE, Int_t debugLevel = 0)
{
TStopwatch timer;
timer.Start();
// Check runing mode
Int_t mode = GetMode(inputFileName);
if(mode < 0){
Error("runAnalysis","Please provide either an ESD/AOD root file or a collection of ESDs/AODs.");
return;
}
// Load common libraries
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
gSystem->Load("libSTEERBase");
// gSystem->Load("libSTEER");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libEventMixing");
gSystem->Load("libCORRFW");
gSystem->Load("libPWGmuon");
gSystem->Load("libPWGmuondep");
gSystem->AddIncludePath(Form("-I\"%s/include\" -I\"%s/include\"", gSystem->ExpandPathName("$ALICE_ROOT"),gSystem->ExpandPathName("$ALICE_PHYSICS")));
gROOT->ProcessLine(Form(".include %s/include %s/include", gSystem->ExpandPathName("$ALICE_ROOT"), gSystem->ExpandPathName("$ALICE_PHYSICS")));
// Create input chain
TChain* chain = CreateChain(inputFileName,isESD);
if (!chain) return;
// Create the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("MuonTask");
if ( isESD) {
// ESD input handler
AliESDInputHandler* esdH = new AliESDInputHandler();
esdH->SetReadFriends(kFALSE);
mgr->SetInputEventHandler(esdH);
}
else {
// AOD input handler
AliAODInputHandler* aodH = new AliAODInputHandler();
mgr->SetInputEventHandler(aodH);
}
TString dataType = mgr->GetInputEventHandler()->GetDataType();
Info("runLocal",Form("Manager with %s",dataType.Data()));
// Enable MC event handler for ESDs
if ( isMC && isESD ){
AliVEventHandler* handler = new AliMCEventHandler;
mgr->SetMCtruthEventHandler(handler);
}
// event selection and centrality framework
if ( isESD ){
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physicsSelection = AddTaskPhysicsSelection(isMC);
if ( !physicsSelection ) {
Error("runLocal","AliPhysicsSelectionTask not created!");
return;
}
}
if ( isESD ){
// event centrality
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
if ( !taskCentrality ) {
Error("runLocal on ESD","AliCentralitySelectionTask not created!");
return;
}
if ( isMC ) taskCentrality->SetMCInput();
//taskCentrality->SetPass(1); // remember to set the pass you are processing!!!
}
/*else {
//Only on full AOD, it is possible to reprocess the centrality framework
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(kTRUE,kTRUE);
if ( !taskCentrality ) {
Error("runLocal on AOD","AliCentralitySelectionTask not created!");
return;
}
if ( isMC ) taskCentrality->SetMCInput();
}*/
// Example analysis
// Create task
//Analysis task is on working directory
// gROOT->LoadMacro("AliAnalysisTaskNorm.cxx+g");
// gROOT->LoadMacro("AddTaskNorm.C");
gROOT->LoadMacro("$ALICE_PHYSICS/../src/PWG/muon/AliAnalysisTaskNorm.cxx+g");
gROOT->LoadMacro("$ALICE_PHYSICS/../src/PWG/muon/AddTaskNorm.C");
AliAnalysisTaskNorm* task = AddTaskNorm(isESD,isMC,beamConf);
if (!task) {
Error("runAnalysis","AliAnalysisTaskNorm not created!");
return;
}
task->SetDebugLevel(debugLevel);
// Enable debug printouts
mgr->SetDebugLevel(debugLevel);
// start local analysis
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
if(debugLevel>=2) mgr->SetNSysInfo(100);
mgr->StartAnalysis("local", chain, nEvents);
}
if(debugLevel>=2){
mgr->ProfileTask("Task");
}
timer.Stop();
timer.Print();
}
//______________________________________________________________________________
void AddAnalysisTasks(const char *cdb_location)
{
// Add all analysis task wagons to the train
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
//
// Tender and supplies. Needs to be called for every event.
//
AliAnalysisManager::SetCommonFileName("AODQA.root");
if (useTender) {
gROOT->LoadMacro("$ALICE_PHYSICS/ANALYSIS/TenderSupplies/AddTaskTender.C");
// IF V0 tender needed, put kTRUE below
AliAnalysisTaskSE *tender = AddTaskTender(useV0tender);
// tender->SetDebugLevel(2);
}
// Clean Geometry: Ruben
// gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/CalibMacros/commonMacros/CleanGeom.C++");
// CleanGeom* clgmTask = new CleanGeom("cleanGeom");
// mgr->AddTask(clgmTask);
// AliAnalysisDataContainer *dummyInp = mgr->GetCommonInputContainer();
// if (dummyInp) mgr->ConnectInput(clgmTask,0,dummyInp);
//
// PIDResponse(JENS)
//
if (doPIDResponse) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
// PIDResponse->SetUserDataRecoPass(1);
// PIDResponse->SelectCollisionCandidates(AliVEvent::kAny);
}
//
// PIDqa(JENS)
//
if (doPIDqa) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
PIDQA->SelectCollisionCandidates(AliVEvent::kAny);
}
// CDB connection
//
if (doCDBconnect && !useTender) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C");
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, 0 /*run_number*/);
if (!taskCDB) return;
AliCDBManager *cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage(cdb_location);
// taskCDB->SetRunNumber(run_number);
}
if (usePhysicsSelection) {
// Physics selection task
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
mgr->RegisterExtraFile("event_stat.root");
AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(useMC);
mgr->AddStatisticsTask(AliVEvent::kAny);
}
//Jacek
if (iPWGPP) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFilteredTree.C");
AddTaskFilteredTree("FilterEvents_Trees.root");
}
// Centrality
if (useCentrality) {
if ( run_flag >= 1500 )
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
AliMultSelectionTask *taskMult = AddTaskMultSelection();
}
else
{
// old scheme is only valid for PbPb
if ( iCollision == kPbPb )
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
//taskCentrality->SelectCollisionCandidates(AliVEvent::kAny);
}
}
}
// --- PWGLF - Forward ([email protected]) -----------------------------
if (iPWGLFForward && usePhysicsSelection) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskForwardMult.C");
UShort_t pwglfForwardSys = 0; // iCollision+1; // pp:1, PbPb:2, pPb:3
UShort_t pwglfSNN = 0; // GeV, 0==unknown
Short_t pwglfField = 0;
AddTaskForwardMult(useMC && useTR, // Need track-refs
pwglfForwardSys, // Collision system
pwglfSNN,
pwglfField);
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskCentralMult.C");
AddTaskCentralMult(useMC, pwglfForwardSys, pwglfSNN, pwglfField);
}
//PWGAgammaconv
if (iPWGGAgammaconv) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/GammaConv/macros/AddTask_ConversionAODProduction.C");
Int_t dataset=iCollision;
if( iCollision == kXeXe) dataset=kPbPb;
if( iCollision == kPbp || iCollision == kpPb ) dataset=2;
AliAnalysisTask *taskconv = AddTask_ConversionAODProduction(dataset, kFALSE, periodName);
mgr->RegisterExtraFile("AliAODGammaConversion.root");
}
if (iESDfilter)
{
// ESD filter task configuration.
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/ESDfilter/macros/AddTaskESDFilter.C");
if (iMUONcopyAOD) {
printf("Registering delta AOD file\n");
mgr->RegisterExtraFile("AliAOD.Muons.root");
}
Bool_t muonWithSPDTracklets = (iCollision==kPbPb || iCollision==kXeXe) ? kFALSE : kTRUE; // add SPD information to muon AOD only for pp
AliAnalysisTaskESDfilter *taskesdfilter =
AddTaskESDFilter(useKFILTER,
iMUONcopyAOD, // write Muon AOD
kFALSE, // write dimuon AOD
kFALSE, // usePhysicsSelection
kFALSE, // centrality OBSOLETE
kTRUE, // enable TPS only tracks
kFALSE, // disable cascades
kFALSE, // disable kinks
run_flag, // run flag (YY00)
3, // muonMCMode
//kTRUE, // useV0Filter
kFALSE, // useV0Filter - turned off for PCM to make sense
muonWithSPDTracklets,
isMuonCaloPass,
iPWGGAgammaconv); // Add PCMV0
AliEMCALGeometry::GetInstance("","");
}
// ********** PWG3 wagons ******************************************************
// PWGHF vertexing
if (iPWGHFvertexing)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C");
Int_t configHF=0;
if(iCollision == kPbPb || iCollision == kXeXe) configHF=1;
AliAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF(configHF,train_name,"",run_number,periodName);
// Now we need to keep in sync with the ESD filter
if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "AliAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("AliAOD.VertexingHF.root");
taskvertexingHF->SelectCollisionCandidates(0);
}
// PWGDQ JPSI filtering (only pp)
if (iPWGDQJPSIfilter && (iCollision==kpp)) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C");
AliAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter();
if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "AliAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED");
else mgr->RegisterExtraFile("AliAOD.Dielectron.root");
taskJPSIfilter->SelectCollisionCandidates(0);
}
// PWGHF D2h
if (iPWGHFd2h)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/vertexingHF/AddD2HTrain.C");
AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0);
}
// ********** PWG4 wagons ******************************************************
// Jet analysis
// Configurations flags, move up?
TString kDeltaAODJetName = "AliAOD.Jets.root"; //
Bool_t kIsPbPb = (iCollision==kPbPb || iCollision==kXeXe);
TString kDefaultJetBackgroundBranch = "";
TString kJetSubtractBranches = "";
UInt_t kHighPtFilterMask = 272;// from esd filter
UInt_t iPhysicsSelectionFlag = 0;
if (iJETAN) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJets.C");
// Default jet reconstructor running on ESD's
AliAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
if (!taskjets) ::Fatal("AnalysisTrainNew", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
if (iJETANdelta) {
// AddTaskJetsDelta("AliAOD.Jets.root"); // need to modify this accordingly in the add task jets
mgr->RegisterExtraFile(kDeltaAODJetName.Data());
TString cTmp("");
if(kIsPbPb){
// UA1 intrinsic background subtraction
taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
// SICONE
taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later....
if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
cTmp = taskjets->GetNonStdBranch();
if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
// Add the clusters..
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJetCluster.C");
AliAnalysisTaskJetCluster *taskCl = 0;
Float_t fCenUp = 0;
Float_t fCenLo = 0;
Float_t fTrackEtaWindow = 0.9;
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
taskCl->SetBackgroundCalc(kTRUE);
taskCl->SetNRandomCones(10);
taskCl->SetCentralityCut(fCenLo,fCenUp);
taskCl->SetGhostEtamax(fTrackEtaWindow);
kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
taskCl->SetNRandomCones(10);
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
taskCl->SetCentralityCut(fCenLo,fCenUp);
if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
// DO THE BACKGROUND SUBTRACTION
if(kIsPbPb&&kJetSubtractBranches.Length()){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJetBackgroundSubtract.C");
AliAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d");
taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
}
}
}
}
TString Setup
(
Int_t nmix,
const char *options,
const char *outputFileName,
const char *macroPath = "."
)
{
// prepare output
TString out("");
//
// === EXAMINE OPTIONS ==========================================================================
//
// this is done using the utility 'RsnOptions.C'
// which provides a unique way to interpret them
TString opt(options);
opt.ToUpper();
Bool_t isMC = opt.Contains("MC") || (!opt.Contains("DATA"));
Bool_t isPP = opt.Contains("PP") || (!opt.Contains("PBPB"));
Bool_t isESD = opt.Contains("ESD");
Bool_t useTender = opt.Contains("Tender");
Bool_t noV0 = opt.Contains("NOV0");
//
// === LOAD LIBRARIES ===========================================================================
//
// load analysis libraries
gSystem->Load("libCore");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libMinuit");
gSystem->Load("libPhysics");
gSystem->Load("libTree");
gSystem->Load("libSTEERBase");
gSystem->Load("libESD");
gSystem->Load("libAOD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libEventMixing");
gSystem->Load("libCORRFW");
gSystem->Load("libPWGLFresonances");
// tender-related libraries
if (isESD && useTender) {
::Info("AnalysisSetup", "Loading tender libraries");
gSystem->Load("libTender");
gSystem->Load("libTenderSupplies");
} else if (!isESD) {
useTender = kFALSE;
}
// load development RSN library
if (!AliAnalysisAlien::SetupPar("PWGLFresonances.par")) return "";
//
// === CREATE ANALYSIS MANAGER ==================================================================
//
AliAnalysisManager *mgr = new AliAnalysisManager("RsnAnalysisManager");
mgr->SetCommonFileName(outputFileName);
::Info("AnalysisSetup", "Common file name: %s", outputFileName);
//
// === INPUT / OUTPUT HANDLER CONFIGURATION =====================================================
//
if (isESD) {
out = "esdTree";
::Info("AnalysisSetup", "Creating ESD handler");
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
if (isMC) {
::Info("AnalysisSetup", "Creating MC handler");
AliMCEventHandler *mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
}
} else {
out = "aodTree";
::Info("AnalysisSetup", "Creating AOD handler");
AliAODInputHandler *aodHandler = new AliAODInputHandler();
mgr->SetInputEventHandler(aodHandler);
}
//
// === Tender TASK (ESD only -- optional) =======================================================
//
if (isESD && useTender) {
::Info("AnalysisSetup", "Adding tender (and then accepting V0 info)", options);
gROOT->LoadMacro(Form("%s/AddTaskTender.C", macroPath));
AddTaskTender();
noV0 = kFALSE;
}
//
// === PHYSICS SELECTION (ESD only) =============================================================
//
if (isESD) {
::Info("AnalysisSetup", "Add physics selection by default on ESD analysis");
gROOT->LoadMacro("$(ALICE_PHYSICS)/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC);
if (noV0) {
::Info("AnalysisSetup", "Skip of V0 info is required");
physSelTask->GetPhysicsSelection()->SetSkipV0(kTRUE);
}
}
//
// === CENTRALITY/PLANE (ESD only) ==============================================================
//
if (isESD && !isPP) {
::Info("AnalysisSetup", "Add centrality and event plane computation tasks");
gROOT->LoadMacro("$(ALICE_PHYSICS)/OADB/macros/AddTaskCentrality.C");
gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskEventplane.C");
AliCentralitySelectionTask* taskCentrality = (AliCentralitySelectionTask*)AddTaskCentrality();
if (isMC) {
::Info("AnalysisSetup", "Setting centrality computation for MC");
taskCentrality->SetMCInput();
}
AddTaskEventplane();
}
//
// === PID RESPONSE =============================================================================
//
gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskPIDResponse.C");
AddTaskPIDResponse(isMC,kTRUE,kTRUE);
//gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskPIDqa.C ");
//AddTaskPIDqa();
//
// === OTHER TASKS ==============================================================================
//
// add RSN task
gROOT->LoadMacro(Form("%s/AddTaskLStarPPb.C", macroPath));
if (!AddTaskLStarPPb(isMC, isPP, macroPath, nmix)) return "";
::Info("AnalysisSetup", "Setup successful");
return out;
}
void AddAnalysisTasks(const char *cdb_location)
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
mgr->SetCommonFileName("QAresults.root");
// Statistics task
mgr->AddStatisticsTask(kTriggerMask);
//
// CDB connection
//
if (doCDBconnect) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C");
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, run_number);
if (!taskCDB) return;
}
//
// Event Statistics (Jan Fiete)
//
if (doEventStat) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kTRUE /*MC*/);
}
//
// PIDResponse(JENS)
//
if (doPIDResponse) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse(kTRUE);
PIDResponse->SelectCollisionCandidates(kTriggerMask);
}
//
// Centrality (A. Toia)
//
if (doCentrality)
{
if(run_flag >= 1500)
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
AliMultSelectionTask *taskMult = AddTaskMultSelection();
taskMult->SetAlternateOADBforEstimators(periodName);
}
else
// old scheme is only valid for PbPb
if (iCollisionType == kPbPb)
{
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
taskCentrality->SetMCInput();
}
}
// Vertexing (A. Dainese)
//
if (doVertex) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskVertexESD.C");
// Specific setting for MC
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kTRUE, kTriggerMask);
taskvertexesd->SelectCollisionCandidates(kTriggerMask);
}
// TPC QA (E. Sicking)
//
if (doQAsym) {
// offline trigger in AddTask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
}
//
// VZERO QA (C. Cheshkov)
//
if (doVZERO) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
if (doVZEROPbPb) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/VZERO/AddTaskVZEROPbPb.C");
AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(run_number);
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-");
// taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
}
//
// TPC (Jacek Otwinowski & Michael Knichel)
//
//
// Optionally MC information can be used by setting the 1st argument to true
// Optionally friends information can be switched off by setting the 2st argument
// to false
// Optionally highMult axis can be used by setting the 3st argument to true (for PbPb)
if (doTPC) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
AliPerformanceTask *tpcQA = 0;
if (iCollisionType==kPbPb || iCollisionType == kXeXe) {
// High multiplicity Pb-Pb
tpcQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kTRUE);
} else {
// Low multiplicity (pp)
tpcQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kFALSE);
}
tpcQA->SelectCollisionCandidates(kTriggerMask);
AliPerformanceRes::SetMergeEntriesCut(5000000);
}
// HLT (Alberica Toia)
if (doHLT) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
AliPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kFALSE,0,kTRUE);
hltQA->SelectCollisionCandidates(kTriggerMask);
}
//
// SPD (A. Mastroserio)
//
if (doSPD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSPD* taskspdqa = (AliAnalysisTaskSPD*)AddTaskSPDQA();
// Request from Annalisa
if (iCollisionType==kPbPb || iCollisionType == kXeXe) taskspdqa->SetHeavyIonMode();
taskspdqa->SelectCollisionCandidates(kTriggerMask);
taskspdqa->SetOCDBInfo(run_number, "raw://");
}
//
// SDD (F. Prino)
//
if (doSDD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates(kTriggerMask);
}
//
// SSD dEdx (Marek Chojnacki)
//
if (doSSDdEdx) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates(kTriggerMask);
}
//
// ITS
//
if (doITS) {
// hardcoded non-zero trigger mask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent0010 = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent3050 = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent6080 = 0;
itsQA = AddTaskPerformanceITS(kTRUE);
if(iCollisionType==kPbPb) {
itsQACent0010 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,3500,10000);
itsQACent3050 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,590,1570);
itsQACent6080 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,70,310);
}
else if(iCollisionType==kXeXe) {
itsQACent0010 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,2000,6000);
itsQACent3050 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,350,1000);
itsQACent6080 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,40,200);
}
}
//
// ITS saTracks, align (F.Prino)
//
if (doITSsaTracks) {
// offline trigger in AddTask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskITSsaTracks.C");
AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kTRUE,kFALSE);
itssaTracks->SelectCollisionCandidates(kTriggerMask);
}
if (doITSalign) {
// no offline trigger selection
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskITSAlign.C");
AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
}
//
// Global tracks + V0s QA
//
if(doESDTracks) {
// protection for bug fixed in v5-09-14
Bool_t disable=kTRUE;
if(gSystem->Getenv("ALIEN_JDL_PACKAGES")){
TString packg=gSystem->Getenv("ALIEN_JDL_PACKAGES");
TObjArray* pkgs=packg.Tokenize("##");
Int_t np=pkgs->GetEntries();
Int_t ver,n1,n2;
Char_t str2[20];
for(Int_t i=0; i<np; i++){
TObjString* str=(TObjString*)pkgs->At(i);
TString s=str->GetString();
if(s.Contains("AliPhysics")){
s.ReplaceAll("VO_ALICE@","");
sscanf(s.Data(),"AliPhysics::v%d-%d-%d-%s",&ver,&n1,&n2,str2);
if(ver>=5 && n1>=9 && n2>=14){
printf("%s -> enable ESD track QA\n",s.Data());
disable=kFALSE;
}else{
disable=kTRUE;
printf("%s -> disable ESD track QA\n",s.Data());
}
}
}
}
if(!disable){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckESDTracks.C");
AliAnalysisTaskCheckESDTracks* taskestr=AddTaskCheckESDTracks("QA",kFALSE,kTRUE,kTRUE);
taskestr->SetPtBinning(160,0.,40.);
taskestr->SelectCollisionCandidates(kTriggerMask);
}
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(doTRD) {
// no offline trigger selection
// steer individual TRD tasks
Bool_t
doCheckESD(kTRUE), // AliTRDcheckESD
doCheckDET(kTRUE), // AliTRDcheckDET
doEffic(kTRUE), // AliTRDefficiency
doResolution(kTRUE),// AliTRDresolution
doCheckPID(kFALSE), // AliTRDcheckPID
doV0Monitor(kFALSE);// AliTRDv0Monitor
AliTRDpwgppHelper::AddTrainPerformanceTRD(AliTRDpwgppHelper::Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
// no offline trigger selection
// gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTrainPerformanceTRD.C");
// steer individual TRD tasks
// Bool_t
// doCheckESD(kTRUE), // AliTRDcheckESD
// doCheckDET(kTRUE), // AliTRDcheckDET
// doEffic(kTRUE), // AliTRDefficiency
// doResolution(kTRUE),// AliTRDresolution
// doCheckPID(kFALSE), // AliTRDcheckPID
// doV0Monitor(kFALSE);// AliTRDv0Monitor
// AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor));
}
//
// ZDC (Chiara Oppedisano)
//
if(doZDC) {
// hardcoded kMB trigger mask
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/ZDC/AddTaskZDCQA.C");
AliAnalysisTaskSE *taskZDC = AddTaskZDCQA();
taskZDC->SelectCollisionCandidates(kTriggerMask);
}
//
// Calorimetry (Gustavo Conesa)
//
if(doCALO) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("default");
taskCaloQA->SetDebugLevel(0);
taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetEMCALGeometryName("EMCAL_COMPLETE12SMV1_DCAL_8SM");
taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetImportGeometryFromFile(kFALSE);
taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetNumberOfSuperModulesUsed(20);
AliAnaCalorimeterQA * caloqa = (AliAnaCalorimeterQA*) taskCaloQA->GetAnalysisMaker()->GetListOfAnalysisContainers()->At(0);
AliHistogramRanges* histoRanges = caloqa->GetHistogramRanges();
histoRanges->SetHistoPhiRangeAndNBins(77*TMath::DegToRad(), 330*TMath::DegToRad(), 253) ;
// offline mask set in AddTask to kMB
// taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
// taskCaloQA = AddTaskCalorimeterQA("trigEMC");
// taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
// AliAnalysisTaskCaloTrackCorrelation*taskCaloQA= AddTaskCalorimeterQA("ESD", 2012, kFALSE, kTRUE);
// taskCaloQA->SetDebugLevel(0);
// offline mask set in AddTask to kMB
// taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
// taskCaloQA= AddTaskCalorimeterQA("ESD", 2012, kFALSE, kTRUE, "", "EMC7");
// taskCaloQA->SetDebugLevel(0);
// taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
// AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kTRUE);
// taskCaloQA->SetDebugLevel(0);
// offline mask set in AddTask to kMB
// taskCaloQA->SelectCollisionCandidates(kTriggerMask);
// Add a new calo task with EMC1 trigger only
// taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kTRUE, "", "EMC7");
// taskCaloQA->SetDebugLevel(0);
// taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
}
//
// Muon Trigger
//
if(doMUONTrig) {
// no offline trigger selection
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency(kTRUE);
}
//
// Muon Efficiency (not used)
//
if(doMUONEff)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff *muonEfficiency = AddTaskMUONTrackingEfficiency(kTRUE,kTRUE,"");
if (!isMuonOnly) muonEfficiency->SelectCollisionCandidates(kTriggerMask);
muonEfficiency->UseMCLabel(kTRUE);
}
//
// Muon Performance (Philippe Pillot)
//
//
if (doMUONPerf)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMuonPerformance.C");
AliAnalysisTaskMuonPerformance* muonPerformance = AddTaskMuonPerformance();
if (!isMuonOnly) muonPerformance->SelectCollisionCandidates(kTriggerMask);
muonPerformance->UseMCKinematics(kTRUE);
muonPerformance->SetMCTrigLevelFromMatchTrk(kTRUE);
}
//
// V0-Decay Reconstruction (Ana Marin) (not used)
//
if (doV0) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kTRUE);
}
//
// Impact parameter resolution ([email protected], [email protected])
//
if (doImpParRes) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskImpParRes.C");
AliAnalysisTaskSE* taskimpparres=0;
// Specific setting for MC
if(iCollisionType==kpp || iCollisionType==kpPb || iCollisionType==kPbp) {
taskimpparres= AddTaskImpParRes(kTRUE);
} else {
taskimpparres= AddTaskImpParRes(kTRUE,-1,kTRUE,kFALSE);
}
taskimpparres->SelectCollisionCandidates(kTriggerMask);
}
//
// MUON QA (Philippe Pillot)
//
if (doMUON) {
// trigger analysis internal
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskMuonQA.C");
AliAnalysisTaskMuonQA* taskmuonqa = AddTaskMuonQA(kFALSE);
taskmuonqa->GetTrackCuts()->SetIsMC(kTRUE);
}
//
// TOF (Francesca Bellini)
//
if (doTOF) {
// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
// AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA(kFALSE);
// tofQA->SelectCollisionCandidates(kTriggerMask);
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TOF/AddTaskTOFqaID.C");
AliAnalysisTaskTOFqaID *tofQA = AddTaskTOFqaID(kFALSE, AliVEvent::kAnyINT, 0, kFALSE, "", kTRUE, 0);
// tofQA->SelectCollisionCandidates(kTriggerMask);
}
//
// PIDqa(JENS)
//
if (doPIDqa) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
PIDQA->SelectCollisionCandidates(kTriggerMask);
}
//
// HMPID QA (Giacomo Volpe)
//
if (doHMPID) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/HMPID/AddTaskHmpidQA.C");
AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kTRUE);
// offline mask set in AddTask to kMB
taskhmpidqa->SelectCollisionCandidates(kTriggerMask);
}
// T0 QA (Alla Mayevskaya)
if (doT0) {
// no offline trigger selection
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/T0/AddTaskT0QA.C");
AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
taskt0qa->SelectCollisionCandidates(kTriggerMask);
}
// FMD QA (Christian Holm Christiansen)
if (doFMD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C");
// Parameters: usemc, usecentrality
AliAnalysisTaskSE *forwardQA = (AliAnalysisTaskSE *)AddTaskForwardQA(kTRUE, (Bool_t)doCentrality);
// No offline trigger config. needed (see #84077)
}
//
// PHOS QA (Boris Polishchuk)
//
if (doPHOS) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C");
//AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt");
AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(5, 1, NULL,"PHOSCellsQA_AnyInt");
taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask);
taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
//AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7");
AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(5, 1, NULL,"PHOSCellsQA_PHI7");
taskPHOSCellQA2->SelectCollisionCandidates(AliVEvent::kPHI7);
taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
// Pi0 QA fo PbPb
if (iCollisionType == kPbPb || iCollisionType == kXeXe) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C");
AliAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0);
}
}
if (doPHOSTrig) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_TriggerQA/macros/AddTaskPHOSTriggerQA.C");
AliAnalysisTaskPHOSTriggerQA *taskPHOSTrig = AddTaskPHOSTriggerQA(NULL);
}
//
// EMCAL QA (Gustavo Conesa)
//
if (doEMCAL) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C");
AliAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA();
}
//
// EvTrk QA (Zaida)
//
if (doEvTrk) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EvTrkSelection/AddSingleTrackEfficiencyTaskForAutomaticQA.C");
AliAnalysisTask *task = AddSingleTrackEfficiencyTaskForAutomaticQA();
}
//
// AD QA (Michal Broz))
//
if (doAD) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/AD/AddTaskADQA.C");
AliAnalysisTaskADQA *task = AddTaskADQA();
}
//
// FLOW and BF QA (C.Perez && A.Rodriguez)
//
if (doFBFqa) {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFBFqa.C");
AliAnalysisTaskSE *qaFBFMB = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE);
qaFBFMB->SelectCollisionCandidates(AliVEvent::kMB);
AliAnalysisTaskSE *qaFBFSC = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFsc",kFALSE);
qaFBFSC->SelectCollisionCandidates(AliVEvent::kSemiCentral);
AliAnalysisTaskSE *qaFBFCE = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE);
qaFBFCE->SelectCollisionCandidates(AliVEvent::kCentral);
}
}
//______________________________________________________________________________
void AddAnalysisTasks(UInt_t config)
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
mgr->SetCommonFileName("QAresults.root");
//
// Event Statistics (Jan Fiete)
//
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
mgr->RegisterExtraFile("event_stat.root");
//
// Tender and supplies
//
if (config & kTender) {
gROOT->LoadMacro("$ALICE_ROOT/TENDER/TenderSupplies/AddTaskTender.C");
AliAnalysisTaskSE *tender = AddTaskTender();
// SelectCollisionCandidates ?? Tender has to derive from TaskSE
tender->SelectCollisionCandidates();
tender->SetDebugLevel(2);
}
// AOD creation with collision events
if (config & kAOD) {
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
mgr->RegisterExtraFile("AliAOD.Muons.root");
mgr->RegisterExtraFile("AliAOD.Dimuons.root");
AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kFALSE, kTRUE, kTRUE, doEventStat);
}
// TPC QA (E. Sicking)
//
if (config & kCar00) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0);
taskqasim->SelectCollisionCandidates();
}
//
// VZERO QA (C. Cheshkov)
//
if (config & kCar01) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
// Vertexing (A. Dainese)
//
if (config & kCar02) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD();
taskvertexesd->SelectCollisionCandidates();
}
//
// SPD (A. Mastroserio)
//
if (config & kCar03) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSE* taskspdqa = AddTaskSPDQA();
taskspdqa->SelectCollisionCandidates();
}
//
// SDD (F. Prino)
//
if (config & kCar04) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates();
}
//
// SSD dEdx (Marek Chojnacki)
//
if (config & kCar05) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates();
}
// FMD (Hans Hjersing Dalsgaard)
//
if (config & kCar06) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskFMD.C");
AliAnalysisTaskSE* taskfmd = AddTaskFMD();
taskfmd->SelectCollisionCandidates();
}
//
// ITS
//
if (config & kCar07) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(kFALSE);
}
//
// TPC (Jacek Otwinowski)
//
if (config & kCar08) {
gROOT->LoadMacro("$(ALICE_ROOT)/PWGPP/TPC/macros/AddTaskPerformanceTPCQA.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPCQA(kFALSE, kTRUE);
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(config & kCar09) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
AddTrainPerformanceTRD("ALL");
}
//
// Calorimetry (Gustavo Conesa)
//
if(config & kCar10) {
gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/QA/AddTaskCalorimeterQA.C");
AliAnalysisTaskParticleCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", kTRUE, kFALSE);
taskCaloQA->SetDebugLevel(0);
}
//
// Muon Trigger
//
if(config & kCar11) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
//
// Muon Efficiency
//
/*
if(doMUONEff) {
gROOT->LoadMacro("$ALICE_ROOT/PWG3/muondep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff *taskMuonTrackEff = AddTaskMUONTrackingEfficiency();
}
//
// V0-Decay Reconstruction (Ana Marin)
//
if (doV0) {
gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kFALSE);
}
*/
}
void Embedding(const char* dataset="collection.xml")
{
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
//load analysis framework
gSystem->Load("libSTEERBase");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_ROOT/PHOS");
// A task can be compiled dynamically with AClic
gROOT->LoadMacro("AliPHOSEmbedding.cxx+g");
// Connect to alien
TString token = gSystem->Getenv("GRID_TOKEN") ;
if (1) // token == "OK" )
TGrid::Connect("alien://");
else
AliInfo("You are not connected to the GRID") ;
cout << "Pi0Analysis: processing collection " << dataset << endl;
// Create the chain
TChain* chain = new TChain("esdTree");
TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset));
TAlienResult* result = collection->GetGridResult("",0 ,0);
TList* rawFileList = result->GetFileInfoList();
for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) {
TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(counter)) ;
const char * rawFile = fi->GetCurrentUrl()->GetUrl() ;
printf("Processing %s\n", rawFile) ;
chain->Add(rawFile);
printf("Chain: %d entries.\n",chain->GetEntries());
}
TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(0));
const char * fn = fi->GetCurrentUrl()->GetUrl() ;
char runNum[7];
for(Int_t i=0;i<6;i++)runNum[i]=fn[35+i] ;
runNum[6]=0 ;
Int_t iRunNum=atoi(runNum) ;
printf("Run number=%d \n",iRunNum) ;
//Run AOD simulation
int nrun = atoi(runNum);
int nevent = 0;
int seed = 0;
char sseed[1024];
char sevent[1024];
char sprocess[1024];
char sfield[1024];
char senergy[1024];
sprintf(sevent,"");
sprintf(sprocess,"");
sprintf(sfield,"");
sprintf(senergy,"");
seed = 0;
sprintf(sseed,"%d",seed);
if (seed==0) {
fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr,"!!!! WARNING! Seeding variable for MC is 0 !!!!\n");
fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
} else {
fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stdout,"!!! MC Seed is %d \n",seed);
fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
}
// set the seed environment variable
gSystem->Setenv("CONFIG_SEED",sseed);
gSystem->Setenv("CONFIG_RUN_TYPE","kPythia6"); // kPythia6 or kPhojet^M
gSystem->Setenv("CONFIG_FIELD","k5kG"); // kNoField or k5kG^M
gSystem->Setenv("CONFIG_ENERGY","2760"); // 900 or 10000 (GeV)
gSystem->Setenv("DC_RUN",runNum); //run number
char nSimEvents[55] ;
sprintf(nSimEvents,"%d",chain->GetEntries());
gSystem->Setenv("SIM_EVENTS",nSimEvents);
gSystem->Exec("mv geometry.root geometry_PHOS.root") ;
gSystem->Exec("aliroot -b -q simrun.C > simrun.log 2>&1");
gSystem->Exec("mv geometry_PHOS.root geometry.root") ;
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("Pi0EmbeddingManager");
// ESD input handler
AliESDInputHandler* esdH = new AliESDInputHandler();
esdH->SetReadFriends(kFALSE);
mgr->SetInputEventHandler(esdH);
// Output
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName("AliAODout.root");
mgr->SetOutputEventHandler(aodHandler);
// Debug level
mgr->SetDebugLevel(0);
// Add physics selection
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE);
gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality() ;
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
AliEPSelectionTask *taskEP = AddTaskEventplane() ;
// Add my task
AliPHOSEmbedding *task1 = new AliPHOSEmbedding("Embedding");
TChain* chainAOD = new TChain("aodTree");
chainAOD->AddFile("AliAOD.root") ;
task1->SetSignalChain(chainAOD) ;
task1->SelectCollisionCandidates();
TFile *fOldCalib = TFile::Open("OldCalibration.root");
if(fOldCalib->IsOpen()){
printf("\n\n...Adding PHOS calibration used in ESD production \n") ;
char key[55] ;
TH2F * hCalib[5] ;
for(Int_t mod=0;mod<5; mod++){
sprintf(key,"calibrationMod%d",mod) ;
hCalib[mod] = (TH2F*)fOldCalib->Get(key) ;
}
task1->SetOldCalibration(hCalib) ;
fOldCalib->Close() ;
}
mgr->AddTask(task1);
// Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("output0",
TTree::Class(), AliAnalysisManager::kOutputContainer);
// Connect input/output
mgr->ConnectInput(task1 , 0, cinput);
mgr->ConnectOutput(task1, 0,coutput1);
AliLog::SetClassDebugLevel("AliGeomManager", 10) ;
AliCDBManager::Instance()->SetRun(iRunNum) ;
// AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB") ;
// AliCDBManager::Instance()->SetDefaultStorage("raw://") ;
AliCDBManager::Instance()->SetDefaultStorage("alien://folder=/alice/data/2010/OCDB") ;
AliCDBManager::Instance()->SetSpecificStorage("PHOS/*/*",
"local://OCDB");
printf("RunNunm===%d \n",iRunNum) ;
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
if(iRunNum<=137848){ //period 1
gSystem->Exec("mv BadMap_LHC10h_period1.root BadMap_LHC10h.root") ;
}
else{
gSystem->Exec("mv BadMap_LHC10h_period234.root BadMap_LHC10h.root") ;
}
gSystem->Exec("aliroot -b -q AnalyzeDiff.C> analyze3.log 2>&1");
}
void runGridDeuteronTree(TString mode="terminate", TString fname="DeuteronTreeTest")
{
AliLog::SetGlobalDebugLevel(5);
//__________________________________________________________________________
// Use AliRoot includes to compile our task
gROOT->ProcessLine(".include $ALICE_ROOT/include");
gROOT->ProcessLine(".include $ALICE_PHYSICS/include");
gSystem->Load("libPWGTools.so");
gSystem->Load("libPWGLFnuclex.so");
// Create and configure the alien handler plugin
AliAnalysisGrid *alienHandler = CreateAlienHandler(mode,fname);
if (!alienHandler) return;
// Create the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("testAnalysis");
// Connect plug-in to the analysis manager
mgr->SetGridHandler(alienHandler);
AliESDInputHandler* esdH = new AliESDInputHandler();
mgr->SetInputEventHandler(esdH);
Bool_t mc = kFALSE;
//if(sub == 2)
//mc = kTRUE;
// Add PIDResponse task
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse *taskPID=AddTaskPIDResponse(mc,kTRUE,kTRUE);
// Add Physics Selec
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
// Add centrality
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
//taskCentrality->SetPass(2); // Change if changing pass
// Add AliPPVsMultUtils task
// AliAnalysisUtils* utils = new AliAnalysisUtils();
// add DPhiCorrelations task from $ALICE_PHYSICS/../src/PWGCF/Correlations/DPhi/AliAnalysisTaskPhiCorrelations[.cxx .h]
//gROOT->LoadMacro("AliAnalysisTaskPhiCorrelations.cxx+g");
gROOT->LoadMacro("$ALICE_PHYSICS/../src/PWGLF/NUCLEX/Nuclei/DeuteronpA/macros/AddTaskDeuteronTree.C");
AliAnalysisDeuteronTree *taskDeuteronTree = AddTaskDeuteronTree("DeuteronTreeTest");
taskDeuteronTree->SelectCollisionCandidates(AliVEvent::kINT7);
//mgr->SetDebugLevel(5);
if (!mgr->InitAnalysis())
return;
mgr->PrintStatus();
// Start analysis in grid.
mgr->StartAnalysis("grid",100);
// local analysis
//TChain *chain = new TChain("aodTree");
//chain->AddFile("./traintest/__alice__data__2010__LHC10d__000126158__ESDs__pass2__AOD147_root_archive_AliAOD_2/0002/root_archive/AliAOD.root");
//mgr->StartAnalysis("local",chain);
}
//________________________________________________________________
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 runFlowTaskCentralityKinkTrain( Int_t mode = mLocal,
Bool_t useFlowParFiles = kFALSE,
Bool_t DATA = kTRUE,
const Char_t* dataDir="fileList",
Int_t nEvents = 1e4,
Int_t offset=0 )
{
// Time:
TStopwatch timer;
timer.Start();
// Load needed libraries:
LoadLibraries(mode,useFlowParFiles);
// Create analysis manager:
AliAnalysisManager *mgr = new AliAnalysisManager("FlowAnalysisManager");
// Chains:
if(mode == mLocal)
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWGUD/macros/CreateESDChain.C");
TChain* chain = CreateESDChain(dataDir, nEvents, offset);
//TChain* chain = CreateAODChain(dataDir, nEvents, offset);
}
// Connect plug-in to the analysis manager:
if(mode == mGrid)
{
gROOT->LoadMacro("CreateAlienHandler.C");
AliAnalysisGrid *alienHandler = CreateAlienHandler(useFlowParFiles);
if(!alienHandler) return;
mgr->SetGridHandler(alienHandler);
}
// Event handlers:
AliVEventHandler* esdH = new AliESDInputHandler;
mgr->SetInputEventHandler(esdH);
if (!DATA)
{
AliMCEventHandler *mc = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mc);
}
// Task to check the offline trigger:
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AddTaskPhysicsSelection(!DATA);
//Add the centrality determination task
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask* centSelTask = AddTaskCentrality();
if (!DATA) centSelTask->SetMCInput();
//add the PID response task
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse* pidresponsetask = AddTaskPIDResponse(!DATA);
//Add the TOF tender
//gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/AddTaskTenderTOF.C");
//AddTaskTenderTOF();
// Setup kink analysis per centrality bin:
gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityKink.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Float_t lowCentralityBinEdge = centralityArray[i];
Float_t highCentralityBinEdge = centralityArray[i+1];
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
-1,2,kTRUE );
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
1,2,kTRUE );
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
-1,3 );
AddTaskFlowCentralityKink( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kUnknown,
AliFlowTrackCuts::kTOFbeta,
1,3 );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
// Setup kaon analysis per centrality bin:
gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityPID.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Float_t lowCentralityBinEdge = centralityArray[i];
Float_t highCentralityBinEdge = centralityArray[i+1];
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
-1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
-1,3 );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kKaon,
AliFlowTrackCuts::kTOFbeta,
1,3 );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
// Setup He3 analysis per centrality bin:
gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityPID.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Float_t lowCentralityBinEdge = centralityArray[i];
Float_t highCentralityBinEdge = centralityArray[i+1];
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
-1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
1,2,kTRUE );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
-1,3 );
AddTaskFlowCentralityPID( lowCentralityBinEdge,
highCentralityBinEdge,
commonOutputFileName,
AliPID::kHe3,
AliFlowTrackCuts::kTPCNuclei,
1,3 );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
// Enable debug printouts:
mgr->SetDebugLevel(2);
// Run the analysis:
if(!mgr->InitAnalysis()) return;
mgr->PrintStatus();
if(mode == mLocal)
{
mgr->StartAnalysis("local",chain);
}
else if(mode == mPROOF)
{
mgr->StartAnalysis("proof",dataDir,nEvents,offset);
}
else if(mode == mGrid)
{
mgr->StartAnalysis("grid");
}
// Print real and CPU time used for analysis:
timer.Stop();
timer.Print();
} // end of void runFlowTaskCentralityPIDTrain(...)
//______________________________________________________________________________
void AddAnalysisTasks(Int_t merge){
// Add all analysis task wagons to the train
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
//
// Tender and supplies. Needs to be called for every event.
//
if ( VAR_OCDB_SNAPSHOT )
{
AliCDBManager::Instance()->SetDefaultStorage("local:///donotexist");
// explicitely wrong default storage
// so we take _EVERYTHING_ from the snapshot.
AliCDBManager::Instance()->SetRun(0);
AliCDBManager::Instance()->SetSnapshotMode("OCDB_rec.root");
}
if ( VAR_MAKE_COMPACT_ESD )
{
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskCompactTreeMaker.C");
AddTaskCompactTreeMaker();
}
if (iMUONCDBConnect) {
if (iMUONCDBConnect > 1) gROOT->LoadMacro("AddTaskMuonCDBConnect.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskMuonCDBConnect.C");
AliAnalysisTaskMuonCDBConnect *cdbConnect = AddTaskMuonCDBConnect();
if (!defaultStorage.IsNull()) cdbConnect->SetDefaultStorage(defaultStorage.Data());
if (!alignStorage.IsNull() || alignVersion >= 0 || alignSubVersion >= 0)
cdbConnect->SetAlignStorage(alignStorage.Data(), alignVersion, alignSubVersion);
if (!recoParamStorage.IsNull()) cdbConnect->SetRecoParamStorage(recoParamStorage.Data());
cdbConnect->LoadMagField();
cdbConnect->LoadGeometry();
cdbConnect->LoadMapping();
}
UInt_t offlineTriggerMask = 0;
if (usePhysicsSelection) {
// Physics selection task
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
mgr->RegisterExtraFile("event_stat.root");
AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(kTRUE);
offlineTriggerMask = AliVEvent::kAny;
}
// Centrality (only Pb-Pb)
if (iCollision && useCentrality) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
AliMultSelectionTask *mult = AddTaskMultSelection(kFALSE);
}
// track selection
AliMuonTrackCuts *trackCuts = 0x0;
if (iMUONEfficiency) {
trackCuts = new AliMuonTrackCuts("stdCuts", "stdCuts");
trackCuts->SetAllowDefaultParams();
trackCuts->SetFilterMask(AliMuonTrackCuts::kMuMatchLpt | AliMuonTrackCuts::kMuEta | AliMuonTrackCuts::kMuThetaAbs | AliMuonTrackCuts::kMuPdca);
trackCuts->SetIsMC(kTRUE);
}
if (iMUONRefit) {
if (iMUONRefit > 1) gROOT->LoadMacro("AddTaskMuonRefit.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskMuonRefit.C");
AliAnalysisTaskMuonRefit* refit = AddTaskMuonRefit(-1., -1., kTRUE, -1., -1.);
if (!defaultStorage.IsNull()) refit->SetDefaultStorage(defaultStorage.Data());
if (!alignStorage.IsNull()) refit->SetAlignStorage(alignStorage.Data());
refit->RemoveMonoCathodClusters(kTRUE, kFALSE);
}
if (iMUONRefitVtx) {
if (iMUONRefitVtx > 1) gROOT->LoadMacro("AddTaskMuonRefitVtx.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskMuonRefitVtx.C");
AliAnalysisTaskMuonRefitVtx* refitVtx = AddTaskMuonRefitVtx(kFALSE, kFALSE, kTRUE);
if (!defaultStorage.IsNull()) refitVtx->SetDefaultStorage(defaultStorage.Data());
}
if(iESDMCLabelAddition) {
if(iESDMCLabelAddition > 1) gROOT->LoadMacro("AddTaskESDMCLabelAddition.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWG/muondep/AddTaskESDMCLabelAddition.C");
AliAnalysisTaskESDMCLabelAddition *esdmclabel = AddTaskESDMCLabelAddition();
if (!defaultStorage.IsNull()) esdmclabel->SetDefaultStorage(defaultStorage.Data());
if (!alignStorage.IsNull()) esdmclabel->SetAlignStorage(alignStorage.Data());
if (!recoParamStorage.IsNull()) esdmclabel->SetRecoParamStorage(recoParamStorage.Data());
esdmclabel->DecayAsFake(kTRUE);
}
if (iMUONQA) {
if (iMUONQA > 1) gROOT->LoadMacro("AddTaskMuonQA.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskMuonQA.C");
AliAnalysisTaskMuonQA* muonQA = AddTaskMuonQA(kFALSE);
if (usePhysicsSelection) muonQA->SelectCollisionCandidates(offlineTriggerMask);
muonQA->SetTrackCuts(trackCuts);
}
if (useMC && useTR && iMUONPerformance) {
if (iMUONPerformance > 1) gROOT->LoadMacro("AddTaskMuonPerformance.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMuonPerformance.C");
AliAnalysisTaskMuonPerformance* muonPerformance = AddTaskMuonPerformance();
if (usePhysicsSelection) muonPerformance->SelectCollisionCandidates(offlineTriggerMask);
if (!defaultStorage.IsNull()) muonPerformance->SetDefaultStorage(defaultStorage.Data());
if (!alignStorage.IsNull()) muonPerformance->SetAlignStorage(alignStorage.Data());
if (!recoParamStorage.IsNull()) muonPerformance->SetRecoParamStorage(recoParamStorage.Data());
muonPerformance->UseMCKinematics(kTRUE);
muonPerformance->SetMCTrigLevelFromMatchTrk(kTRUE);
}
if (iMUONEfficiency) {
if (iMUONEfficiency > 1) gROOT->LoadMacro("AddTaskMUONTrackingEfficiency.C");
else gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff* muonEfficiency = AddTaskMUONTrackingEfficiency(kFALSE,kTRUE,"");
if (usePhysicsSelection) muonEfficiency->SelectCollisionCandidates(offlineTriggerMask);
if (!defaultStorage.IsNull()) muonEfficiency->SetDefaultStorage(defaultStorage.Data());
if (!alignStorage.IsNull()) muonEfficiency->SetAlignStorage(alignStorage.Data());
if (!recoParamStorage.IsNull()) muonEfficiency->SetRecoParamStorage(recoParamStorage.Data());
muonEfficiency->SetMuonTrackCuts(*trackCuts);
muonEfficiency->SetMuonPtCut(VAR_EFFTASK_PTMIN);
muonEfficiency->UseMCLabel(kTRUE);
muonEfficiency->EnableDisplay(kFALSE);
}
TString addExtraTasks = VAR_EXTRATASKS_CONFIGMACRO;
if (!addExtraTasks.IsNull()) gROOT->ProcessLineSync(TString::Format(".x %s",addExtraTasks.Data()));
if (iESDfilter) {
// ESD filter task configuration.
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/ESDfilter/macros/AddTaskESDFilter.C");
if (iMUONcopyAOD) {
printf("Registering delta AOD file\n");
mgr->RegisterExtraFile("AliAOD.Muons.root");
}
AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, iMUONcopyAOD, kFALSE, kFALSE /*usePhysicsSelection*/,kFALSE,kTRUE,kTRUE,kTRUE,1500,VAR_MUONMCMODE,kFALSE,kFALSE,kTRUE,kFALSE); // others
taskesdfilter->DisablePmdClusters();
taskesdfilter->DisableCaloClusters();
taskesdfilter->DisableCells();
taskesdfilter->DisableCaloTrigger("PHOS");
taskesdfilter->DisableCaloTrigger("EMCAL");
taskesdfilter->SetPropagateTrackToEMCal(kFALSE);
if ( 0 && VAR_USE_ITS_RECO ) /* 0 for the moment to get this macro running also with AliRoot <= .... */
{
AliAnalysisTaskESDMuonFilter* muFilter = mgr->GetTask("ESD Muon Filter");
if ( !muFilter )
{
std::cout << "ERROR : got a NULL muFilter ! so I cannot ask to keep SPD tracklets !" << std::endl;
}
else
{
muFilter->SetWithSPDtracklets(kTRUE);
}
}
}
}
void RunSingleTrackEfficiencyTaskHFCJ()
{
TBenchmark fBenchMark;
fBenchMark.Start("AliCFSingleTrackEfficiencyTask");
Load();
if(fAnalysisMode=="grid"){
//gSystem->Exec(Form("alien-token-init %s",fUsername.Data()));
TGrid::Connect("alien://") ;
}
if(IsPlugin) {
AliAnalysisGrid *alienHandler = CreateAlienHandler();
if(!alienHandler) return;
}
printf("CREATE ANALYSIS MANAGER\n");
AliAnalysisManager *mgr = new AliAnalysisManager("My Manager","My Manager");
mgr->SetDebugLevel(10);
if(IsPlugin) mgr->SetGridHandler(alienHandler);
AliMCEventHandler* mcHandler = new AliMCEventHandler();
if (!readAOD) mgr->SetMCtruthEventHandler(mcHandler);
AliInputEventHandler* dataHandler;
if (readAOD) dataHandler = new AliAODInputHandler();
else dataHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(dataHandler);
if (!readAOD) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kTRUE);
}
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskSE *setupTask = AddTaskPIDResponse(kTRUE, kTRUE, kTRUE, 2, kFALSE, "", kTRUE, kFALSE, -1);
if(ifTaskPIDQA){
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *pidQA = AddTaskPIDqa();
}
printf("Prepare to create the task\n");
gROOT->LoadMacro("./AddSingleTrackEfficiencyTaskDhCorrelations.C");
//NCharge Filterbin0 + kFAST configuration + w/o external cut file
AliCFSingleTrackEfficiencyTask *taskNchF0wFile = AddSingleTrackEfficiencyTaskDhCorrelations(kTRUE, "NchFbit0woFile", AliPID::kPion, 0, AliVEvent::kAnyINT, kFALSE, AliCFSingleTrackEfficiencyTask::kFast, AliSingleTrackEffCuts::kNoBayesianPID, "", "");
//NCharge Filterbin0 + kFAST configuration + w external cut file
AliCFSingleTrackEfficiencyTask *taskNchF0 = AddSingleTrackEfficiencyTaskDhCorrelations(kTRUE, "NchFbit0", AliPID::kPion, 0, AliVEvent::kAnyINT, kFALSE, AliCFSingleTrackEfficiencyTask::kFast, AliSingleTrackEffCuts::kNoBayesianPID, "AssocPartCuts_Std_NewPoolsAndCode_10000Tr.root", "AssociatedTrkCuts");
//Pion Filterbin0+ kFAST configuration + w external cut file
AliCFSingleTrackEfficiencyTask *taskPionF0 = AddSingleTrackEfficiencyTaskDhCorrelations(kTRUE, "PionFbit0", AliPID::kPion, 211, AliVEvent::kAnyINT, kFALSE, AliCFSingleTrackEfficiencyTask::kFast, AliSingleTrackEffCuts::kNoBayesianPID,"AssocPartCuts_Std_NewPoolsAndCode_10000Tr.root", "AssociatedTrkCuts");
//Kaons Filterbin0+ kFAST configuration + w external cut file
AliCFSingleTrackEfficiencyTask *taskKaonF0 = AddSingleTrackEfficiencyTaskDhCorrelations(kTRUE, "KaonFbit0", AliPID::kKaon, 321, AliVEvent::kAnyINT, kFALSE, AliCFSingleTrackEfficiencyTask::kFast, AliSingleTrackEffCuts::kNoBayesianPID,"AssocPartCuts_Std_NewPoolsAndCode_10000Tr.root", "AssociatedTrkCuts");
//Protons Filterbin0+ kFAST configuration + w external cut file
AliCFSingleTrackEfficiencyTask *taskProtF0 = AddSingleTrackEfficiencyTaskDhCorrelations(kTRUE, "ProtonFbit0", AliPID::kProton, 2212, AliVEvent::kAnyINT, kFALSE, AliCFSingleTrackEfficiencyTask::kFast, AliSingleTrackEffCuts::kNoBayesianPID,"AssocPartCuts_Std_NewPoolsAndCode_10000Tr.root", "AssociatedTrkCuts");
//Electron Filterbin0+ kFAST configuration + w external cut file
AliCFSingleTrackEfficiencyTask *taskElecF0 = AddSingleTrackEfficiencyTaskDhCorrelations(kTRUE, "ElectronFbit0", AliPID::kElectron,11, AliVEvent::kAnyINT, kFALSE, AliCFSingleTrackEfficiencyTask::kFast, AliSingleTrackEffCuts::kNoBayesianPID, "AssocPartCuts_Std_NewPoolsAndCode_10000Tr.root", "AssociatedTrkCuts");
// Run the analysis
TChain * analysisChain=0;
if(analysisChain) printf("CHAIN HAS %d ENTRIES\n",(Int_t)analysisChain->GetEntries());
if(!mgr->InitAnalysis()) return;
mgr->PrintStatus();
if(fAnalysisMode=="grid" && !IsPlugin) fAnalysisMode="local";
if(fAnalysisMode!="proof") {
mgr->StartAnalysis(fAnalysisMode.Data(),analysisChain,nEntries,firstentry);
}
fBenchMark.Stop("AliCFSingleTrackEfficiencyTask");
fBenchMark.Show("AliCFSingleTrackEfficiencyTask");
return;
}
//______________________________________________________________________________
void RunGrid(
const char* runtype = "grid", // local, proof or grid
const char *gridmode = "test", // Set the run mode (can be "full", "test", "offline", "submit" or "terminate"). Full & Test work for proof
const Long64_t nentries = 400, // 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
const char *proofdataset = "/alice/data/LHC10c_000120821_p1", // path to dataset on proof cluster, for proof analysis
const char *proofcluster = "alice-caf.cern.ch", // which proof cluster to use in proof mode
const char *taskname = "Deuterons2011ESD"
)
{
// 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);
gROOT->ProcessLine(".include $ALICE_ROOT/include");
gSystem->AddIncludePath("-I$ALICE_ROOT/include");
gSystem->AddIncludePath("-I$ALICE_ROOT/PWGHF/vertexingHF");
// Load analysis specific libraries
//=====================================================================
gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER/STEER -I$ALICE_ROOT/STEER/STEERBase -I$ALICE_ROOT/STEER/ESD -I$ALICE_ROOT/STEER/AOD -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/OADB -I$ALICE_ROOT/PWGHF -I$ALICE_ROOT/PWGHF/base -I$ALICE_ROOT/PWGHF/vertexingHF -I$ALICE_ROOT/PWG/FLOW/Base -I$ALICE_ROOT/PWG/FLOW/Tasks -g");
gSystem->Load("libTree.so");
gSystem->Load("libGeom.so");
gSystem->Load("libPhysics.so");
gSystem->Load("libVMC.so");
gSystem->Load("libMinuit.so");
gSystem->Load("libSTEERBase.so");
gSystem->Load("libESD.so");
gSystem->Load("libAOD.so");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libOADB.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libCORRFW.so");
gSystem->Load("libPWGHFbase.so");
gSystem->Load("libPWGflowBase.so");
gSystem->Load("libPWGflowTasks.so");
gSystem->Load("libPWGHFvertexingHF.so");
// Load analysis specific libraries
//=====================================================================
//------ Create AlienPlugin ---------------------
AliAnalysisGrid *plugin = 0x0;
TChain *chain = 0x0;
if (runtype != "local") {
plugin = CreateAlienHandler(taskname, gridmode, proofcluster, proofdataset);
if(!plugin) return;
} else {
gROOT->LoadMacro("$ALICE_ROOT/PWGCF/Correlations/macros/dphicorrelations/CreateESDChain.C");
chain = CreateESDChain("ESDs.txt");
}
//---- Create the analysis manager
AliAnalysisManager* mgr = new AliAnalysisManager(taskname);
if(plugin) mgr->SetGridHandler(plugin);
// Input
AliESDInputHandler* iH = new AliESDInputHandler("handler","handler for my analisys");
mgr->SetInputEventHandler(iH);
//--------------------------------------------------------------
// Other tasks
// Physics selection
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask *physSel = AddTaskPhysicsSelection(kFALSE); // useMC
// Centrality selection
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
AliCentralitySelectionTask *taskCentr = AddTaskCentrality();
// PID response
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
AliAnalysisTaskPIDResponse *pidTask = AddTaskPIDResponse(kFALSE); // useMC
// PID QA
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
AliAnalysisTaskPIDqa *pidQATask = AddTaskPIDqa();
gROOT->LoadMacro("./AliAnalysisTaskFlowd.cxx+g");//$ALICE_ROOT/PWGLF/STRANGENESS/Cascades/AliAnalysisTaskCheckCascadePbPb.cxx++g");
gROOT->LoadMacro("./AddTaskFlowd.C");//$ALICE_ROOT/PWGLF/STRANGENESS/Cascades/macros/AddTaskCheckCascadePbPb.C");
AliAnalysisTaskFlowd *task = AddTaskFlowd(kTRUE);
//__________________________________________________________________________
// Disable debug printouts
mgr->SetDebugLevel(3);
AliLog::SetGlobalLogLevel(AliLog::kFatal);
AliLog::SetGlobalDebugLevel(0);
//__________________________________________________________________________
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
// Start analysis in grid.
if (runtype == "local")
mgr->StartAnalysis(runtype,chain,nentries,firstentry);
else
mgr->StartAnalysis(runtype,nentries,firstentry);
}
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 run(const Char_t *files=NULL, Bool_t mc=kFALSE, Bool_t tpid=kTRUE, Bool_t tchg=kFALSE, Bool_t tpp=kTRUE, Long64_t nev=1234567890, Long64_t first = 0)
{
TStopwatch timer;
timer.Start();
// VERY GENERAL SETTINGS
//AliLog::SetGlobalLogLevel(AliLog::kError);
if(gSystem->Load("libANALYSIS.so")<0) return;
if(gSystem->Load("libANALYSISalice.so")<0) return;
if(gSystem->Load("libTender.so")<0) return;
if(gSystem->Load("libTenderSupplies.so")<0) return;
// if(gSystem->Load("libMES.so")<0) return;
if(gSystem->Load("libPWGLFspectra.so")<0) return;
// DEFINE DATA CHAIN
TChain *chain = NULL;
if(!files) chain = MakeChainLST();
else chain = MakeChainLST(files);
if(!chain) return;
chain->Lookup();
chain->GetListOfFiles()->Print();
Long64_t nfound=chain->GetEntries();
printf("\tENTRIES FOUND [%lli] REQUESTED [%lli]\n", nfound, nev>nfound?nfound:nev);
// BUILD ANALYSIS MANAGER
AliAnalysisManager *mgr = new AliAnalysisManager("Multiplicity and Event Shape");
AliESDInputHandler *esdH = new AliESDInputHandler();
AliMCEventHandler *mcH(NULL);
mgr->SetInputEventHandler(esdH);
if(mc) mgr->SetMCtruthEventHandler(mcH = new AliMCEventHandler());
//mgr->SetDebugLevel(10);
mgr->SetSkipTerminate(kTRUE);
// LOAD tasks
// ******************* PID response ******************
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
if(!mc) AddTaskPIDResponse();
else AddTaskPIDResponse(kTRUE,kTRUE,kTRUE,2);
// ******************* Tenders ***********************
AliTender *aliTender(NULL);
gROOT->LoadMacro("$ALICE_PHYSICS/TENDER/TenderSupplies/AddTaskTender.C");
if(!mc){ // for DATA
aliTender = (AliTender*)AddTaskTender(!mc, kTRUE, kTRUE, kTRUE, kTRUE, kFALSE, kTRUE, kFALSE, kFALSE);
// (useV0, useTPC, !!! useTOF=kFALSE for MC !!!, useTRD, usePID, useVTX, useT0, useEmc, usePtFix)
} else { // for MC
aliTender = (AliTender*)AddTaskTender(!mc, kTRUE, kFALSE, kTRUE, kTRUE, kTRUE, kTRUE, kFALSE, kFALSE); // (useV0, useTPC, !!! useTOF=kFALSE for MC !!!, useTRD, usePID, useVTX, useT0, useEmc, usePtFix)
}
aliTender->SetHandleOCDB(kTRUE);
//aliTender->SetDefaultCDBStorage(Form("alien://folder=/alice/data/2010/OCDB?cacheFolder=%s/local", gSystem->ExpandPathName("$HOME")));
// aliTender->SetDefaultCDBStorage(Form("local://%s/local/alice/data/2010/OCDB", gSystem->ExpandPathName("$HOME")));
// ******************* Physics Selection *************
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(mc); // 0 = real data; 1 = MC
// ******************* MES Tender ******************
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMEStender.C");
AddMEStender(mc);
// ******************* MES PID task ******************
if(tpid){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESpidTask.C");
AddMESpidTask(mc);
}
//
// // ******************* MES CHG task ******************
if(tchg){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESchgTask.C");
AddMESchgTask(mc);
}
//
// // ******************* MES ppCol task ******************
if(tpp){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESppColTask.C");
AddMESppColTask(mc);
}
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
mgr->StartAnalysis("local", chain, nev, first);
timer.Stop();
timer.Print();
// verbosity
printf("\tCLEANING TASK LIST:\n");
mgr->GetTasks()->Delete();
if(mcH) delete mcH;
delete esdH;
delete chain;
}
void AddAnalysisTasks(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);
}
}
