//___________________________________________________________
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 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 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 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 Hyperon(const char* dataset="collection.xml")
{
/* $Id$ */
TStopwatch timer;
timer.Start();
TStringToken libs("Core,Tree,Geom,VMC,Physics,Minuit,Gui,XMLParser,Minuit2,Proof,STEERBase,ESD,AOD,OADB,ANALYSIS,ANALYSISalice,CDB,RAWDatabase,STEER,CORRFW,PHOSUtils,PHOSbase,PHOSpi0Calib,PHOSrec,PHOSshuttle,PHOSsim", ",");
while( libs.NextToken() )
gSystem->Load( Form("lib%s", libs.Data()) );
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
gSystem->Load("libPWGGAGammaConv");
gSystem->Load("libPWGGAHyperon");
//load analysis framework
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
// 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("aodTree");
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->GetEntriesFast());
}
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("Hyperon");
mgr->SetCommonFileName("histos.root");
// AOD input handler
AliAODInputHandler* aodH = new AliAODInputHandler();
mgr->SetInputEventHandler(aodH);
// Debug level
mgr->SetDebugLevel(2);
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask* taskCentrality = AddTaskCentrality();
if (analysisMC)
taskCentrality->SetMCInput();
// // Update it for Hyperon (YK 22.01.2015)
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
// AliEPSelectionTask *taskEP = AddTaskEventplane() ;
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
// AliVZEROEPSelectionTask *selTask = AddTaskVZEROEPSelection();
// Add my task
AliAnalysisHyperon* task = new AliAnalysisHyperon();
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPb/AddTaskPHOSPi0Flow.C"); // Update it for Hyperon (YK 22.01.2015)
// task = AddTaskPHOSPi0Flow();
// // Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("Hyperon",TList::Class(),AliAnalysisManager::kOutputContainer,"HyperonHist.root");
// // Connect input/output
mgr->ConnectInput(task , 0, cinput);
mgr->ConnectOutput(task, 1, coutput1);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
timer.Stop();
timer.Print();
}
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;
}
