void runProofFwdDetsQA(const char * dataset = "/COMMON/COMMON/LHC09a4_run8101X",Long64_t nentries=100000, Long64_t firstentry=0) { gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->AddIncludePath("-I$ALICE_ROOT/include"); // Connect to Proof gEnv->SetValue("XSec.GSI.DelegProxy","2"); TProof::Open("cheshkov:PWG0@alicecaf"); // Upload and enable packages: please use the correct version! gProof->UploadPackage("/afs/cern.ch/alice/caf/sw/ALICE/PARs/v4-16-Release/AF-v4-16"); gProof->EnablePackage("/afs/cern.ch/alice/caf/sw/ALICE/PARs/v4-16-Release/AF-v4-16"); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("AliAnaFwdDetsQA"); AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliVEventHandler* handler = new AliMCEventHandler; mgr->SetMCtruthEventHandler(handler); // Create task gProof->Load(Form("%s/PWGPP/AliAnaFwdDetsQA.cxx++g", gSystem->Getenv("ALICE_ROOT"))); AliAnalysisTask *task = new AliAnaFwdDetsQA("AliAnaFwdDetsQA"); // Add task mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "FwdDetsQA.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); // Enable debug printouts mgr->SetDebugLevel(3); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); TFileCollection *proofColl = gProof->GetDataSet(dataset); TChain *chain = new TChain("esdTree"); chain->AddFileInfoList((TCollection*)(proofColl->GetList())); mgr->StartAnalysis("proof", chain, nentries, firstentry); // mgr->StartAnalysis("proof",dataset,nentries,firstentry); }
void runProofT0analysis(const char * dataset = "/COMMON/COMMON/LHC09a4_10TeV_200k#esdTree",Long64_t nentries=20000, Long64_t firstentry=0) { // Connect to Proof TProof::Open("proof://[email protected]"); //TProof::Open("lxb6046"); // Upload and enable packages: please use the correct version! gProof->UploadPackage("AF-v4-16"); gProof->EnablePackage("AF-v4-16"); gProof->ShowDataSets(); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("AliT0MultiplicityTask"); AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliVEventHandler* handler = new AliMCEventHandler; mgr->SetMCtruthEventHandler(handler); // Create task // gProof->Load("AliMCComparisonTrack.cxx++g"); gProof->Load("AliT0MultiplicityTask.cxx++g"); AliAnalysisTask *task = new AliT0MultiplicityTask("AliT0MultiplicityTask"); // Add task mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->CreateContainer("cchain", TChain::Class(), AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *coutput = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "MultHist.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); // Enable debug printouts mgr->SetDebugLevel(3); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("proof",dataset,nentries,firstentry); }
void rundStarTask(const char* mode = "test", bool isMC=true){ // Include AliPhysics and AliRoot libraries gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_PHYSICS/include"); //Check the run mode if(std::strcmp(mode,"local")!=0 && std::strcmp(mode,"grid")!=0 && std::strcmp(mode,"test")!=0){ Printf("\n\tIncorrect run option, check first argument of run macro"); Printf("\tmode = local, test or grid\n"); return; } Printf("%s analysis chosen",mode); //Define the plugin AliAnalysisGrid *plugin = 0x0; TChain *chain = 0x0; if(std::strcmp(mode,"local")!=0) { plugin = CreateAlienHandler(mode,isMC); if(!plugin) return; } else { gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/CreateAODChain.C"); chain = CreateAODChain("localdata.txt"); } // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager(kTaskName); if(plugin) mgr->SetGridHandler(plugin); // Define input handlers if(isMC){ AliMCEventHandler* mcHandler = new AliMCEventHandler(); if (plugin) mgr->SetMCtruthEventHandler(mcHandler); } AliAODInputHandler *aodH = new AliAODInputHandler(); mgr->SetInputEventHandler(aodH); // Compile the class gROOT->LoadMacro("AliAnalysisTaskdStar.cxx++g"); // PID response gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskPIDResponse *pidTask = AddTaskPIDResponse(isMC); // useMC // dStar task gROOT->LoadMacro("AddTaskdStar.C"); AliAnalysisTaskdStar *task = AddTaskdStar(isMC); // Disbale debug printouts mgr->SetDebugLevel(3); AliLog::SetGlobalLogLevel(AliLog::kFatal); AliLog::SetGlobalDebugLevel(0); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); // Start analysis in grid. if (std::strcmp(mode,"local")==0) mgr->StartAnalysis(mode,chain); else mgr->StartAnalysis("grid"); }
void runProofTRDComparison(const char *dataset="/PWG0/COMMON/run30000X_10TeV_0.5T",Long64_t nentries=1000, Long64_t firstentry=0) { // Connect to Proof TProof::Open("lxb6046"); // Upload and enable packages: please use the correct version! gProof->UploadPackage("AF-v4-14"); gProof->EnablePackage("AF-v4-14"); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("AliTRDComparison"); AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliVEventHandler* handler = new AliMCEventHandler; mgr->SetMCtruthEventHandler(handler); // Create task gProof->Load("AliMCComparisonTrack.cxx++g"); gProof->Load("AliTRDComparisonTask.cxx++g"); AliAnalysisTask *task = new AliTRDComparisonTask("AliTRDComparisonTask"); // Add task mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer* cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer* coutput = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "AliTRDComparisonHist.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); // Enable debug printouts mgr->SetDebugLevel(3); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("proof",dataset,nentries,firstentry); }
void TaskBuzzer(UInt_t config, const char *collection="wn.xml") { printf("Running buzzer with: %s\n", ConfigName(config)); TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("PilotAnalysis", "No grid connection"); return; } TChain *chain = CreateChain(collection, "ESD"); // Load libraries gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD"); LoadLibraries(); // Create manager AliAnalysisManager *mgr = new AliAnalysisManager("ESDfiltering", "Production train"); mgr->SetNSysInfo(100); // Input handler AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP(); // AliESDInputHandler *esdHandler = new AliESDInputHandler(); esdHandler->SetReadFriends(kTRUE); esdHandler->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(esdHandler); if (config & kAOD) { // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); if (!mergeExcludes.IsNull()) mergeExcludes += " "; mergeExcludes += "AliAOD.root"; mgr->SetOutputEventHandler(aodHandler); } // AnalysisTasks AddAnalysisTasks(config); mgr->SetDebugLevel(1); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("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"); } } }
void runLocalSim() { TStopwatch timer; timer.Start(); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gROOT->LoadMacro("AliAnalysisEt.cxx+g"); gROOT->LoadMacro("AliAnalysisEtReconstructed.cxx+g"); gROOT->LoadMacro("AliAnalysisEtMonteCarlo.cxx+g"); gROOT->LoadMacro("AliAnalysisEtReconstructedPhos.cxx+g"); gROOT->LoadMacro("AliAnalysisEtMonteCarloPhos.cxx+g"); gROOT->LoadMacro("AliAnalysisTaskTotEt.cxx+g"); //____________________________________________// /*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); evCuts->SetNPHOSClustersRange(0,10000); TChain* chain = 0x0; chain = TagAna->QueryTags(runCuts,lhcCuts,detCuts,evCuts); */// chain->SetBranchStatus("*Calo*",0); TChain *chain = new TChain("esdTree"); //chain->Add("/media/wd/data/LHC10b/10000116134019.10/AliESDs.root"); // chain->Add("../ESDs/140012/001/AliESDs.root"); // chain->Add("../ESDs/140012/002/AliESDs.root"); // chain->Add("../ESDs/140012/003/AliESDs.root"); // chain->Add("../ESDs/140012/004/AliESDs.root"); // chain->Add("../ESDs/140012/005/AliESDs.root"); // chain->Add("../ESDs/140012/006/AliESDs.root"); // chain->Add("../ESDs/140012/007/AliESDs.root"); // chain->Add("../ESDs/140012/008/AliESDs.root"); // chain->Add("../ESDs/140012/009/AliESDs.root"); // chain->Add("../ESDs/140012/010/AliESDs.root"); // chain->Add("../ESDs/140012/011/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/088/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/081/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/065/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/050/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/010/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/013/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/025/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/021/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/072/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/011/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/092/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/043/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/002/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/008/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/059/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/107/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/017/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/085/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/103/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/091/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/034/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/084/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/071/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/079/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/087/AliESDs.root"); chain->Add("/media/wd/data/LHC10a/140009/067/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/028/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/068/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/051/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/020/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/102/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/066/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/063/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/047/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/105/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/040/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/053/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/083/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/069/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/016/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/006/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/039/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/077/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/100/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/003/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/052/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/009/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/026/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/062/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/095/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/070/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/106/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/027/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/054/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/073/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/022/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/044/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/012/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/056/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/031/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/086/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/023/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/075/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/093/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/005/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/035/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/057/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/019/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/042/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/046/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/048/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/024/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/018/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/014/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/064/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/032/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/104/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/029/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/082/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/108/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/074/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/041/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/058/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/089/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/080/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/101/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/055/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/098/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/096/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/038/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/1000/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/033/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/094/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/004/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/060/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/076/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/078/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/061/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/090/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/097/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140009/099/AliESDs.root"); // // chain->Add("/media/wd/data/LHC10a/140010/081/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/065/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/050/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/010/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/013/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/025/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/021/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/072/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/011/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/092/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/043/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/002/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/001/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/015/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/008/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/059/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/017/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/045/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/103/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/091/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/034/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/084/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/071/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/079/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/087/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/067/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/028/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/068/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/051/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/020/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/102/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/066/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/063/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/047/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/105/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/040/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/053/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/083/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/069/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/016/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/006/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/039/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/077/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/100/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/036/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/003/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/052/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/007/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/009/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/026/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/062/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/030/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/095/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/070/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/027/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/054/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/073/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/022/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/044/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/012/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/056/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/031/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/086/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/023/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/075/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/093/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/005/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/035/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/057/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/019/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/042/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/046/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/048/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/024/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/018/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/014/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/064/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/032/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/104/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/029/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/082/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/058/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/089/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/080/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/101/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/055/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/098/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/096/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/038/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/1000/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/033/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/094/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/004/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/060/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/076/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/078/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/061/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/090/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/037/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/097/AliESDs.root"); // chain->Add("/media/wd/data/LHC10a/140010/099/AliESDs.root"); // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TotEtManager"); AliVEventHandler* esdH = new AliESDInputHandler; mgr->SetInputEventHandler(esdH); AliMCEventHandler* handler = new AliMCEventHandler; handler->SetReadTR(kFALSE); mgr->SetMCtruthEventHandler(handler); AliAnalysisTaskTotEt *task1 = new AliAnalysisTaskTotEt("TaskTotEt"); mgr->AddTask(task1); // Create containers for input/output //AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1", TChain::Class(),AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("out1", TList::Class(), AliAnalysisManager::kOutputContainer,"Et.ESD.sim.root"); //____________________________________________// mgr->ConnectInput(task1,0,cinput1); mgr->ConnectOutput(task1,1,coutput1); mgr->SetDebugLevel(1); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("local",chain); timer.Stop(); timer.Print(); }
void runGrid() { gSystem->Load("libCore.so"); gSystem->Load("libTree.so"); gSystem->Load("libGeom.so"); gSystem->Load("libVMC.so"); gSystem->Load("libPhysics.so"); gSystem->Load("libSTEERBase"); // gSystem->Load("libESD"); gSystem->Load("libAOD"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libTENDER"); // gSystem->Load("libPWGPP"); gROOT->ProcessLine(".include $ALICE_ROOT/include"); gROOT->LoadMacro("CreateAlienHandler.C"); AliAnalysisGrid *alienHandler = CreateAlienHandler(); if (!alienHandler) return; cout<<" Got alien handler"<<endl; AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); mgr->SetGridHandler(alienHandler); /* // For centrality Selection: Requires input event handler. gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(); taskCentrality->SetPass(2); // remember to set the pass you are processing!!! */ // My Task gROOT->LoadMacro("AliAnalysisFBMultFluct.cxx++g"); AliAnalysisTask *task = new AliAnalysisFBMultFluct("TaskFBGrid"); // task->SelectCollisionCandidates(AliVEvent::kMB) // Added for minbias trigger on 3Jun14 // task->SelectCollisionCandidates(AliVEvent::kCentral) // Added for minbias trigger on 3Jun14 mgr->AddTask(task); /* AliESDInputHandler* esdH = new AliESDInputHandler; mgr->SetInputEventHandler(esdH); AliMCEventHandler *mc = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mc); TChain *chain = new TChain("aodTree"); // chain->Add("/Users/sadhanadash/QA/AliESDs.root"); chain->Add("/Users/rashmi/ALICE/InitFluct/alice/data/2010/LHC11h/000170388/ESDs/pass2_muon/AOD/132/AliAOD.root"); // chain->Add("/Users/rashmi/ALICE/InitFluct/alice/data/2011/LHC11h/000170388/ESDs/pass2_muon/AOD/132/AliESDs.root"); chain->Add("AliESDs.root"); */ // AliAODInputHandler* aodH = new AliAODInputHandler; AliVEventHandler* aodH = new AliAODInputHandler; mgr->SetInputEventHandler(aodH); cout<<" SetInputEventHandler"<<endl; // TChain *chain = new TChain("aodTree"); //alice/data/2010/LHC10h/000139510/ESDs/pass2/AOD160/0001 //chain->Add("AODfile/139510/AliAOD.root"); // chain->Add("pass2/137161/1/AliAOD.root"); // chain->Add("pass2/137161/2/AliAOD.root"); // chain->GetListOfFiles()->Print(); // Create containers for input/output AliAnalysisDataContainer *coutput = // mgr->CreateContainer("coutput", TObjArray::Class(), // mgr->CreateContainer("coutput", TList::Class(), // AliAnalysisManager::kOutputContainer, "MC.AOD.root" ); mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "AOD.DATA.root" ); AliAnalysisDataContainer *cTree = mgr->CreateContainer("cTree",TTree::Class(),AliAnalysisManager::kOutputContainer,"AOD.DATA.root"); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task,1,coutput); mgr->ConnectOutput(task,2,cTree); /* mgr->CreateContainer("cinput",TFile::Class(),1,"AOD.137161.input.root"); mgr->ConnectInput(task,2,cinput); */ mgr->SetDebugLevel(1); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); cout<<" Starting Analysis now"<<endl; // mgr->StartAnalysis("local",chain); mgr->StartAnalysis("grid"); }
//______________________________________________________________________________ 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 AODtrainsim(Int_t merge=0) { // Main analysis train macro. // merge = 0: production // merge = 1: intermediate merging // merge = 2: final merging + terminate // merge = 3: terminate only if (merge) { TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("AODtrainsim.C", "No grid connection"); return; } } // Set temporary merging directory to current one gSystem->Setenv("TMPDIR", gSystem->pwd()); // Set temporary compilation directory to current one gSystem->SetBuildDir(gSystem->pwd(), kTRUE); printf("==================================================================\n"); printf("=========== RUNNING FILTERING TRAIN ==========\n"); printf("==================================================================\n"); printf("= Configuring analysis train for: =\n"); if (usePhysicsSelection) printf("= Physics selection =\n"); if (iESDfilter) printf("= ESD filter =\n"); if (iMUONcopyAOD) printf("= MUON copy AOD =\n"); // Load common libraries and set include path gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_PHYSICS/include"); // Make the analysis manager and connect event handlers AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train"); if (useSysInfo) mgr->SetNSysInfo(100); // Load ParFiles if (!LoadAnalysisLibraries()) { ::Error("AODtrainsim.C", "Could not load analysis libraries"); return; } // Create input handler (input container created automatically) // ESD input handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); // Monte Carlo handler if (useMC) { AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetReadTR(useTR); } // AOD output container, created automatically when setting an AOD handler if (iAODhandler) { // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); mgr->SetOutputEventHandler(aodHandler); } // Debugging if needed if (useDBG) mgr->SetDebugLevel(3); AddAnalysisTasks(merge); if (merge) { if (merge < 3) AODmerge(); if (merge > 1) { mgr->InitAnalysis(); mgr->SetGridHandler(new AliAnalysisAlien()); mgr->StartAnalysis("grid terminate",0); } return; } // Run the analysis // TChain *chain = CreateChain(); if (!chain) return; TStopwatch timer; timer.Start(); mgr->SetSkipTerminate(kTRUE); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } timer.Print(); }
//________________________________________________________________ void 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 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 runTask(Float_t etamax=0.5,const char * incollection = 0, const char * outfile = "dndeta.root", Bool_t skipNorm = kFALSE) { // for running with root only gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libSTEERBase"); gSystem->Load("libESD"); gSystem->Load("libAOD"); // load analysis framework gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); TChain * chain = new TChain ("TE"); if (incollection == 0) { chain->Add("galice.root"); } else if (TString(incollection).Contains("xml")){ TGrid::Connect("alien://"); TAlienCollection * coll = TAlienCollection::Open (incollection); while(coll->Next()){ chain->Add(TString("alien://")+coll->GetLFN()); } } else { ifstream file_collect(incollection); TString line; while (line.ReadLine(file_collect) ) { chain->Add(line.Data()); } } chain->GetListOfFiles()->Print(); // for includes use either global setting in $HOME/.rootrc // ACLiC.IncludePaths: -I$(ALICE_ROOT)/include // or in each macro gSystem->AddIncludePath("-I$ALICE_ROOT/include"); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("dNdeta"); AliVEventHandler* esdH = new AliESDInputHandler; ((AliESDInputHandler*)esdH)->SetReadFriends(kFALSE); mgr->SetInputEventHandler(esdH); // Create tasks gROOT->LoadMacro("AliAnalysisTaskdNdetaMC.cxx++g"); AliAnalysisTask *task1 = new AliAnalysisTaskdNdetaMC("TaskdNdeta"); ((AliAnalysisTaskdNdetaMC*)task1)->SetEtaMax(etamax); if (skipNorm) ((AliAnalysisTaskdNdetaMC*)task1)->SkipNormalization(); // Enable MC event handler AliMCEventHandler* handler = new AliMCEventHandler; handler->SetReadTR(kFALSE); mgr->SetMCtruthEventHandler(handler); // Add tasks mgr->AddTask(task1); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, outfile); // Connect input/output mgr->ConnectInput(task1, 0, cinput); mgr->ConnectOutput(task1, 1, coutput1); // Enable debug printouts mgr->SetDebugLevel(0); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("local", chain); }
// const char* cDataType = "AOD", // set the analysis type, AOD or ESD //################################################## AliAnalysisManager* EmcalJetCDF ( const char* cRunPeriod = "LHC11d", // set the run period const char* cLocalFiles = "data.txt", // set the local list file const Int_t arg_sel_chg = 3145763, // "mykEMC_noGA", // physics selection const Int_t arg_sel_full = 3145763, // "mykEMC_noGA", // physics selection const Int_t mgr_mode = 0, // local = 0, proof = 1, grid = 2, mixing = 3 const Int_t alien_mode = 0, // test = 0, offline = 1, submit = 2, merge = 3, full = 4 const char* cTaskName = "CDFJets", // sets name of task manager unsigned int iNumFiles = 100, // numger of files to process from list file unsigned int iNumEvents = 999999999, // number of events to be analyzed bool bDoChargedJets = true, // enable charge jets bool bDoFullJets = false // enable full jets ) { //Load needed libs TString ListLibs = ""; // string list of loaded libs TString ListLibsExtra = ""; // string list of loaded extra libs LoadLibs( ListLibs, ListLibsExtra ); AnalysisType ManagerMode = static_cast<AnalysisType>(mgr_mode); PluginType PluginMode = static_cast<PluginType>(alien_mode); namespace CDF = PWGJE::EMCALJetTasks::AliAnalysisTaskEmcalJetCDF_NS; // shortcut to task namespace unsigned int kGridFilesPerJob = iNumFiles; // Maximum number of files per job (gives size of AOD) unsigned int kTTL = 64800 ; // Time To Live; 18h = 64800; 12h = 43200 bool bDoBackgroundSubtraction = true; bool bDoEmbedding = false; // Embeded Configuration options // Embedding files list const TString embeddedFilesList = "aodFilesEmbed.txt"; // If true, events that are not selected in the PbPb will not be used for embedding. // This ensures that good embedded events are not wasted on bad PbPb events. const bool internalEventSelection = true; // Do jet matching const bool useJetTagger = true; TString sGridMode ("test"); if ( PluginMode == PluginType::offline ) { sGridMode = "offline"; } if ( PluginMode == PluginType::submit ) { sGridMode = "submit"; } if ( PluginMode == PluginType::merge ) { sGridMode = "merge"; } if ( PluginMode == PluginType::full ) { sGridMode = "full"; } const char* cGridMode = sGridMode.Data(); TString sAnalysisType ("local"); if ( ManagerMode == AnalysisType::proof ) { sAnalysisType = "proof"; } if ( ManagerMode == AnalysisType::grid ) { sAnalysisType = "grid"; } if ( ManagerMode == AnalysisType::mixing ) { sAnalysisType = "mix"; } const char* cAnalysisType = sAnalysisType.Data(); cout << std::endl << ">>>>>>>> ManagerMode : " << ManagerMode << " ; String value : " << cAnalysisType << std::endl << ">>>>>>>> PluginMode : " << PluginMode << " ; String value : " << cGridMode << std::endl << std::endl; //--------------------------------------------------------------------------------------------- TRegexp false_regex ("[f,F][a,A][l,L][s,S][e,E]"); TRegexp true_regex ("[t,T][r,R][u,U][e,E]"); TRegexp enable_regex ("[e,E][n,N][a,A][b,B][l,L][e,E]"); TRegexp disable_regex ("[d,D][i,I][s,S][a,A][b,B][l,L][e,E]"); bool bDoSample = false; TString ENV_doSAMPLE = gSystem->Getenv("CDF_doSAMPLE"); if (!ENV_doSAMPLE.IsNull() && ( ENV_doSAMPLE.EqualTo("0") || ENV_doSAMPLE.Contains(false_regex) ) ) { bDoSample = kFALSE; } if (!ENV_doSAMPLE.IsNull() && ( ENV_doSAMPLE.EqualTo("1") || ENV_doSAMPLE.Contains(true_regex) ) ) { bDoSample = kTRUE; } bool bDoCDF = true; TString ENV_doCDF = gSystem->Getenv("CDF_doCDF"); if (!ENV_doCDF.IsNull() && ( ENV_doCDF.EqualTo("0") || ENV_doCDF.Contains(false_regex) ) ) { bDoCDF = kFALSE; } if (!ENV_doCDF.IsNull() && ( ENV_doCDF.EqualTo("1") || ENV_doCDF.Contains(true_regex) ) ) { bDoCDF = kTRUE; } // ###### DEBUG ###### Int_t debug = 0 ; // kFatal = 0, kError, kWarning, kInfo, kDebug, kMaxType UInt_t mgr_debug = 0 ; // AliAnalysisManager debug level UInt_t kUseSysInfo = 0 ; // activate debugging TString ENV_DEBUG = gSystem->Getenv("CDF_DEBUG"); if (!ENV_DEBUG.IsNull() && ENV_DEBUG.IsDigit() ) { debug = ENV_DEBUG.Atoi(); } TString ENV_DEBUG_MGR = gSystem->Getenv("CDF_DEBUG_MGR"); if (!ENV_DEBUG_MGR.IsNull() && ENV_DEBUG_MGR.IsDigit() ) { mgr_debug = ENV_DEBUG_MGR.Atoi(); } TString ENV_NSYSINFO = gSystem->Getenv("CDF_NSYSINFO"); if (!ENV_NSYSINFO.IsNull() && ENV_NSYSINFO.IsDigit() ) { kUseSysInfo = ENV_NSYSINFO.Atoi(); } if ( debug == 0 ) { AliLog::SetGlobalLogLevel ( AliLog::kFatal ); } if ( debug == 1 ) { AliLog::SetGlobalLogLevel ( AliLog::kError ); } if ( debug == 2 ) { AliLog::SetGlobalLogLevel ( AliLog::kWarning ); } if ( debug == 3 ) { AliLog::SetGlobalLogLevel ( AliLog::kInfo ); } if ( debug >= 4 ) { AliLog::SetGlobalLogLevel ( AliLog::kDebug ); } // Progress bar Bool_t bUseProgBar = kFALSE; // N.B. !! if true will set fDebug to 0 TString ENV_USEPROGBAR = gSystem->Getenv("PROGRESSBAR"); if (!ENV_USEPROGBAR.IsNull() && ( ENV_USEPROGBAR.EqualTo("1") || ENV_USEPROGBAR.Contains(true_regex) ) ) { bUseProgBar = kTRUE; } //################################################## // AliEN plugin variables //################################################## const char* curdir = gSystem->BaseName(gSystem->pwd()); TString kJobTag (curdir); TString execArgs (" -l -b -q -x"); TString exec = // "aliroot"; "root.exe"; TString kPluginExecutableCommand = exec + execArgs; TString kAliPhysicsVersion = "vAN-20190304-1"; // == grid plugin files rules TString kGridExtraFiles = ""; // extra files that will be added to the input list in the JDL TString kGridMergeExclude = "AliAOD.root AliAOD.Jets.root"; // Files that should not be merged TString kGridOutputStorages = "disk=2"; // Make replicas on the storages // FILES USED IN MACRO TString kCommonOutputFileName = "AnalysisResults.root"; //-------------------- // PROOF SETTINGS //-------------------- TString kAAF = ""; Int_t kProofReset = 0; (void)kProofReset; Int_t kWorkers = 20; (void)kWorkers; Int_t kCores = 8 ; (void)kCores; // AliRoot mode among the list supported by the proof cluster. // TString kAlirootMode = "ALIROOT"; // STEERBase,ESD,AOD,ANALYSIS,ANALYSISalice (default aliroot mode) //############################################################ // const AliAnalysisTaskEmcal::EDataType_t kAod = AliAnalysisTaskEmcal::kAOD; // const AliAnalysisTaskEmcal::EDataType_t kEsd = AliAnalysisTaskEmcal::kESD; const AliJetContainer::EJetType_t fulljet = AliJetContainer::kFullJet; const AliJetContainer::EJetType_t chgjet = AliJetContainer::kChargedJet; const AliJetContainer::EJetAlgo_t antikt = AliJetContainer::antikt_algorithm; const AliJetContainer::EJetAlgo_t kt = AliJetContainer::kt_algorithm; const AliJetContainer::ERecoScheme_t recomb = AliJetContainer::pt_scheme; // kTPC, kTPCfid, kEMCAL, kEMCALfid, kDCAL, kDCALfid, kDCALonly, kDCALonlyfid, kPHOS, kPHOSfid, kUser const AliEmcalJet::JetAcceptanceType acc_chgjets = AliEmcalJet::kTPCfid; const AliEmcalJet::JetAcceptanceType acc_fulljets = AliEmcalJet::kEMCALfid; //############################################################ // data source name TString kDataSource (cLocalFiles); // label of dataset from InputData.C TString kGridDataSet (""); if ( ManagerMode == AnalysisType::grid ) { kGridDataSet = kDataSource;} //############################################################ // SETUP OF TRIGGERS const AliEmcalPhysicsSelection::EOfflineEmcalTypes mykEMCAL = AliEmcalPhysicsSelection::kEmcalOk; const AliVEvent::EOfflineTriggerTypes mykEMC = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE | AliVEvent::kEMCEGA); const AliVEvent::EOfflineTriggerTypes mykEMC_noGA = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE); const AliVEvent::EOfflineTriggerTypes mykMB = AliVEvent::kAnyINT; const AliVEvent::EOfflineTriggerTypes mykMB_central = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kCentral); const AliVEvent::EOfflineTriggerTypes mykMB_semicentral = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kSemiCentral); const AliVEvent::EOfflineTriggerTypes mykMB_mostcentral = static_cast<AliVEvent::EOfflineTriggerTypes>(AliVEvent::kAnyINT | AliVEvent::kCentral | AliVEvent::kSemiCentral); AliVEvent::EOfflineTriggerTypes kPhysSel = mykMB; //AliVEvent::kAnyINT; // physics selection // AliVEvent::EOfflineTriggerTypes kSel_tasks = mykMB; AliVEvent::EOfflineTriggerTypes kSel_chg = static_cast<AliVEvent::EOfflineTriggerTypes>(arg_sel_chg); AliVEvent::EOfflineTriggerTypes kSel_full = static_cast<AliVEvent::EOfflineTriggerTypes>(arg_sel_full); //############################################################ // Analysis manager AliAnalysisManager* pMgr = new AliAnalysisManager(cTaskName); pMgr->SetDebugLevel(mgr_debug); if ( kUseSysInfo > 0 ) { pMgr->SetNSysInfo ( kUseSysInfo ); } // actual runName in the form of LHCXXX.... TString sRunName; Bool_t kIsAOD = kTRUE; AliAnalysisTaskEmcal::EDataType_t iDataType = AliAnalysisTaskEmcal::kAOD; // assuming default is to process AOD TString file; AliAnalysisAlien* plugin = NULL; if ( ManagerMode == AnalysisType::grid ) { // start grid analysis // ( const char* gridMode, const char* tag, unsigned int nr_test_files, unsigned int TTL, const char* outdir, const char subworkdir, const char* extradirlvl); plugin = CreateAlienHandler(cGridMode, kJobTag.Data(), kGridFilesPerJob, kTTL); if ( !plugin ) { ::Error ( "runEMCalJetSampleTask.C - StartGridAnalysis", "plugin invalid" ); return NULL; } pMgr->SetGridHandler(plugin); // use this command to run the macro plugin->SetExecutableCommand(kPluginExecutableCommand.Data()); // AliPhysics version. plugin->SetAliPhysicsVersion ( kAliPhysicsVersion.Data() ); // Here you can set the (Ali)PHYSICS version you want to use gROOT->LoadMacro("InputData.C"); InputData(kGridDataSet); sRunName = CDF::GetPeriod( plugin->GetGridDataDir() ); file = CDF::GetFileFromPath(plugin->GetDataPattern()); if (file.Contains("AliESD")) { iDataType = AliAnalysisTaskEmcal::kESD; kIsAOD = kFALSE; } plugin->SetMergeExcludes(kGridMergeExclude.Data()); } if ( ManagerMode == AnalysisType::local ) { // start local analysis if ( kDataSource.IsNull() ) { Printf("You need to provide the list of local files!"); return NULL; } TChain* pChain = CDF::CreateChain(kDataSource.Data(), "auto", "", iNumFiles); if (!pChain) { std::cout << ">>>>>>>>>>>>>> CHAIN NOT CREATED <<<<<<<<<<<<<<" << std::endl; return NULL; } Printf("Setting local analysis for %d files from list %s, max events = %d", iNumFiles, kDataSource.Data(), iNumEvents); // get the path of first file file = pChain->GetFile()->GetEndpointUrl()->GetUrl(); sRunName = CDF::GetPeriod(file.Data()); // get the run name : first token beggining with lhc if ( CDF::GetFileFromPath(file).Contains("AliESD") ) { iDataType = AliAnalysisTaskEmcal::kESD; kIsAOD = kFALSE; } } TString sDataType ("AOD"); if (!kIsAOD) { sDataType = "ESD"; } std::cout << ">>> Analysis data type : " << sDataType.Data() << std::endl; // name of de period (for MC is the name of "achored to" production) TString sRunPeriod (cRunPeriod); sRunPeriod.ToLower(); bool isMC = false; isMC = CDF::PeriodIsMC(sRunName.Data()); // EMCAL corrections task configuration file TString EMCALcfg ("CDF_CorrectionsConf.yaml"); if (isMC) {EMCALcfg = "CDF_MC_CorrectionsConf.yaml";} if ( !kGridExtraFiles.IsNull() ) {kGridExtraFiles += " ";} kGridExtraFiles += EMCALcfg; AliAnalysisTaskEmcal::BeamType iBeamType = AliAnalysisTaskEmcal::kpp; Bool_t bIsRun2 = kFALSE; if (sRunPeriod.Length() == 6 && (sRunPeriod.BeginsWith("lhc15") || sRunPeriod.BeginsWith("lhc16") || sRunPeriod.BeginsWith("lhc17") || sRunPeriod.BeginsWith("lhc18") ) ) { bIsRun2 = kTRUE; } if (sRunPeriod == "lhc10h" || sRunPeriod == "lhc11h" || sRunPeriod == "lhc15o" || sRunPeriod == "lhc17n" ) { iBeamType = AliAnalysisTaskEmcal::kAA; } if (sRunPeriod == "lhc12g" || sRunPeriod == "lhc13b" || sRunPeriod == "lhc13c" || sRunPeriod == "lhc13d" || sRunPeriod == "lhc13e" || sRunPeriod == "lhc13f" || sRunPeriod == "lhc16q" || sRunPeriod == "lhc16r" || sRunPeriod == "lhc16s" || sRunPeriod == "lhc16t" ) { iBeamType = AliAnalysisTaskEmcal::kpA; } Double_t kGhostArea = 0.01; if (iBeamType != AliAnalysisTaskEmcal::kpp) { kGhostArea = 0.005; } AliTrackContainer::SetDefTrackCutsPeriod(sRunPeriod); Printf("Default track cut period set to: %s", AliTrackContainer::GetDefTrackCutsPeriod().Data()); Bool_t bDoEmcalCorrections = kFALSE; if (bDoFullJets) { bDoEmcalCorrections = kTRUE; } // ### Containers and string definitions TString name_tracks = "usedefault"; TString name_clusters = "usedefault"; TString name_cells = "usedefault"; // Set centrality estimator for centrality task TString cent_est_chg = "V0M" ; TString cent_est_full = "V0M" ; TString mc_container (""); if (isMC) { mc_container = "mcparticles"; } /* // General input object names TString tracksName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kTrack); TString clustersName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCluster); TString emcalCellsName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCaloCells); // Combined (PbPb + embedded det level) TString emcalCellsCombined = emcalCellsName + "Combined"; TString clustersCombined = clustersName + "Combined"; */ //########################## // TASKS DEFINITIONS ### //########################## AliAODInputHandler* pAODHandler = NULL; AliESDInputHandler* pESDHandler = NULL; if (kIsAOD) { pAODHandler = AliAnalysisTaskEmcal::AddAODHandler(); } else { pESDHandler = AliAnalysisTaskEmcal::AddESDHandler(); } // CDBconnect task AliTaskCDBconnect* taskCDB = AliTaskCDBconnect::AddTaskCDBconnect(); taskCDB->SetFallBackToRaw(kTRUE); // Needed for the moment as not all grid sites do support cvmfs OCDB for the moment if (!taskCDB) { std::cout << "--------->>>> taskCDB :: could not connect!!!! CHECK CVMFS" << std::endl; return NULL;} // Physics selection task AliPhysicsSelectionTask* pPhysSelTask = NULL; if (!kIsAOD) { // signature : (Bool_t mCAnalysisFlag = kFALSE, Bool_t applyPileupCuts = kFALSE, UInt_t deprecatedFlag2 = 0, Bool_t useSpecialOutput=kFALSE) pPhysSelTask = AliPhysicsSelectionTask::AddTaskPhysicsSelection(); } // Centrality task // The Run 2 condition is too restrictive, but until the switch to MultSelection is complete, it is the best we can do AliCentralitySelectionTask* pCentralityTask = NULL; if ( !kIsAOD && (iBeamType != AliAnalysisTaskEmcal::kpp && bIsRun2) ) { //signature : (Bool_t fillHistos=kTRUE, Bool_t aod=kFALSE) pCentralityTask = AliCentralitySelectionTask::AddTaskCentrality(kFALSE, kIsAOD); pCentralityTask->SelectCollisionCandidates(AliVEvent::kAny); } // AliMultSelection AliMultSelectionTask* pMultSelTask = NULL; if (bIsRun2) { // signature : ( Bool_t lCalibration = kFALSE, TString lExtraOptions = "", Int_t lNDebugEstimators = 1, const TString lMasterJobSessionFlag = "") pMultSelTask = AliMultSelectionTask::AddTaskMultSelection(); pMultSelTask->SelectCollisionCandidates(AliVEvent::kAny); } // Embedding task if (bDoEmbedding) { // Debug options //AliLog::SetClassDebugLevel("AliAnalysisTaskEmcalEmbeddingHelper", AliLog::kDebug+0); // Setup embedding task AliAnalysisTaskEmcalEmbeddingHelper * embeddingHelper = AliAnalysisTaskEmcalEmbeddingHelper::AddTaskEmcalEmbeddingHelper(); embeddingHelper->SelectCollisionCandidates(kPhysSel); // The pt hard bin should be set via the filenames in this file // If using a file pattern, it could be configured via embeddingHelper->SetPtHardBin(ptHardBin); embeddingHelper->SetFileListFilename(embeddedFilesList.Data()); // Some example settings for LHC12a15e_fix (anchored to LHC11h) embeddingHelper->SetNPtHardBins(11); embeddingHelper->SetMCRejectOutliers(); // Setup internal event selection and additional configuration options embeddingHelper->SetConfigurationPath("EmbeddingConfigurationExample.yaml"); // Initialize the task to complete the setup. embeddingHelper->Initialize(); } // EMCal corrections AliEmcalCorrectionTask* correctionTask = NULL; if (bDoEmcalCorrections) { // Configuration of the Correction Task is handled via a YAML file, which is setup below // signature : (TString suffix) correctionTask = AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask(); // correctionTask = AliEmcalCorrectionTask::ConfigureEmcalCorrectionTaskOnLEGOTrain(suffix); correctionTask->SelectCollisionCandidates(kPhysSel); correctionTask->SetUseNewCentralityEstimation(bIsRun2); correctionTask->SetForceBeamType(static_cast<AliEmcalCorrectionTask::BeamType>(iBeamType)); // Configure and initialize correctionTask->SetUserConfigurationFilename( EMCALcfg.Data() ); //correctionTask->SetUserConfigurationFilename("alien:///alice/cern.ch/user/m/mfasel/EMCALCorrectionConfig/ConfigDataPWGJEhighClusterThresholds.yaml"); correctionTask->Initialize(true); } // TObjArray correctionTasks; // // // Create the Correction Tasks // // "data" corresponds to the PbPb level // // "embed" corresponds to the embedded detector level // // "combined" corresponds to the hybrid (PbPb + embedded detector) level // correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("data")); // correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("embed")); // // It is important that combined is last! // correctionTasks.Add(AliEmcalCorrectionTask::AddTaskEmcalCorrectionTask("combined")); // // // Loop over all of the correction tasks to configure them // AliEmcalCorrectionTask * tempCorrectionTask = 0; // TIter next(&correctionTasks); // while (( tempCorrectionTask = static_cast<AliEmcalCorrectionTask *>(next()))) { // tempCorrectionTask->SelectCollisionCandidates(kPhysSel); // // Configure centrality // tempCorrectionTask->SetNCentBins(5); // tempCorrectionTask->SetUseNewCentralityEstimation(bIsRun2); // tempCorrectionTask->SetUserConfigurationFilename("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/EMCalCorrectionTaskEmbeddingExample.yaml"); // // tempCorrectionTask->Initialize(true); // } // Background TString sRhoChName; TString sRhoFuName; AliAnalysisTaskRho* pRhoTask = NULL; if ( bDoBackgroundSubtraction && iBeamType != AliAnalysisTaskEmcal::kpp ) { sRhoChName = "Rho"; sRhoFuName = "Rho_Scaled"; AliEmcalJetTask* pKtChJetTask = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", kt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 0., kFALSE, kFALSE); pKtChJetTask->SelectCollisionCandidates(kPhysSel); //signature : // const char* nTracks = "usedefault", const char* nClusters = "usedefault", const char* nRho = "Rho", Double_t jetradius = 0.2, UInt_t acceptance = AliEmcalJet::kTPCfid, // AliJetContainer::EJetType_t jetType = AliJetContainer::kChargedJet, const Bool_t histo = kFALSE, AliJetContainer::ERecoScheme_t rscheme = AliJetContainer::pt_scheme, const char* suffix = "" pRhoTask = AliAnalysisTaskRho::AddTaskRhoNew(name_tracks.Data(), name_clusters.Data(), sRhoChName, 0.4); pRhoTask->SetExcludeLeadJets(2); pRhoTask->SelectCollisionCandidates(kPhysSel); pRhoTask->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection); if (bDoFullJets) { TString sFuncPath = "alien:///alice/cern.ch/user/s/saiola/LHC11h_ScaleFactorFunctions.root"; TString sFuncName = "LHC11h_HadCorr20_ClustersV2"; pRhoTask->LoadRhoFunction(sFuncPath, sFuncName); } } // Find Charged jets AliEmcalJetTask* pChJet02Task = NULL; AliEmcalJetTask* pChJet04Task = NULL; AliEmcalJetTask* pChJet02Task_MC = NULL; AliEmcalJetTask* pChJet04Task_MC = NULL; if (bDoChargedJets) { pChJet02Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", antikt, 0.2, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pChJet02Task->SelectCollisionCandidates(kSel_chg); pChJet04Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), "", antikt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pChJet04Task->SelectCollisionCandidates(kSel_chg); if (isMC) { pChJet02Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), "", antikt, 0.2, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pChJet02Task_MC->SelectCollisionCandidates(kSel_chg); if (bDoEmbedding) { pChJet02Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection); AliParticleContainer* partLevelTracks02Task_MC = pChJet02Task_MC->GetParticleContainer(0); // Called Embedded, but really just means get from an external event! partLevelTracks02Task_MC->SetIsEmbedding(kTRUE); } pChJet04Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), "", antikt, 0.4, chgjet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pChJet04Task_MC->SelectCollisionCandidates(kSel_chg); if (bDoEmbedding) { pChJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection); AliParticleContainer* partLevelTracks04Task_MC = pChJet04Task_MC->GetParticleContainer(0); // Called Embedded, but really just means get from an external event! partLevelTracks04Task_MC->SetIsEmbedding(kTRUE); } } // isMC } // bDoChargedJets // Find Full jets AliEmcalJetTask* pFuJet02Task = NULL; AliEmcalJetTask* pFuJet04Task = NULL; AliEmcalJetTask* pFuJet02Task_MC = NULL; AliEmcalJetTask* pFuJet04Task_MC = NULL; if (bDoFullJets) { pFuJet02Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), name_clusters.Data(), antikt, 0.2, fulljet, 0.15, 0.30, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pFuJet02Task->SelectCollisionCandidates(kSel_full); pFuJet02Task->GetClusterContainer(0)->SetDefaultClusterEnergy(AliVCluster::kHadCorr); pFuJet04Task = AliEmcalJetTask::AddTaskEmcalJet(name_tracks.Data(), name_clusters.Data(), antikt, 0.4, fulljet, 0.15, 0.30, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pFuJet04Task->SelectCollisionCandidates(kSel_full); pFuJet04Task->GetClusterContainer(0)->SetDefaultClusterEnergy(AliVCluster::kHadCorr); if (isMC) { pFuJet02Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), name_clusters.Data(), antikt, 0.2, fulljet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pFuJet02Task_MC->SelectCollisionCandidates(kSel_chg); if (bDoEmbedding) { pFuJet02Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection); AliParticleContainer* partLevelTracks02Task_MC = pFuJet02Task_MC->GetParticleContainer(0); // Called Embedded, but really just means get from an external event! partLevelTracks02Task_MC->SetIsEmbedding(kTRUE); } pFuJet04Task_MC = AliEmcalJetTask::AddTaskEmcalJet(mc_container.Data(), name_clusters.Data(), antikt, 0.4, fulljet, 0.15, 0, kGhostArea, recomb, "Jet", 1., kFALSE, kFALSE); pFuJet04Task_MC->SelectCollisionCandidates(kSel_chg); pFuJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection); if (bDoEmbedding) { pFuJet04Task_MC->SetRecycleUnusedEmbeddedEventsMode(internalEventSelection); AliParticleContainer* partLevelTracks04Task_MC = pFuJet04Task_MC->GetParticleContainer(0); // Called Embedded, but really just means get from an external event! partLevelTracks04Task_MC->SetIsEmbedding(kTRUE); } } // isMC } // bDoFullJets //////////////////////// // ANALYSIS TASKS // //////////////////////// // Sample task - charge jets AliAnalysisTaskEmcalJetSample* sampleTaskchg = NULL; if (bDoSample && bDoChargedJets) { sampleTaskchg = AliAnalysisTaskEmcalJetSample::AddTaskEmcalJetSample(name_tracks.Data(), "", "", "SMPCHG"); sampleTaskchg->SetHistoBins(600, 0, 300); sampleTaskchg->SelectCollisionCandidates(kSel_chg); sampleTaskchg->SetDebugLevel(debug); AliParticleContainer* sampleTaskchg_partCont = sampleTaskchg->GetParticleContainer(0); sampleTaskchg_partCont->SetParticlePtCut(0.15); if (bDoEmbedding) { sampleTaskchg_partCont->SetIsEmbedding(kTRUE); } if ( pMultSelTask ) { sampleTaskchg->SetUseNewCentralityEstimation(bIsRun2); sampleTaskchg->SetNCentBins(5); } } // Sample task - full jets AliAnalysisTaskEmcalJetSample* sampleTaskfull = NULL; if (bDoSample && bDoFullJets) { sampleTaskfull = AliAnalysisTaskEmcalJetSample::AddTaskEmcalJetSample(name_tracks.Data(), name_clusters.Data(), name_cells.Data(), "SMPFULL"); sampleTaskfull->SetHistoBins(600, 0, 300); sampleTaskfull->SelectCollisionCandidates(kSel_full); sampleTaskfull->SetDebugLevel(debug); AliParticleContainer* sampleTaskfull_partCont = sampleTaskfull->GetParticleContainer(0); sampleTaskfull_partCont->SetParticlePtCut(0.15); AliClusterContainer* sampleTaskfull_clusCont = sampleTaskfull->GetClusterContainer(0); sampleTaskfull_clusCont->SetClusECut(0.); sampleTaskfull_clusCont->SetClusPtCut(0.); sampleTaskfull_clusCont->SetClusNonLinCorrEnergyCut(0.); sampleTaskfull_clusCont->SetClusHadCorrEnergyCut(0.30); sampleTaskfull_clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr); if (bDoEmbedding) { sampleTaskfull_partCont->SetIsEmbedding(kTRUE); sampleTaskfull_clusCont->SetIsEmbedding(kTRUE); } if ( pMultSelTask ) { sampleTaskfull->SetUseNewCentralityEstimation(bIsRun2); sampleTaskfull->SetNCentBins(5); } } //### CDF task - charged jets AliAnalysisTaskEmcalJetCDF* anaTaskCDFchg = NULL; AliAnalysisTaskEmcalJetCDF* anaTaskCDFchg_MC = NULL; if (bDoCDF && bDoChargedJets) { anaTaskCDFchg = CDF::AddTaskEmcalJetCDF ( name_tracks.Data(), "", "", "", "CDFchg" ); anaTaskCDFchg->SetHistoBins(600, 0, 300); anaTaskCDFchg->SelectCollisionCandidates(kSel_chg); anaTaskCDFchg->SetDebugLevel(debug); AliParticleContainer* anaTaskCDFchg_partCont = anaTaskCDFchg->GetParticleContainer(0); anaTaskCDFchg_partCont->SetParticlePtCut(0.15); if (bDoEmbedding) { anaTaskCDFchg_partCont->SetIsEmbedding(kTRUE); } if ( pMultSelTask ) { anaTaskCDFchg->SetUseNewCentralityEstimation(bIsRun2); anaTaskCDFchg->SetNCentBins(5); anaTaskCDFchg->SetCentralityEstimator(cent_est_chg.Data()); } //################################################# if (isMC){ anaTaskCDFchg_MC = CDF::AddTaskEmcalJetCDF ( mc_container.Data(), "", "", "", "CDFchgMC" ); anaTaskCDFchg_MC->SetHistoBins(600, 0, 300); anaTaskCDFchg_MC->SelectCollisionCandidates(kSel_chg); anaTaskCDFchg_MC->SetDebugLevel(debug); AliParticleContainer* anaTaskCDFchg_partCont_MC = anaTaskCDFchg_MC->GetMCParticleContainer(0); anaTaskCDFchg_partCont->SetParticlePtCut(0.15); if (bDoEmbedding) { anaTaskCDFchg_partCont_MC->SetIsEmbedding(kTRUE); } if ( pMultSelTask ) { anaTaskCDFchg_MC->SetUseNewCentralityEstimation(bIsRun2); anaTaskCDFchg_MC->SetNCentBins(5); anaTaskCDFchg_MC->SetCentralityEstimator(cent_est_chg.Data()); } } } //### CDF task - full jets AliAnalysisTaskEmcalJetCDF* anaTaskCDFfull = NULL; if (bDoCDF && bDoFullJets) { anaTaskCDFfull = CDF::AddTaskEmcalJetCDF ( name_tracks.Data(), name_clusters.Data(), name_cells.Data(), mc_container.Data(), "CDFfull" ); anaTaskCDFfull->SetHistoBins(600, 0, 300); anaTaskCDFfull->SelectCollisionCandidates(kSel_full); anaTaskCDFfull->SetDebugLevel(debug); AliParticleContainer* anaTaskCDFfull_partCont = anaTaskCDFfull->GetParticleContainer(0); anaTaskCDFfull_partCont->SetParticlePtCut(0.15); AliClusterContainer* anaTaskCDFfull_clusCont = anaTaskCDFfull->GetClusterContainer(0); anaTaskCDFfull_clusCont->SetClusECut(0.); anaTaskCDFfull_clusCont->SetClusPtCut(0.); anaTaskCDFfull_clusCont->SetClusNonLinCorrEnergyCut(0.); anaTaskCDFfull_clusCont->SetClusHadCorrEnergyCut(0.30); anaTaskCDFfull_clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr); if (bDoEmbedding) { anaTaskCDFfull_partCont->SetIsEmbedding(kTRUE); anaTaskCDFfull_clusCont->SetIsEmbedding(kTRUE); } if ( pMultSelTask ) { anaTaskCDFfull->SetUseNewCentralityEstimation(bIsRun2); anaTaskCDFfull->SetNCentBins(5); anaTaskCDFfull->SetCentralityEstimator(cent_est_full.Data()); } } //######################## // ANALYSIS TASKS - CONTAINERS SETUP //######################## // AliEmcalJetTask* pChJet02Task_MC = NULL; // AliEmcalJetTask* pChJet04Task_MC = NULL; // add jet containers to CDF task for charged jets if (bDoChargedJets && bDoCDF) { AliJetContainer* jetcont_chg = NULL; for ( Float_t fi = 0 ; fi<=100 ; fi+=10) { // CHG JETS 0.2 jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet"); CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0); // CHG JETS 0.4 jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet"); CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0); if (isMC) { // CHG JETS MC 0.2 jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet02Task_MC, acc_chgjets); CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0); // CHG JETS MC 0.4 jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet04Task_MC, acc_chgjets); CDF::jetContSetParams (jetcont_chg, fi, fi+10, 0, 0); } } jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet"); CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0); jetcont_chg = anaTaskCDFchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet"); CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0); if (isMC) { jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet02Task_MC, acc_chgjets); CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0); jetcont_chg = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFchg_MC), pChJet04Task_MC, acc_chgjets); CDF::jetContSetParams (jetcont_chg, 1., 500., 0, 0); } jetcont_chg = NULL; } // add jet containers to CDF task for full jets if (bDoFullJets && bDoCDF) { AliJetContainer* jetcont_full = NULL; for ( Float_t fi = 0 ; fi<=100 ; fi+=10) { // FULL JETS 0.2 jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet"); CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 2); // FULL JETS 0.4 jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet"); CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 2); if (isMC) { // CHG JETS MC 0.2 jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet02Task_MC, acc_fulljets); CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 0); // CHG JETS MC 0.4 jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet04Task_MC, acc_fulljets); CDF::jetContSetParams (jetcont_full, fi, fi+10, 0, 0); } } jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet"); CDF::jetContSetParams (jetcont_full, 1., 500., 0, 2); jetcont_full = anaTaskCDFfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet"); CDF::jetContSetParams (jetcont_full, 1., 500., 0, 2); if (isMC) { jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet02Task_MC, acc_fulljets); CDF::jetContSetParams (jetcont_full, 1., 500., 0, 0); jetcont_full = AddJetContainerJetTask(dynamic_cast<AliAnalysisTaskEmcalJetCDF*>(anaTaskCDFfull_MC), pFuJet04Task_MC, acc_fulljets); CDF::jetContSetParams (jetcont_full, 1., 500., 0, 0); } jetcont_full = NULL; } // add jet containers to sample task for charged jets if (bDoChargedJets && bDoSample) { AliJetContainer* jetCont02chg_sample = sampleTaskchg->AddJetContainer(chgjet, antikt, recomb, 0.2, acc_chgjets, "Jet"); AliJetContainer* jetCont04chg_sample = sampleTaskchg->AddJetContainer(chgjet, antikt, recomb, 0.4, acc_chgjets, "Jet"); if (iBeamType != AliAnalysisTaskEmcal::kpp) { jetCont02chg_sample->SetRhoName(sRhoChName); jetCont02chg_sample->SetPercAreaCut(0.6); jetCont04chg_sample->SetRhoName(sRhoChName); jetCont04chg_sample->SetPercAreaCut(0.6); } } // add jet containers to sample task for full jets if (bDoFullJets && bDoSample) { AliJetContainer* jetCont02full_sample = sampleTaskfull->AddJetContainer(fulljet, antikt, recomb, 0.2, acc_fulljets, "Jet"); AliJetContainer* jetCont04full_sample = sampleTaskfull->AddJetContainer(fulljet, antikt, recomb, 0.4, acc_fulljets, "Jet"); if (iBeamType != AliAnalysisTaskEmcal::kpp) { jetCont02full_sample->SetRhoName(sRhoFuName); jetCont02full_sample->SetPercAreaCut(0.6); jetCont04full_sample->SetRhoName(sRhoFuName); jetCont04full_sample->SetPercAreaCut(0.6); } } TObjArray* tasks_list = pMgr->GetTasks(); TIter task_iter (tasks_list); AliAnalysisTaskSE* task = NULL; while (( task = dynamic_cast<AliAnalysisTaskSE*>(task_iter.Next()) )) { if (task->InheritsFrom("AliAnalysisTaskEmcal")) { Printf("Setting beam type %d for task %s", iBeamType, static_cast<AliAnalysisTaskEmcal*>(task)->GetName()); static_cast<AliAnalysisTaskEmcal*>(task)->SetForceBeamType(iBeamType); } } // Let's start ######################################################################################################### if ( !pMgr->InitAnalysis() ) { std::cout << ">>>>>>>>>>>>>> AliAnalysisManager Initialising FAILED!!! " << std::endl; return NULL; } std::cout << "##-->> Initialising Analysis :: Status :" << std::endl; pMgr->PrintStatus(); pMgr->SetUseProgressBar(bUseProgBar, 100); // task profiling if ( kUseSysInfo > 0 ) { for ( int i = 0; i < pMgr->GetTopTasks()->GetEntries(); i++ ) { pMgr->ProfileTask (i); } } CDF::SaveManager("train.root"); if ( ManagerMode == AnalysisType::local ) { // start local analysis // enable class level debugging for these classes if ( debug > 2 ) { // pMgr->AddClassDebug("AliJetContainer", 100); // pMgr->AddClassDebug("AliEmcalJetTask", 100); if (bDoCDF) { pMgr->AddClassDebug("AliAnalysisTaskEmcalJetCDF", 100); } if (bDoSample) { pMgr->AddClassDebug("AliAnalysisTaskEmcalJetSample", 100); } } TChain* pChain = CDF::CreateChain(kDataSource.Data(), "auto", "", iNumFiles); if (!pChain) { std::cout << ">>>>>>>>>>>>>> CHAIN NOT CREATED <<<<<<<<<<<<<<" << std::endl; return NULL; } // start analysis Printf("Starting LOCAL Analysis..."); pMgr->StartAnalysis( cAnalysisType, pChain, iNumEvents ); } if ( ManagerMode == AnalysisType::grid ) { // start grid analysis // start analysis Printf("Starting GRID Analysis..."); ListLibs += kGridExtraFiles; if ( ListLibs.Length() ) { plugin->SetAdditionalLibs ( ListLibs.Data() ); } if ( ListLibsExtra.Length() ) { plugin->SetAdditionalRootLibs ( ListLibsExtra.Data() ); } if ( PluginMode == PluginType::test ) { plugin->StartAnalysis(iNumEvents); } else { pMgr->SetDebugLevel(0); plugin->StartAnalysis(); } } cout << "END of EmcalJetCDF.C" << std::endl; return pMgr; }
//______________________________________________________________________________ void AODtrain(Int_t merge=0) { // Main analysis train macro. ProcessEnvironment(); UpdateFlags(); PrintSettings(); if (merge || doCDBconnect) { TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("AODtrain", "No grid connection"); return; } } // Set temporary merging directory to current one gSystem->Setenv("TMPDIR", gSystem->pwd()); // Set temporary compilation directory to current one gSystem->SetBuildDir(gSystem->pwd(), kTRUE); printf("==================================================================\n"); printf("=========== RUNNING FILTERING TRAIN ==========\n"); printf("=========== Collision System is %s ==========\n",CollisionSystem[iCollision]); printf("==================================================================\n"); printf("= Configuring analysis train for: =\n"); if (usePhysicsSelection) printf("= Physics selection =\n"); if (useTender) printf("= TENDER =\n"); if (iESDfilter) printf("= ESD filter =\n"); if (iMUONcopyAOD) printf("= MUON copy AOD =\n"); if (iJETAN) printf("= Jet analysis =\n"); if (iJETANdelta) printf("= Jet delta AODs =\n"); if (iPWGHFvertexing) printf("= PWGHF vertexing =\n"); if (iPWGDQJPSIfilter) printf("= PWGDQ j/psi filter =\n"); if (iPWGHFd2h) printf("= PWGHF D0->2 hadrons QA =\n"); // Make the analysis manager and connect event handlers AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train"); mgr->SetCacheSize(0); if (useSysInfo) { //mgr->SetNSysInfo(100); AliSysInfo::SetVerbose(kTRUE); } // Create input handler (input container created automatically) // ESD input handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); // Monte Carlo handler if (useMC) { AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetReadTR(useTR); } // AOD output container, created automatically when setting an AOD handler if (iAODhandler) { // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); mgr->SetOutputEventHandler(aodHandler); } // Debugging if needed if (useDBG) mgr->SetDebugLevel(3); AddAnalysisTasks(cdbPath); if (merge) { AODmerge(); mgr->InitAnalysis(); mgr->SetGridHandler(new AliAnalysisAlien); mgr->StartAnalysis("gridterminate",0); return; } // Run the analysis // TChain *chain = CreateChain(); if (!chain) return; TStopwatch timer; timer.Start(); mgr->SetSkipTerminate(kTRUE); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } timer.Print(); }
//______________________________________________________________________________ void QAtrainsim(Int_t run = 0, const char *xmlfile = "wn.xml", Int_t stage = 0, /*0 = QA train, 1...n - merging stage*/ const char *cdb = "raw://") { run_number = run; ProcessEnvironment(); // // set OCDB source TString ocdbConfig = "default,snapshot"; if (gSystem->Getenv("CONFIG_OCDB")) ocdbConfig = gSystem->Getenv("CONFIG_OCDB"); if (stage != 0) { // gSystem->Setenv("CONFIG_RUN", gSystem->Getenv("ALIEN_JDL_LPMRUNNUMBER")); // set OCDB gROOT->LoadMacro("$ALIDPG_ROOT/MC/OCDBConfig.C"); OCDBDefault(1); } else if (ocdbConfig.Contains("alien") || ocdbConfig.Contains("cvmfs")) { // set OCDB gROOT->LoadMacro("$ALIDPG_ROOT/MC/OCDBConfig.C"); OCDBDefault(1); } else { // set OCDB snapshot mode AliCDBManager *cdbm = AliCDBManager::Instance(); cdbm->SetSnapshotMode("OCDBrec.root"); } printf("------ Run QAtrainsim.C for collision type %s ------\n",CollisionSystem[iCollisionType]); UpdateFlags(); TString cdbString(cdb); if (cdbString.Contains("raw://") && !ocdbConfig.Contains("cvmfs")) { TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("QAtrain", "No grid connection"); return; } } // gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_PHYSICS -I$ALICE_PHYSICS/include -I$ALICE_PHYSICS/PWGPP/TRD/macros"); // Set temporary merging directory to current one gSystem->Setenv("TMPDIR", gSystem->pwd()); // Set temporary compilation directory to current one gSystem->SetBuildDir(gSystem->pwd(), kTRUE); // Load libraries // LoadLibraries(); printf("Include path: %s\n", gSystem->GetIncludePath()); // Create manager AliAnalysisManager *mgr = new AliAnalysisManager("PilotAnalysis_sim", "Production train"); mgr->SetRunFromPath(run_number); // Input handler AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP(); esdHandler->SetReadFriends(kTRUE); esdHandler->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(esdHandler); mgr->SetDebugLevel(debug_level); // Monte Carlo handler AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetPreReadMode(1); mcHandler->SetReadTR(kTRUE); // subsidiary handler for mc-to-mc embedding TString bgDir = gSystem->Getenv("CONFIG_BGEVDIR"); if (!bgDir.IsNull()) { // add extra handler for underlaying event if (bgDir.BeginsWith("alien://") && !gGrid && !TGrid::Connect("alien://")) { printf("Failed to create a grid connection\n"); abort(); } if (!bgDir.EndsWith("/")) bgDir += "/"; AliMCEventHandler* mcHandlerBg = new AliMCEventHandler(); mcHandlerBg->SetInputPath(bgDir.Data()); mcHandlerBg->SetPreReadMode(1); mcHandlerBg->SetReadTR(kTRUE); mcHandler->AddSubsidiaryHandler(mcHandlerBg); } // AnalysisTasks // mgr->Lock(); mgr->SetFileInfoLog("fileinfo.log"); AddAnalysisTasks(cdb); // mgr->UnLock(); // mcHandler = (AliMCEventHandler*)mgr->GetMCtruthEventHandler(); // mcHandler->SetReadTR(kTRUE); // mcHandler->SetPreReadMode(1); if (stage>0) { QAmerge(xmlfile, stage); return; } // Input chain TChain *chain = new TChain("esdTree"); chain->Add("AliESDs.root"); TStopwatch timer; timer.Start(); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->SetSkipTerminate(kTRUE); // mgr->SetNSysInfo(1); mgr->StartAnalysis("local", chain); } timer.Print(); }
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(); }
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 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(); }
AliMeanPtAnalysisTask* AddTask_mkrueger_MeanPt(TString controlstring, Int_t cutModeLow = 100, Int_t cutModeHigh = 101) { // INFO: for MC use 4 different trains (cutModeLow, cutModeHigh) = (100,105), (105,109), (109,113), (113,116), (116,120) // settings: Bool_t includeCrosscheckHistos = kFALSE; Bool_t is2013pA = kFALSE; UInt_t offlineTriggerMask = AliVEvent::kINT7; Bool_t is2015Data = kFALSE; Bool_t isPbPbAnalysis = kFALSE; Int_t maxMultiplicity = 100; Float_t etaCut = 0.8; if(controlstring.Contains("eta03")) etaCut = 0.3; Float_t upperPtCut = 10.; Bool_t includeSigmas = kTRUE; string colsys = "pp"; const Int_t nMultSteps = 3; Int_t multSteps[] = {100, 0, 0}; Int_t multBinWidth[] = {1,1,1}; Int_t nBinsCent = 1; Double_t centBinEdgesDummy[2] = {0., 100.}; Double_t centBinEdgesUsed[9] = {0., 5., 10., 20., 40., 60., 80., 90., 100.}; Double_t* centBinEdges = centBinEdgesDummy; if(controlstring.Contains("pp")){ if(controlstring.Contains("performanceHistos")) includeCrosscheckHistos = kTRUE; if(controlstring.Contains("5TeV")) is2015Data = kTRUE; if(controlstring.Contains("7TeV")) offlineTriggerMask = AliVEvent::kMB; } if(controlstring.Contains("XeXe")) { colsys = "XeXe"; multSteps[0] = 3500; multBinWidth[0] = 1; multSteps[1] = 0; multBinWidth[1] = 1; multSteps[2] = 0; multBinWidth[2] = 1; nBinsCent = 8; centBinEdges = centBinEdgesUsed; } if(controlstring.Contains("pPb")) { colsys = "pPb"; multSteps[0] = 300; multBinWidth[0] = 1; multSteps[1] = 0; multBinWidth[1] = 1; multSteps[2] = 0; multBinWidth[2] = 1; is2013pA = kTRUE; } if(controlstring.Contains("PbPb")) { isPbPbAnalysis = kTRUE; is2015Data = kTRUE; colsys = "PbPb"; multSteps[0] = 4500; multBinWidth[0] = 1; multSteps[1] = 0; multBinWidth[1] = 1; multSteps[2] = 0; multBinWidth[2] = 1; nBinsCent = 8; centBinEdges = centBinEdgesUsed; } if(controlstring.Contains("excludeSigmas")) includeSigmas = kFALSE; // Binning in Multiplicity const Int_t nBinsMult = multSteps[0]+ multSteps[1] + multSteps[2] + 1; Double_t multBinEdges[nBinsMult+1]; multBinEdges[0] = -0.5; multBinEdges[1] = 0.5; Int_t startBin = 1; Int_t endBin = 1; for(Int_t multStep = 0; multStep < nMultSteps; multStep++){ endBin += multSteps[multStep]; for(Int_t multBin = startBin; multBin < endBin; multBin++) { multBinEdges[multBin+1] = multBinEdges[multBin] + multBinWidth[multStep]; } startBin = endBin; } AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error("AddTask_mkrueger_MeanPt", "No analysis manager found."); return 0; } // Switch off all AliInfo (too much output!!!) AliLog::SetGlobalLogLevel(AliLog::kError); mgr->SetDebugLevel(0); TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" Bool_t hasMC = (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler() != 0x0); if(controlstring.Contains("PbPb") && hasMC) offlineTriggerMask = AliVEvent::kMB; AliMeanPtAnalysisTask* mainTask = NULL; char taskName[100] = ""; for(Int_t cutMode = cutModeLow; cutMode < cutModeHigh; cutMode++){ sprintf(taskName, "mkrueger_%s_eta_%.2f_cutMode_%d", colsys.c_str(), etaCut, cutMode); AliMeanPtAnalysisTask* task = new AliMeanPtAnalysisTask(taskName); task->SetIncludeCrosscheckHistos(includeCrosscheckHistos); task->Set2013pA(is2013pA); // general cuts task->SelectCollisionCandidates(offlineTriggerMask); task->SetTriggerMask(offlineTriggerMask); task->SetUseMC(hasMC); if(type.Contains("ESD")) task->SetUseESD(); else task->SetUseAOD(); task->SetBinsMult(nBinsMult, multBinEdges); task->SetBinsCent(nBinsCent, centBinEdges); // nominal cut-setting: task->SetMinEta(-etaCut); task->SetMaxEta(etaCut); task->SetMinPt(0.15); task->SetMaxPt(upperPtCut); task->Set2013pA(kFALSE); task->Set2015data(is2015Data); task->SetMeanXYZv(0.0,0.0,0.0); task->SetSigmaMeanXYZv(1.0,1.0,10.0); task->SetZvtx(10.); // Quality cuts for tracks task->SetTPCRefit(kTRUE); task->SetITSRefit(kTRUE); task->SetKinkDaughters(kFALSE); task->SetRatioCrossedRowsOverFindableClustersTPC(0.8); task->SetFractionSharedClustersTPC(0.4); task->SetMaxchi2perTPCclu(4.); task->SetClusterReqITS(kTRUE); task->SetMaxchi2perITSclu(36.); task->SetDCAtoVertex2D(kFALSE); task->SetSigmaToVertex(kFALSE); task->SetDCAtoVertexZ(2.0); task->SetDCAtoVertexXYPtDep("0.0182+0.0350/pt^1.01"); task->SetMaxChi2TPCConstrained(36.); // was excluded for some reason? task->SetMinLenghtInActiveZoneTPC(0); task->SetGeometricalCut(kTRUE,3,130,1.5,0.85,0.7); ///if kTRUE comment CrossedRowsTPC cut // task->SetMinCrossedRowsTPC(120); //MC1-- if(cutMode == 100) mainTask = task; // has no particular use... just to return task with nominal cut setting in macro // cut-variation: if(cutMode == 101) {task->SetMaxchi2perITSclu(25.);} if(cutMode == 102) {task->SetMaxchi2perITSclu(49.);} if(cutMode == 103) {task->SetMaxchi2perTPCclu(3); } if(cutMode == 104) {task->SetMaxchi2perTPCclu(5); } //MC2-- if(cutMode == 105) {task->SetRatioCrossedRowsOverFindableClustersTPC(0.7);} if(cutMode == 106) {task->SetRatioCrossedRowsOverFindableClustersTPC(0.9);} if(cutMode == 107) {task->SetFractionSharedClustersTPC(0.2);} if(cutMode == 108) {task->SetFractionSharedClustersTPC(1.0);} //MC3-- if(cutMode == 109) {task->SetMaxChi2TPCConstrained(25.);} if(cutMode == 110) {task->SetMaxChi2TPCConstrained(49.);} if(cutMode == 111) {task->SetDCAtoVertexXYPtDep("0.0104+0.0200/pt^1.01");} if(cutMode == 112) {task->SetDCAtoVertexXYPtDep("0.0260+0.0500/pt^1.01");} //MC4-- if(cutMode == 113) {task->SetDCAtoVertexZ(1.0);} if(cutMode == 114) {task->SetDCAtoVertexZ(5.0);} if(cutMode == 115) {task->SetClusterReqITS(kFALSE);} //MC5-- if(cutMode == 116) {task->SetGeometricalCut(kTRUE,3,120,1.5,0.85,0.7);} if(cutMode == 117) {task->SetGeometricalCut(kTRUE,3,140,1.5,0.85,0.7);} if(cutMode == 118) {task->SetGeometricalCut(kTRUE,4,130,1.5,0.85,0.7);} if(cutMode == 119) {task->SetGeometricalCut(kTRUE,2,130,1.5,0.85,0.7);} // hang task in train mgr->AddTask(task); AliAnalysisDataContainer* cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer* coutput = mgr->CreateContainer(taskName, TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults.root"); mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); } return mainTask; }
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 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 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 AnaPi0Select(const char* dataset="minbias_LHC09a4_81040_81050.xml") { gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libPhysics"); //load analysis framework gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE //Set local DB for PHOS gROOT->ProcessLine(".! tar xzvf PHOS.tgz") ; AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); AliCDBManager::Instance()->SetSpecificStorage("PHOS/*","local://./"); // A task can be compiled dynamically with AClic gROOT->LoadMacro("AliAnalysisTaskPi0CalibSelection.cxx+g"); // Connect to alien TString token = gSystem->Getenv("GRID_TOKEN") ; if ( token == "OK" ) TGrid::Connect("alien://"); else AliInfo("You are not connected to the GRID") ; // 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()); } // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("Pi0CalibSelect","Pi0CalibSelection"); // ESD input handler AliESDInputHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Debug level mgr->SetDebugLevel(10); // Add task AliAnalysisTaskPi0CalibSelection *task = new AliAnalysisTaskPi0CalibSelection("Pi0CalibSelection"); task->SetClusterMinEnergy(0.4); mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput = mgr->CreateContainer("histos",TList::Class(),AliAnalysisManager::kOutputContainer,"histos.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } }
//_____________________________________________________________________________ void RunPerformanceTaskResEffMC(TChain *chain, Bool_t bUseMCInfo=kTRUE, Bool_t bUseESDfriend=kTRUE, Bool_t bProof=kTRUE) { if(!chain) { AliDebug(AliLog::kError, "ERROR: No input chain available"); return; } // // Swtich off all AliInfo (too much output!) // AliLog::SetGlobalLogLevel(AliLog::kError); // // Create analysis manager // AliAnalysisManager *mgr = new AliAnalysisManager; if(!mgr) { Error("runTPCQA","AliAnalysisManager not set!"); return; } // // Set ESD input handler // AliESDInputHandler* esdH = new AliESDInputHandler; if(!esdH) { Error("runTPCQA","AliESDInputHandler not created!"); return; } if(bUseESDfriend) esdH->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(esdH); // // Set MC input handler // if(bUseMCInfo) { AliMCEventHandler* mcH = new AliMCEventHandler; if(!esdH) { Error("runTPCQA","AliMCEventHandler not created!"); return; } mcH->SetReadTR(kTRUE); mgr->SetMCtruthEventHandler(mcH); } // // Create task // AliPerformanceTask *task = new AliPerformanceTask("Performance","TPC Performance"); if (!task) { Error("AddTaskPerformanceTPC", "TPC performance task cannot be created!"); return NULL; } task->SetUseMCInfo(bUseMCInfo); task->SetUseESDfriend(bUseESDfriend); // // Add task to analysis manager // mgr->AddTask(task); // // Create TPC-ESD track reconstruction cuts // MB tracks // AliRecInfoCuts *pRecInfoCutsTPC = new AliRecInfoCuts("pRecInfoCutsTPC"); if(pRecInfoCutsTPC) { pRecInfoCutsTPC->SetMaxDCAToVertexXY(3.0); pRecInfoCutsTPC->SetMaxDCAToVertexZ(30.0); //pRecInfoCutsTPC->SetMaxDCAToVertexZ(3.0); pRecInfoCutsTPC->SetRequireSigmaToVertex(kFALSE); pRecInfoCutsTPC->SetRequireTPCRefit(kFALSE); pRecInfoCutsTPC->SetAcceptKinkDaughters(kTRUE); pRecInfoCutsTPC->SetMinNClustersTPC(50); pRecInfoCutsTPC->SetMaxChi2PerClusterTPC(1000000.); pRecInfoCutsTPC->SetDCAToVertex2D(kFALSE); pRecInfoCutsTPC->SetHistogramsOn(kFALSE); } else { Error("AddTaskPerformanceTPC", "AliRecInfoCutsTPC cannot be created!"); return NULL; } // // Create TPC-ESD track reconstruction cuts // MATCH tracks // AliRecInfoCuts *pRecInfoCutsMATCH = new AliRecInfoCuts("pRecInfoCutsMATCH"); if(pRecInfoCutsMATCH) { pRecInfoCutsMATCH->SetMaxDCAToVertexXY(3.0); pRecInfoCutsMATCH->SetMaxDCAToVertexZ(3.0); pRecInfoCutsMATCH->SetRequireSigmaToVertex(kFALSE); pRecInfoCutsMATCH->SetRequireTPCRefit(kFALSE); pRecInfoCutsMATCH->SetAcceptKinkDaughters(kTRUE); pRecInfoCutsMATCH->SetMinNClustersTPC(50); pRecInfoCutsMATCH->SetMaxChi2PerClusterTPC(1000000.); pRecInfoCutsMATCH->SetDCAToVertex2D(kFALSE); pRecInfoCutsMATCH->SetTPCITSMatchingRadius(70); pRecInfoCutsMATCH->SetTPCTRDMatchingRadius(260); pRecInfoCutsMATCH->SetMinNClustersITS(3); pRecInfoCutsMATCH->SetHistogramsOn(kFALSE); } else { Error("AddTaskPerformanceTPC", "AliRecInfoCutsTPC cannot be created!"); return NULL; } // // Create TPC-ESD track reconstruction cuts // standard cuts AliRecInfoCuts *pRecInfoCuts = new AliRecInfoCuts("pRecInfoCuts"); if(pRecInfoCuts) { pRecInfoCuts->SetMaxDCAToVertexXY(3.0); pRecInfoCuts->SetMaxDCAToVertexZ(3.0); pRecInfoCuts->SetMinNClustersTPC(50); pRecInfoCuts->SetMinNClustersITS(2); pRecInfoCuts->SetHistogramsOn(kFALSE); pRecInfoCuts->SetTPCITSMatchingRadius(70); pRecInfoCuts->SetTPCTRDMatchingRadius(260); } else { Error("AddTaskPerformanceTPC", "AliRecInfoCuts cannot be created!"); return NULL; } // // Create TPC-MC track reconstruction cuts // AliMCInfoCuts *pMCInfoCuts = new AliMCInfoCuts("pMCInfoCuts"); if(pMCInfoCuts) { pMCInfoCuts->SetMinTrackLength(70); } else { Error("AddTaskPerformanceTPC", "AliMCInfoCuts cannot be created!"); return NULL; } // // Create performance objects for TPC and set cuts // enum { kTPC = 0, kTPCITS, kConstrained, kTPCInner, kTPCOuter, kTPCSec }; // // Resolution // AliPerformanceRes *pCompRes0 = new AliPerformanceRes("AliPerformanceRes","AliPerformanceRes",kTPC,kFALSE); if(!pCompRes0) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceRes"); } pCompRes0->SetAliRecInfoCuts(pRecInfoCuts); pCompRes0->SetAliMCInfoCuts(pMCInfoCuts); AliPerformanceRes *pCompRes3 = new AliPerformanceRes("AliPerformanceResTPCInner","AliPerformanceResTPCInner",kTPCInner,kFALSE); if(!pCompRes3) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceResTPCInner"); } pCompRes3->SetAliRecInfoCuts(pRecInfoCuts); pCompRes3->SetAliMCInfoCuts(pMCInfoCuts); AliPerformanceRes *pCompRes4 = new AliPerformanceRes("AliPerformanceResTPCOuter","AliPerformanceResTPCOuter",kTPCOuter,kFALSE); if(!pCompRes4) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceResTPCOuter"); } pCompRes4->SetAliRecInfoCuts(pRecInfoCuts); pCompRes4->SetAliMCInfoCuts(pMCInfoCuts); // // Efficiency // AliPerformanceEff *pCompEff0 = new AliPerformanceEff("AliPerformanceEff","AliPerformanceEff",kTPC,kFALSE); if(!pCompEff0) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceEff"); } pCompEff0->SetAliRecInfoCuts(pRecInfoCuts); pCompEff0->SetAliMCInfoCuts(pMCInfoCuts); // // dEdx // AliPerformanceDEdx *pCompDEdx3 = new AliPerformanceDEdx("AliPerformanceDEdxTPCInner","AliPerformanceDEdxTPCInner",kTPCInner,kFALSE); if(!pCompDEdx3) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceDEdxTPCInner"); } pCompDEdx3->SetAliRecInfoCuts(pRecInfoCuts); pCompDEdx3->SetAliMCInfoCuts(pMCInfoCuts); // // DCA // AliPerformanceDCA *pCompDCA0 = new AliPerformanceDCA("AliPerformanceDCA","AliPerformanceDCA",kTPC,kFALSE); if(!pCompDCA0) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceDCA"); } pCompDCA0->SetAliRecInfoCuts(pRecInfoCuts); pCompDCA0->SetAliMCInfoCuts(pMCInfoCuts); // // TPC performance // AliPerformanceTPC *pCompTPC0 = new AliPerformanceTPC("AliPerformanceTPC","AliPerformanceTPC",kTPC,kFALSE); if(!pCompTPC0) { Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceTPC"); } pCompTPC0->SetAliRecInfoCuts(pRecInfoCutsTPC); pCompTPC0->SetAliMCInfoCuts(pMCInfoCuts); // // TPC+ITS matching performance // AliPerformanceMatch *pCompMatch0 = new AliPerformanceMatch("AliPerformanceMatchTPCITS","AliPerformanceMatchTPCITS",0,kFALSE); if(!pCompMatch0) { Error("AddTaskPerformanceMatch", "Cannot create AliPerformanceMatchTPCITS"); } pCompMatch0->SetAliRecInfoCuts(pRecInfoCutsMATCH); pCompMatch0->SetAliMCInfoCuts(pMCInfoCuts); // // TPC+TRD matching performance // AliPerformanceMatch *pCompMatch1 = new AliPerformanceMatch("AliPerformanceMatchTPCTRD","AliPerformanceMatchTPCTRD",1,kFALSE); if(!pCompMatch1) { Error("AddTaskPerformanceMatch", "Cannot create AliPerformanceMatchTPCTRD"); } pCompMatch1->SetAliRecInfoCuts(pRecInfoCutsMATCH); pCompMatch1->SetAliMCInfoCuts(pMCInfoCuts); AliPerformanceMatch *pCompMatch2 = new AliPerformanceMatch("AliPerformanceMatchTPCEFF","AliPerformanceMatchTPCEFF",2,kFALSE); if(!pCompMatch2) { Error("AddTaskPerformanceMatch", "Cannot create AliPerformanceMatchTPCEFF"); } pCompMatch2->SetAliRecInfoCuts(pRecInfoCutsMATCH); pCompMatch2->SetAliMCInfoCuts(pMCInfoCuts); // // Add components to the performance task // //task->AddPerformanceObject( pCompDEdx3 ); //task->AddPerformanceObject( pCompDCA0 ); //task->AddPerformanceObject( pCompTPC0 ); //task->AddPerformanceObject( pCompMatch0 ); //task->AddPerformanceObject( pCompMatch1 ); //task->AddPerformanceObject( pCompMatch2 ); // if(bUseMCInfo) { task->AddPerformanceObject( pCompRes0 ); //task->AddPerformanceObject( pCompRes3 ); //task->AddPerformanceObject( pCompRes4 ); task->AddPerformanceObject( pCompEff0 ); } // if(!bUseMCInfo) { pCompDEdx3->SetTriggerClass(triggerClass); pCompDCA0->SetTriggerClass(triggerClass); pCompTPC0->SetTriggerClass(triggerClass); pCompMatch0->SetTriggerClass(triggerClass); pCompMatch1->SetTriggerClass(triggerClass); pCompMatch2->SetTriggerClass(triggerClass); } // // Create containers for input // mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); // // Create containers for output // AliAnalysisDataContainer *coutput_tpc = mgr->CreateContainer("TPCMC", TList::Class(), AliAnalysisManager::kOutputContainer, Form("TPC.MC.%s.root", task->GetName())); mgr->ConnectOutput(task, 1, coutput_tpc); // Enable debug printouts mgr->SetDebugLevel(0); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); if(bProof) mgr->StartAnalysis("proof",chain); else mgr->StartAnalysis("local",chain); }
void AliAnalysisTaskFilteredTest(const char *esdList, Int_t run = 0, Float_t scalingTracks = 1, Float_t scalingV0 = 1, Float_t scalingFriend = 1, const char *ocdb = "cvmfs://", Int_t nFiles = 100000, Int_t firstFile = 0, Int_t nEvents = 1000000000, Int_t firstEvent = 0, Bool_t mc = kFALSE) { TStopwatch timer; timer.Start(); printf("\n\n\n"); printf("scalingTracks=%d\n",scalingTracks); printf("scalingV0=%d\n",scalingV0); printf("nFiles=%d\n",nFiles); gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT -I$ALICE_ROOT/TRD"); //____________________________________________// // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); mgr->SetDebugLevel(0); AliESDInputHandler* esdH = new AliESDInputHandler(); //esdH->SetReadFriends(1); esdH->SetReadFriends(1); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliMCEventHandler* handlerMC = new AliMCEventHandler; //handler->SetReadTR(kFALSE); if (mc) mgr->SetMCtruthEventHandler(handlerMC); gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C"); AddTaskCDBconnect(ocdb,run); if (gSystem->AccessPathName("localOCDBaccessConfig.C", kFileExists)==0) { gROOT->LoadMacro("localOCDBaccessConfig.C"); localOCDBaccessConfig(); } // Create input chain TChain* chain = AliXRDPROOFtoolkit::MakeChain(esdList, "esdTree",0,nFiles,firstFile); if(!chain) { printf("ERROR: chain cannot be created\n"); return; } chain->Lookup(); gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); Bool_t isMC=kFALSE; // kTRUE in case of MC AddTaskPIDResponse(isMC); // // Wagons to run // gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFilteredTree.C"); AliAnalysisTaskFilteredTree* task = (AliAnalysisTaskFilteredTree*)AddTaskFilteredTree("Filtered.root"); task->SetLowPtTrackDownscaligF(scalingTracks); task->SetLowPtV0DownscaligF(scalingV0); task->SetFriendDownscaling(scalingFriend); task->SetUseESDfriends(kTRUE); task->Dump(); // Init if (!mgr->InitAnalysis()) mgr->PrintStatus(); // // Run on dataset mgr->StartAnalysis("local",chain,nEvents, firstEvent); timer.Stop(); timer.Print(); delete mgr; CheckOutput(); }
//_____________________________________________________________________________ void RunPerformanceTrain(Char_t *file="esd.root", Int_t runNumber = 2, const char* triggerClass ="CINT1B-ABCE-NOPF-ALL", Bool_t bUseMCInfo=kFALSE, Bool_t bUseESDfriend=kTRUE, Bool_t bGrid=kFALSE) { // // Grid settings // use GSI::SE if(bGrid) { gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE"); TGrid * alien = TGrid::Connect("alien://",0,0,"t"); gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE"); } // // Train Configuration // Int_t iPWGPPperfTPC = 1; // Test TPC performance Int_t iPWGPPperfTRD = 0; // Test TRD performance Int_t iPWGPPperfITS = 0; // Test ITS performance Int_t iPWGPPperfCalo = 0; // Test Calo performance Int_t iPWGPPperfMuonTrig = 0; // Test Muon Trigger performance Int_t iPWGPPperfMuonEff = 0; // Test Muon Efficiency performance Int_t iPWGPPperfTOF = 0; // Test TOF-TPC matching performance Int_t iPWGPPperfPrimVertex = 0; // Test Primary Vertex performance Int_t iPWGPPv0QA = 0; // V0 algorithm QA task // // Load Libraries // gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libTender"); gSystem->Load("libCORRFW"); gSystem->Load("libTPCcalib"); gSystem->Load("libPWGPP"); gSystem->Load("libPHOSUtils"); gSystem->Load("libEMCALUtils"); gSystem->Load("libPWG4PartCorrBase"); gSystem->Load("libPWG4PartCorrDep"); gSystem->Load("libPWGmuon"); // The class is here // // OCDB Configuration // AliCDBManager *cdbManager = AliCDBManager::Instance(); cdbManager->SetDefaultStorage("local:///lustre/alice/alien/alice/data/2009/OCDB"); //cdbManager->SetDefaultStorage("local://$ALICE_PHYSICS/OCDB"); //cdbManager->SetSpecificStorage("GRP/GRP/Data", Form("local://%s",gSystem->pwd())); cdbManager->SetRun(runNumber); //cdbManager->SetCacheFlag(kFALSE); // initialize magnetic field from the GRP manager. //if(magField==0) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", 0., 0., AliMagF::k2kG)); //if(magField==1) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1., AliMagF::k2kG)); //if(magField==2) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1., AliMagF::k5kG)); /* AliGRPManager grpMan; grpMan.ReadGRPEntry(); grpMan.SetMagField(); AliRunInfo *runInfo = grpMan.GetRunInfo(); // // Load geometry // */ AliGeomManager::LoadGeometry(); // // Swtich off all AliInfo (too much output!) // AliLog::SetGlobalLogLevel(AliLog::kError); // // Create input ESD chain // /* gROOT->LoadMacro("$ALICE_PHYSICS/PWG0/CreateESDChain.C"); TChain* chain = CreateESDChain(list,nFiles,fistFile); if(!chain) { Error("RunPerformanceTrain","ESD chain not created!"); return; } */ TChain *chain = new TChain("esdTree"); if(!chain) { Error("RunPerformanceTrain","ESD chain not created!"); return; } chain->Add(file); chain->Lookup(); // // Create analysis manager // AliAnalysisManager *mgr = new AliAnalysisManager; if(!mgr) { Error("RunPerformanceTrain","AliAnalysisManager not set!"); return; } // // Set ESD input handler // AliESDInputHandler* esdH = new AliESDInputHandler; if(!esdH) { Error("RunPerformanceTrain","AliESDInputHandler not created!"); return; } if(bUseESDfriend) esdH->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(esdH); /* // // Set RecPoints and ESD input handler // AliESDInputHandlerRP* rpH = new AliESDInputHandlerRP; if(!rpH) { Error("RunPerformanceTrain","AliESDInputHandlerRP not created!"); return; } if(bUseESDfriend) rpH->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(rpH); */ // // Set MC input handler // if(bUseMCInfo) { AliMCEventHandler* mcH = new AliMCEventHandler; if(!mcH) { Error("RunPerformanceTrain","AliMCEventHandler not created!"); return; } mcH->SetReadTR(kTRUE); mgr->SetMCtruthEventHandler(mcH); } // // Add task to AliAnalysisManager // // // TPC performance // if(iPWGPPperfTPC) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceTPC.C"); AliPerformanceTask *tpcQA = AddTaskPerformanceTPC(bUseMCInfo,bUseESDfriend,triggerClass); if(!tpcQA) { Error("RunPerformanceTrain","AliPerformanceTask not created!"); return; } } else { Printf("RunPerformanceTrain: TPC Performance - EXCLUDED!"); } // // TRD perormance // if(iPWGPPperfTRD) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTrainPerformanceTRD.C"); if(!AddTrainPerformanceTRD(bUseMCInfo,bUseESDfriend)) { Error("RunPerformanceTrain","TrainPerformanceTRD not created!"); return; } } else { Printf("RunPerformanceTrain: TRD TrainPerformanceTRD - EXCLUDED!"); } // // ITS performance // if(iPWGPPperfITS) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceITS.C"); AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(bUseMCInfo); if(!itsQA) { Error("RunPerformanceTrain","AliAnalysisTaskITSTrackingCheck not created!"); return; } } else { Printf("RunPerformanceTrain: AliAnalysisTaskITSTrackingCheck - EXCLUDED!"); } // // Calorimeter Performance // if(iPWGPPperfCalo) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG4/macros/AddTaskCalorimeterQA.C"); AliAnalysisTaskParticleCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD",bUseMCInfo,kFALSE); if(!taskCaloQA) { Error("RunPerformanceTrain","AliAnalysisTaskParticleCorrelation not created!"); return; } mgr->AddTask(taskCaloQA); } else { Printf("RunPerformanceTrain: AliAnalysisTaskParticleCorrelation - EXCLUDED!"); } // // Muon Trigger // if(iPWGPPperfMuonTrig) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskMTRchamberEfficiency.C"); AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency(); if(!taskMuonTrig) { Error("RunPerformanceTrain","AliAnalysisTaskTrigChEff not created!"); return; } mgr->AddTask(taskMuonTrig); } else { Printf("RunPerformanceTrain: AliAnalysisTaskTrigChEff - EXCLUDED!"); } // // Muon Efficiency // if(iPWGPPperfMuonEff) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG3/muondep/AddTaskMUONTrackingEfficiency.C"); AliAnalysisTaskMuonTrackingEff *taskMuonTrackEff = AliAnalysisTaskMuonTrackingEff(); if(!taskMuonTrackEff) { Error("RunPerformanceTrain","AliAnalysisTaskMuonTrackingEff not created!"); return; } mgr->AddTask(taskMuonTrackEff); } else { Printf("RunPerformanceTrain: Muon Efficiency - EXCLUDED!"); } // // TOF performance // if(iPWGPPperfTOF) { // } else { Printf("RunPerformanceTrain: TOF - EXCLUDED!"); } // // PWGPP Primary Vertex // if(iPWGPPperfPrimVertex) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskVertexESD.C"); AliAnalysisTaskVertexESD *taskPrimVertex = AddTaskVertexESD(); if(!taskPrimVertex) { Error("RunPerformanceTrain","AliAnalysisTaskVertexESD not created!"); return; } } else { Printf("RunPerformanceTrain: AliAnalysisTaskVertexESD - EXCLUDED!"); } // // PWGPP V0 QA // if (iPWGPPv0QA) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskV0QA.C"); AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(bUseMCInfo); if(!taskv0QA) { Error("RunPerformanceTrain","AliAnalysisTaskV0QA not created!"); return; } } else { Printf("RunPerformanceTrain: AliAnalysisTaskV0QA - EXCLUDED!"); } // // Disable debug printouts // mgr->SetDebugLevel(0); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); //mgr->StartAnalysis("local",chain, nEvents, firstEvent); mgr->StartAnalysis("local",chain); }
void runAODFilterMC() { // PROOF example gSystem->Load("libTree"); gSystem->Load("libPhysics"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); bool bKineFilter = true; // TProof::Mgr("alicecaf")->SetROOTVersion("v5-21-01-alice_dbg"); TProof::Open("alicecaf"); // gProof->SetParallel(1); char *dataset = "/COMMON/COMMON/LHC08c11_10TeV_0.5T"; // char *dataset = "/PWG4/kleinb/LHC08q_jetjet100"; // gProof->ClearPackages(); gProof->UploadPackage("${ALICE_ROOT}/STEERBase.par"); gProof->EnablePackage("STEERBase"); gProof->UploadPackage("${ALICE_ROOT}/ESD.par"); gProof->EnablePackage("ESD"); gProof->UploadPackage("${ALICE_ROOT}/AOD.par"); gProof->EnablePackage("AOD"); gProof->UploadPackage("${ALICE_ROOT}/ANALYSIS.par"); gProof->EnablePackage("ANALYSIS"); gProof->UploadPackage("${ALICE_ROOT}/ANALYSISalice.par"); gProof->EnablePackage("ANALYSISalice"); // if (gApplication) gApplication->InitializeGraphics(); // Create the chain // /////////////////////////////////////////////////////////////////////////////////// // Create the analysis manager // // Input AliESDInputHandler* inpHandler = new AliESDInputHandler(); // Output AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("aod_ckb2.root"); // MC Truth AliMCEventHandler* mcHandler = new AliMCEventHandler(); AliAnalysisManager *mgr = new AliAnalysisManager("Filter Manager", "Filter Manager"); if(bKineFilter){ mgr->SetMCtruthEventHandler(mcHandler); } mgr->SetInputEventHandler (inpHandler); mgr->SetOutputEventHandler (aodHandler); aodHandler->Dump(); mgr->SetDebugLevel(10); // Filtering of MC particles (decays conversions etc) // this task is also needed to set the MCEventHandler // to the AODHandler, this will not be needed when // AODHandler goes to ANALYSISalice AliAnalysisTaskMCParticleFilter *kinefilter = new AliAnalysisTaskMCParticleFilter("Particle Filter"); if(bKineFilter)mgr->AddTask(kinefilter); // AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose"); esdTrackCutsL->SetMinNClustersTPC(50); esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5); esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2); esdTrackCutsL->SetRequireTPCRefit(kTRUE); esdTrackCutsL->SetDCAToVertexZ(3.0); esdTrackCutsL->SetDCAToVertexXY(3.0); esdTrackCutsL->SetDCAToVertex2D(kTRUE); esdTrackCutsL->SetRequireSigmaToVertex(kFALSE); esdTrackCutsL->SetAcceptKinkDaughters(kFALSE); AliESDtrackCuts* esdTrackCutsITSsa = new AliESDtrackCuts("AliESDtrackCuts", "ITS stand-alone"); esdTrackCutsITSsa->SetRequireITSStandAlone(kTRUE); AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter"); trackFilter->AddCuts(esdTrackCutsL); trackFilter->AddCuts(esdTrackCutsITSsa); AliAnalysisTaskESDfilter *esdfilter = new AliAnalysisTaskESDfilter("ESD Filter"); esdfilter->SetTrackFilter(trackFilter); mgr->AddTask(esdfilter); // // Create containers for input/output AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer(); coutput1->SetSpecialOutput(); if(bKineFilter){ mgr->ConnectInput (kinefilter, 0, cinput1 ); mgr->ConnectOutput (kinefilter, 0, coutput1 ); AliAnalysisDataContainer *coutputEx = mgr->CreateContainer("cFilterList", TList::Class(), AliAnalysisManager::kOutputContainer,"pyxsec_hists.root"); mgr->ConnectOutput (kinefilter, 1, coutputEx ); } mgr->ConnectInput (esdfilter, 0, cinput1 ); mgr->ConnectOutput (esdfilter, 0, coutput1 ); // // Run the analysis // mgr->InitAnalysis(); mgr->PrintStatus(); mgr->StartAnalysis("proof",dataset,10000); }
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 runLocal() { TStopwatch timer; timer.Start(); gSystem->Load("libTree.so"); //____________________________________________________// //_____________Setting up STEERBase.par_______________// //____________________________________________________// setupPar("STEERBase"); gSystem->Load("libSTEERBase.so"); //____________________________________________________// //_____________Setting up ESD.par_____________________// //____________________________________________________// setupPar("ESD"); gSystem->Load("libVMC.so"); gSystem->Load("libESD.so"); //____________________________________________________// //_____________Setting up AOD.par_____________________// //____________________________________________________// setupPar("AOD"); gSystem->Load("libAOD.so"); //_____________________________________________________________// //_____________Setting up ANALYSIS_NEW.par_____________________// //_____________________________________________________________// setupPar("ANALYSIS"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); // gROOT->LoadMacro("../tasks/AliAnalysisTaskTotEt.cxx+"); gSystem->AddIncludePath("-I$ALICE_ROOT/include"); gROOT->LoadMacro("AliAnalysisTaskTotEt.cxx+g"); //____________________________________________// 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); evCuts->SetNPHOSClustersRange(0,100); TChain* chain = 0x0; chain = TagAna->QueryTags(runCuts,lhcCuts,detCuts,evCuts); // chain->SetBranchStatus("*Calo*",0); // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TotEtManager"); AliVEventHandler* esdH = new AliESDInputHandler; mgr->SetInputEventHandler(esdH); AliAnalysisTaskTotEt *task1 = new AliAnalysisTaskTotEt("TaskTotEt"); 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,"Et.ESD.root"); AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("chist2", TH1::Class(), AliAnalysisManager::kOutputContainer,"Et.ESD.root"); AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("chist3", TH1::Class(), AliAnalysisManager::kOutputContainer,"Et.ESD.root"); AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("chist4", TH1::Class(), AliAnalysisManager::kOutputContainer,"Et.ESD.root"); AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("cnt", TNtuple::Class(), AliAnalysisManager::kOutputContainer,"Et.ESD.root"); // AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("carray1", TClonesArray::Class(), AliAnalysisManager::kOutputContainer,"Pt.ESD.root"); //____________________________________________// mgr->ConnectInput(task1,0,cinput1); mgr->ConnectOutput(task1,1,coutput1); mgr->ConnectOutput(task1,2,coutput2); mgr->ConnectOutput(task1,3,coutput3); mgr->ConnectOutput(task1,4,coutput4); mgr->ConnectOutput(task1,5,coutput5); // mgr->ConnectOutput(task1,3,coutput4); mgr->SetDebugLevel(2); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("local",chain); timer.Stop(); timer.Print(); }