void runAliTask() {
TStopwatch timer;
timer.Start();
// gSystem->Load("libTree.so");
// gSystem->Load("libGeom.so");
// gSystem->Load("libVMC.so");
// gSystem->Load("libPhysics.so");
// //____________________________________________________//
// //_____________Setting up required packages___________//
// //____________________________________________________//
// gSystem->Load("libSTEERBase.so");
// gSystem->Load("libESD.so");
// gSystem->Load("libAOD.so");
// gSystem->Load("libANALYSIS.so");
// gSystem->Load("libANALYSISalice.so");
// gROOT->ProcessLine(".include $ALICE_ROOT/include");
//
// //___________Compile analysis task using AClic____________//
// gROOT->LoadMacro("../task/AliAnalysisTaskPt.cxx+g");
//
//
// gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain("files.txt", 2);
//____________________________________________//
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
AliESDInputHandler* esdH = new AliESDInputHandler();
mgr->SetInputEventHandler(esdH);
//____________________________________________//
// 1st Pt task
AliAnalysisTaskPt *task1 = new AliAnalysisTaskPt("TaskPt");
mgr->AddTask(task1);
// Create containers for input/output
AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", TH1::Class(),AliAnalysisManager::kOutputContainer,"Pt.ESD.root");
//____________________________________________//
mgr->ConnectInput(task1,0,cinput1);
mgr->ConnectOutput(task1,0,coutput1);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
//mgr->StartAnalysis("local",chain);
timer.Stop();
timer.Print();
}
void runLocal() {
TStopwatch timer;
timer.Start();
gSystem->Load("libCore.so");
gSystem->Load("libTree.so");
gSystem->Load("libGeom.so");
gSystem->Load("libVMC.so");
gSystem->Load("libPhysics.so");
//____________________________________________________//
//_____________Setting up required packages___________//
//____________________________________________________//
gSystem->Load("libSTEERBase.so");
gSystem->Load("libSTEER.so");
gSystem->Load("libESD.so");
gSystem->Load("libAOD.so");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gROOT->ProcessLine(".include $ALICE_ROOT/include");
gROOT->ProcessLine(".include $ALICE_ROOT/PHOS");
//___________Compile analysis task using AClic____________//
gROOT->LoadMacro("EqEnCalibTask.cxx+g");
// chain using tags
// AliTagAnalysis *tagAna = new AliTagAnalysis("ESD");
// tagAna->ChainLocalTags("tags");
//
// AliRunTagCuts *runCuts = new AliRunTagCuts();
// AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
// AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
// AliEventTagCuts *evCuts = new AliEventTagCuts();
// // evCuts->SetMultiplicityRange(11,12);
// TChain* chain = 0x0;
// chain = tagAna->QueryTags(runCuts, lhcCuts, detCuts, evCuts);
// chain using list of files.
gROOT->LoadMacro("$ALICE_ROOT/PWGUD/macros/CreateESDChain.C");
TChain* chain = CreateESDChain("files.txt", 10);
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
AliESDInputHandler* esdH = new AliESDInputHandler();
mgr->SetInputEventHandler(esdH);
AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
// Create the task
EqEnCalibTask *task = new EqEnCalibTask("EqEnCalibTask");
//task.SetDebugLevel(4);
mgr->AddTask(task);
mgr->ConnectInput(task, 0, cinput0);
AliAnalysisDataContainer *outContainer = mgr->CreateContainer("outContainer", TList::Class(),AliAnalysisManager::kOutputContainer, "ee-calib.output.root");
mgr->ConnectOutput(task, 1, outContainer);
// Start the task
mgr->SetDebugLevel(1);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
mgr->StartAnalysis("local",chain);
timer.Stop();
timer.Print();
}
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 runLocal(const char *chainlistfile, int dataFromAlien=0) {
TStopwatch timer;
timer.Start();
printf("*** Connect to AliEn ***\n");
if (dataFromAlien)
TGrid::Connect("alien://");
gSystem->Load("libProofPlayer");
//____________________________________________________//
//_____________Setting up STEERBase.par_______________//
//____________________________________________________//
setupPar("STEERBase");
gSystem->Load("libSTEERBase");
//____________________________________________________//
//_____________Setting up ESD.par_____________________//
//____________________________________________________//
setupPar("ESD");
gSystem->Load("libVMC");
gSystem->Load("libESD");
//____________________________________________________//
//_____________Setting up AOD.par_____________________//
//____________________________________________________//
setupPar("AOD");
gSystem->Load("libAOD");
//_________________________________________________________//
//_____________Setting up ANALYSIS.par_____________________//
//_________________________________________________________//
setupPar("ANALYSIS");
gSystem->Load("libANALYSIS");
//_________________________________________________________//
//_____________Setting up ANALYSISalice.par________________//
//_________________________________________________________//
setupPar("ANALYSISalice");
gSystem->Load("libANALYSISalice");
//____________________________________________________//
//_____________Setting up PWG2AOD.par_________________//
//____________________________________________________//
setupPar("PWG2AOD");
gSystem->Load("libPWG2AOD");
//____________________________________________________//
//_____________Setting up PWG2femtoscopy.par__________//
//____________________________________________________//
setupPar("PWG2femtoscopy");
gSystem->Load("libPWG2femtoscopy");
//____________________________________________________//
//_____________Setting up PWG2femtoscopyUser.par______//
//____________________________________________________//
setupPar("PWG2femtoscopyUser");
gSystem->Load("libPWG2femtoscopyUser");
//ANALYSIS PART
gSystem->SetIncludePath("-I$ROOTSYS/include -I\"/usr/local/CERN/root/include\" -I./PWG2femtoscopy/FEMTOSCOPY/AliFemto -I./PWG2femtoscopyUser/FEMTOSCOPY/AliFemtoUser -I./ESD -I./AOD -I./ANALYSIS -I./PWG2AOD/AOD");
gROOT->LoadMacro("ConfigFemtoAnalysis.C++");
//____________________________________________//
//Usage of event tags
AliTagAnalysis *analysis = new AliTagAnalysis();
TChain *chain = 0x0;
// chain = analysis->GetChainFromCollection(collectionfile,"esdTree");
if (dataFromAlien) {
AliTagAnalysis *analysis = new AliTagAnalysis();
chain = analysis->GetChainFromCollection(chainlistfile,"esdTree");
}
else {
gROOT->LoadMacro("CreateESDChain.C");
chain = CreateESDChain(chainlistfile,500);
}
//____________________________________________//
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
AliESDInputHandler* esdH = new AliESDInputHandler;
AliMCEventHandler *mcH = new AliMCEventHandler;
esdH->SetInactiveBranches("FMD CaloCluster");
mgr->SetInputEventHandler(esdH);
mgr->SetMCtruthEventHandler(mcH);
//____________________________________________//
// 1st Pt task
AliAnalysisTaskFemto *task1 = new AliAnalysisTaskFemto("TaskFemto");
mgr->AddTask(task1);
// Create containers for input/output
// AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("input0",
TTree::Class(), AliAnalysisManager::kInputContainer);
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("clist1", TList::Class(),AliAnalysisManager::kOutputContainer,"Femto.ESD.root");
//____________________________________________//
cinput1->SetData(chain);
mgr->ConnectInput(task1,0,cinput1);
mgr->ConnectOutput(task1,0,coutput1);
if (!mgr->InitAnalysis()) return;
mgr->PrintStatus();
mgr->StartAnalysis("local",chain);
timer.Stop();
timer.Print();
}
//______________________________________________________________________________
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 CreateChain(const anaModes mode, TChain * chain){
//Fills chain with data
TString ocwd = gSystem->WorkingDirectory();
//-----------------------------------------------------------
//Analysis of CAF data locally and with PROOF
//-----------------------------------------------------------
if(mode ==mPROOF || mode ==mLocalCAF){
// Chain from CAF
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
// The second parameter is the number of input files in the chain
chain = CreateESDChain("ESD12001.txt", 5);
}
//---------------------------------------
//Local files analysis
//---------------------------------------
else if(mode == mLocal){
//If you want to add several ESD files sitting in a common directory INDIR
//Specify as environmental variables the directory (INDIR), the number of files
//to analyze (NFILES) and the pattern name of the directories with files (PATTERN)
if(gSystem->Getenv("INDIR"))
kInDir = gSystem->Getenv("INDIR") ;
else cout<<"INDIR not set, use default: "<<kInDir<<endl;
if(gSystem->Getenv("PATTERN"))
kPattern = gSystem->Getenv("PATTERN") ;
else cout<<"PATTERN not set, use default: "<<kPattern<<endl;
if(gSystem->Getenv("NFILES"))
kFile = atoi(gSystem->Getenv("NFILES")) ;
else cout<<"NFILES not set, use default: "<<kFile<<endl;
//Check if env variables are set and are correct
if ( kInDir && kFile) {
printf("Get %d files from directory %s\n",kFile,kInDir);
if ( ! gSystem->cd(kInDir) ) {//check if ESDs directory exist
printf("%s does not exist\n", kInDir) ;
return ;
}
cout<<"INDIR : "<<kInDir<<endl;
cout<<"NFILES : "<<kFile<<endl;
cout<<"PATTERN : " <<kPattern<<endl;
TString datafile="";
if(kInputData == "ESD") datafile = "AliESDs.root" ;
else if(kInputData == "AOD") datafile = "AliAOD.root" ;
else if(kInputData == "MC") datafile = "galice.root" ;
//Loop on ESD files, add them to chain
Int_t event =0;
Int_t skipped=0 ;
char file[120] ;
for (event = 0 ; event < kFile ; event++) {
sprintf(file, "%s/%s%d/%s", kInDir,kPattern,event,datafile.Data()) ;
TFile * fESD = 0 ;
//Check if file exists and add it, if not skip it
if ( fESD = TFile::Open(file)) {
if ( fESD->Get(kTreeName) ) {
printf("++++ Adding %s\n", file) ;
chain->AddFile(file);
}
}
else {
printf("---- Skipping %s\n", file) ;
skipped++ ;
}
}
printf("number of entries # %lld, skipped %d\n", chain->GetEntries(), skipped*100) ;
}
else {
TString input = "AliESDs.root" ;
cout<<">>>>>> No list added, take a single file <<<<<<<<< "<<input<<endl;
chain->AddFile(input);
}
}// local files analysis
//------------------------------
//GRID xml files
//-----------------------------
else if(mode == mGRID){
//Get colection file. It is specified by the environmental
//variable XML
if(gSystem->Getenv("XML") )
kXML = gSystem->Getenv("XML");
else
sprintf(kXML, "collection.xml") ;
if (!TFile::Open(kXML)) {
printf("No collection file with name -- %s -- was found\n",kXML);
return ;
}
else cout<<"XML file "<<kXML<<endl;
//Load necessary libraries and connect to the GRID
gSystem->Load("libNetx") ;
gSystem->Load("libRAliEn");
TGrid::Connect("alien://") ;
//Feed Grid with collection file
//TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\", 0)", kXML));
TGridCollection * collection = (TGridCollection*) TAlienCollection::Open(kXML);
if (! collection) {
AliError(Form("%s not found", kXML)) ;
return kFALSE ;
}
TGridResult* result = collection->GetGridResult("",0 ,0);
// Makes the ESD chain
printf("*** Getting the Chain ***\n");
for (Int_t index = 0; index < result->GetEntries(); index++) {
TString alienURL = result->GetKey(index, "turl") ;
cout << "================== " << alienURL << endl ;
chain->Add(alienURL) ;
}
}// xml analysis
gSystem->ChangeDirectory(ocwd.Data());
}
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 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);
}
}
