void SetupUtil(bool isMC, bool isAOD){ // // Setup utility packages // // 1. Physics Selection (ESD only) // 2. Tender (ESD only) // 3. PID Response (always) // 4. Centrality Task (ESD only) // //===== ADD PID RESPONSE: === gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AddTaskPIDResponse(isMC); //==== Add tender ==== if(!isAOD){ gROOT->LoadMacro("$ALICE_ROOT/TENDER/TenderSupplies/AddTaskTender.C"); //AddTaskTender(); } //==== Physics Selection ==== if(!isAOD){ gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC); } //===== ADD CENTRALITY: === if(!isAOD){ gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C"); AddTaskCentrality(); } }
void 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 run(Char_t* data, Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 0, Bool_t isMC = 0, Int_t centrBin = 0, const char * centrEstimator = "VOM", Int_t useOtherCentralityCut = 0, Int_t trackMin=0, Int_t trackMax=10000, const char* option = "",TString customSuffix = "", Int_t workers = -1, Bool_t useSingleBin=kTRUE, const char * runList = 0) { // runMode: // // 0 local // 1 proof if (nev < 0) nev = 1234567890; InitAndLoadLibs(runMode,workers,debug); // Create the analysis manager mgr = new AliAnalysisManager; // Add ESD handler AliESDInputHandler* esdH = new AliESDInputHandler; // Do I need any of this? esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks"); mgr->SetInputEventHandler(esdH); if(isMC) { AliMCEventHandler* handler = new AliMCEventHandler; handler->SetPreReadMode(AliMCEventHandler::kLmPreRead); mgr->SetMCtruthEventHandler(handler); } // Parse option strings TString optionStr(option); // remove SAVE option if set // This is copied from a macro by Jan. The reason I kept it is that I may want to pass textual options to the new task at some point Bool_t doSave = kFALSE; TString optionStr(option); if (optionStr.Contains("SAVE")) { optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length()); doSave = kTRUE; } AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE); TString pathsuffix = ""; if(!useSingleBin) pathsuffix += "_AllCentr"; if (optionStr.Contains("DCA")) { delete cuts; // cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(); cout << ">>>> USING DCA cut" << endl; cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(); cuts->SetMaxChi2TPCConstrainedGlobal(); // remove golden cut pathsuffix+="_DCAcut"; } if (optionStr.Contains("ITSsa")) { delete cuts; cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(); cout << ">>>> USING ITS sa tracks" << endl; pathsuffix+="_ITSsa"; } if (optionStr.Contains("TPC")) { delete cuts; cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); cout << ">>>> USING TPC only tracks" << endl; pathsuffix+="_TPC"; } if(optionStr.Contains("NoElectrons")) pathsuffix +="_NoElectrons"; Bool_t useMCKinematics = isMC; if (optionStr.Contains("NOMCKIN")) { cout << ">>>> Ignoring MC kinematics" << endl; useMCKinematics=kFALSE; pathsuffix+="_NOMCKIN"; } // If we are running on grid, we need the alien handler if (runMode == kMyRunModeGRID) { // Create and configure the alien handler plugin gROOT->LoadMacro("CreateAlienHandler.C"); AliAnalysisGrid *alienHandler = CreateAlienHandler(data, runList, pathsuffix.Data(), listToLoad, "full", isMC); // full if (!alienHandler) { cout << "Cannot create alien handler" << endl; exit(1); } mgr->SetGridHandler(alienHandler); } // Add tasks // physics selection gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); physicsSelectionTask = AddTaskPhysicsSelection(isMC); //PID gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AddTaskPIDResponse(isMC); // // PID QA: // gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); // AddTaskPIDqa(); // Centrality gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentr = AddTaskCentrality(); // OBSOLETE const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root"; const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root"; // END of OBSOLETE if(isMC) taskCentr-> SetMCInput(); taskCentr->SetPass(2); // Create my own centrality selector AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector(); centrSelector->SetIsMC(isMC); centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only centrSelector->SetCentralityBin(centrBin); if (!useSingleBin) centrSelector->SetCentralityBin(0); // FIXME: ok? centrSelector->SetCentralityEstimator(centrEstimator); if(useOtherCentralityCut == 1){ cout << "Setting centrality by MULT" << endl; centrSelector->SetUseMultRange(); centrSelector->SetMultRange(trackMin,trackMax); } if(useOtherCentralityCut == 2){ cout << "Setting centrality by V0" << endl; centrSelector->SetUseV0Range(); centrSelector->SetMultRange(trackMin,trackMax); } if(useOtherCentralityCut == 3){ cout << "Setting centrality by SPD outer" << endl; centrSelector->SetUseSPDOuterRange(); centrSelector->SetMultRange(trackMin,trackMax); } // load my task if (useSingleBin) { gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C"); AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector); task->SetIsMC(useMCKinematics); task->SetOfflineTrigger(AliVEvent::kMB); if(optionStr.Contains("TPC")) task->SetTPCOnly(); if(optionStr.Contains("NoElectrons")) task->RejectElectrons(kTRUE); if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC"); if(customSuffix!=""){ cout << "Setting custom suffix: " << customSuffix << endl; task->GetHistoManager()->SetSuffix(customSuffix); } } else { gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracksAllCentrality.C"); centrSelector->SetUseV0Range(kTRUE); Int_t ncentr = 11; const Float_t minCentr[] = {0 ,79 ,239,559 ,1165,2135,3555,5525,8213 ,12191,15079}; const Float_t maxCentr[] = {79,239,559,1165,2135,3555,5525,8213,12191,15079,21000}; AliAnalysisTaskMultPbTracks ** tasks = AddTaskMultPbPbTracksAllCentrality("multPbPbtracks.root", cuts, centrSelector, ncentr,minCentr,maxCentr); for(Int_t icentr = 0; icentr < ncentr; icentr++){ tasks[icentr]->Print(); cout << "MC KINEMATICS:" << useMCKinematics << endl; tasks[icentr]->SetIsMC(useMCKinematics); tasks[icentr]->SetOfflineTrigger(AliVEvent::kMB); if(optionStr.Contains("TPC")) tasks[icentr]->SetTPCOnly(); if(optionStr.Contains("NoElectrons")) task[icentr]->RejectElectrons(kTRUE); if(useMCKinematics) tasks[icentr]->GetHistoManager()->SetSuffix("MC"); if(customSuffix!=""){ cout << "Setting custom suffix: " << customSuffix+long(icentr) << endl; tasks[icentr]->GetHistoManager()->SetSuffix(customSuffix+long(icentr)); } } } // Init and run the analy if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); if (runMode == kMyRunModeLocal ) { // If running in local mode, create chain of ESD files cout << "RUNNING LOCAL, CHAIN" << endl; TChain * chain = GetAnalysisChain(data); chain->Print(); mgr->StartAnalysis("local",chain,nev); } else if (runMode == kMyRunModeProofLite) { TChain * chain = GetAnalysisChain(data); mgr->StartAnalysis("proof",chain,nev); } else if (runMode == kMyRunModeCAF) { mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev); } else if (runMode == kMyRunModeGRID) { mgr->StartAnalysis("grid"); } else { cout << "ERROR: unknown run mode" << endl; } if (!useOtherCentralityCut) { pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin); } else if(useOtherCentralityCut==1){ pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax); } else if(useOtherCentralityCut==2){ pathsuffix = pathsuffix + "_V0Range_" + long(trackMin) + "_" + long(trackMax); } else if(useOtherCentralityCut==3){ pathsuffix = pathsuffix + "_SPDOutRange_" + long(trackMin) + "_" + long(trackMax); } pathsuffix += customSuffix; if (doSave) MoveOutput(data, pathsuffix.Data()); }
Bool_t AddTasksEmcalFjetSparseMaker() { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (bIsInfoAOD) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODHandler.C"); AliAODInputHandler *aodIH = AddAODHandler(); } else { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddESDHandler.C"); AliESDInputHandler *esdIH = AddESDHandler(); // esdIH->SetReadFriends(kFALSE); } if (bAnaInfoMC && (!bIsInfoAOD)) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddMCHandler.C"); AliMCEventHandler *mctEH = AddMCHandler(kTRUE); } if (bOutputAOD) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODOutputHandler.C"); AliAODHandler *aodH = AddAODOutputHandler(); aodH->SetOutputFileName("AliAOD.PicoJets.root"); aodH->SetFillAOD(kTRUE); aodH->SetCreateNonStandardAOD(); mgr->SetOutputEventHandler(aodH); } //============================================================================= if (bIsPhysSel) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalPhysicsSelection.C"); AliEmcalPhysicsSelectionTask *taksPhysSel = AddTaskEmcalPhysicsSelection(kTRUE, kTRUE, wTriggerMask, 5., 5., 10., kTRUE, -1, -1, -1, -1); if (bAnaInfoMC) { AliEmcalPhysicsSelection *pPhysSel = static_cast<AliEmcalPhysicsSelection*>(taksPhysSel->GetPhysicsSelection()); if (!pPhysSel) return kTRUE; pPhysSel->SetAnalyzeMC(); } } if (bIsCentSel) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentSel = AddTaskCentrality(kTRUE, bIsAOD); if (bAnaInfoMC) taskCentSel->SetMCInput(); } if (bIsEvPnSel) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C"); AliEPSelectionTask *taskEventPlane = AddTaskEventplane(); if (bAnaInfoMC) taskEventPlane->SetUseMCRP(); } if (bIsRespPID) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskSE *taskRespPID = AddTaskPIDResponse(bAnaInfoMC); } //============================================================================= gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalSetup.C"); AliEmcalSetupTask *taskSetupEMCal = AddTaskEmcalSetup(); taskSetupEMCal->SetGeoPath("$ALICE_PHYSICS/OADB/EMCAL"); gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalPreparation.C"); AliAnalysisTaskSE *taskEmcMaker = AddTaskEmcalPreparation(sPeriodIn); gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskJetPreparation.C"); AliAnalysisTaskSE *taskHadCorr = AddTaskJetPreparation(sPeriodIn.Data(), sUsedTrksRD.Data(), (bAnaInfoMC ? sUsedTrksMC.Data() : ""), sInputClsRD.Data(), sUsedClusRD.Data(), 2., 0., 0.03, 0.015, 0.15, wTriggerMask, kTRUE, // do trk clus kTRUE, // histos kTRUE, // make pico trk kFALSE, // make trigger kFALSE, // is EMCal train 1., // track eff kTRUE, // do AOD track prop kTRUE, // modify match kFALSE, // use old bit kFALSE, // trigger QA 4); // cent bin //============================================================================= gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C"); /*AliEmcalJetTask *taskAkt = AddTaskEmcalJet(sUsedTrksRD.Data(), sUsedClusRD.Data(), 1, // anti-kT dJetRadius, nJetType, dTrkPtCut, dCluEnCut);*/ //============================================================================= AliAnalysisTaskEmcalFjetSparseMaker *taskEmcalSM = new AliAnalysisTaskEmcalFjetSparseMaker("AliAnalysisTaskEmcalFjetSM"); //taskEmcalSM->SetForceBeamType(0); //taskEmcalSM->SetIsPythia(kTRUE); /*taskEmcalSM->SetCaloTriggerPatchInfoName("EmcalTriggers"); taskEmcalSM->SetTriggerTypeSel(AliAnalysisTaskEmcal::kJ2); taskEmcalSM->SetMainPatchType(AliAnalysisTaskEmcal::kTriggerLevel1Jet);*/ AliParticleContainer *pContTrks = taskEmcalSM->AddParticleContainer(sUsedTrksRD.Data()); pContTrks->SetParticlePtCut(dTrkPtCut); AliClusterContainer *pContClus = taskEmcalSM->AddClusterContainer(sUsedClusRD.Data()); pContClus->SetClusPtCut(dCluEnCut); /*AliJetContainer *pContJets = taskEmcalSM->AddJetContainer(taskAkt->GetName(), sCutType.Data(), dJetRadius); pContJets->SetPercAreaCut(dJetAreaCut); pContJets->SetJetPtCut(dJetPtCut); //pContJets->SetRhoName(sUsedRho.Data()); //pContJets->SetLocalRhoName(); pContJets->SetLeadingHadronType(nLeading); pContJets->ConnectParticleContainer(taskEmcalSM->GetParticleContainer()); pContJets->ConnectClusterContainer(taskEmcalSM->GetClusterContainer()); pContJets->SetNameTitle(taskEmcalSM->GetNameJet().Data(), taskEmcalSM->GetNameJet().Data());*/ mgr->AddTask(taskEmcalSM); mgr->ConnectInput(taskEmcalSM, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(taskEmcalSM, 1, mgr->CreateContainer("listGeneralH", TList::Class(), AliAnalysisManager::kOutputContainer, AliAnalysisManager::GetCommonFileName())); mgr->ConnectOutput(taskEmcalSM, 2, mgr->CreateContainer("listEmcalEvH", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalEvH.root")); mgr->ConnectOutput(taskEmcalSM, 3, mgr->CreateContainer("listEmcalTrk", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalTrk.root")); mgr->ConnectOutput(taskEmcalSM, 4, mgr->CreateContainer("listEmcalClu", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalClu.root")); /*mgr->ConnectOutput(taskEmcalSM, 5, mgr->CreateContainer("listEmcalJet", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalJet.root"));*/ //============================================================================= TObjArray *aTasks = mgr->GetTasks(); for (Int_t i=0; i<aTasks->GetEntries(); i++) { AliAnalysisTaskEmcal *taskJE = dynamic_cast<AliAnalysisTaskEmcal*>(aTasks->At(i)); if (taskJE) if (taskJE->InheritsFrom("AliAnalysisTaskEmcal")) { taskJE->SetVzRange(-10., 10.); if (!sCentEsti.IsNull()) { taskJE->SetCentralityEstimator(sCentEsti.Data()); taskJE->SetCentRange(dCentMin, dCentMax); } } if (wTriggerMask) { AliAnalysisTaskSE *taskSE = dynamic_cast<AliAnalysisTaskSE*>(aTasks->At(i)); if (taskSE) if (!(taskSE->InheritsFrom("AliPhysicsSelectionTask"))) { taskSE->SelectCollisionCandidates(wTriggerMask); } } } //============================================================================= return kFALSE; }
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 QAtrainAOD(Bool_t isMC=kFALSE, Int_t iCollisionType=0){ if(gSystem->Getenv("ALIEN_JDL_LPMINTERACTIONTYPE")){ for (Int_t icoll = 0; icoll < kNSystem; icoll++) if (strcmp(gSystem->Getenv("ALIEN_JDL_LPMINTERACTIONTYPE"), CollisionSystem[icoll]) == 0){ iCollisionType = icoll; break; } } printf("--------------------------------------\n"); if(isMC) printf("Run the AOD QA train for Monte Carlo\n"); else printf("Run the AOD QA train for data\n"); printf("Collision System is %s\n",CollisionSystem[iCollisionType]); printf("--------------------------------------\n"); UInt_t kTriggerMask = AliVEvent::kINT7 | AliVEvent::kINT8; if(gSystem->Getenv("ALIEN_JDL_LPMANCHORYEAR")) { Int_t year = atoi(gSystem->Getenv("ALIEN_JDL_LPMANCHORYEAR")); if(year <= 2015) kTriggerMask = AliVEvent::kAnyINT; } // Create manager AliAnalysisManager *mgr = new AliAnalysisManager("QAtrainAOD", "AOD QA train"); mgr->SetCacheSize(0); mgr->SetCommonFileName("QAresults_AOD.root"); // Input handler AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP(); AliAODInputHandler* aodHandler = new AliAODInputHandler(); mgr->SetInputEventHandler(aodHandler); if(isMC){ AliMCEventHandler* MChandler = new AliMCEventHandler; MChandler->SetReadTR(kFALSE); mgr->SetMCtruthEventHandler(MChandler); } TString macroName=""; // Physics selection gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC); mgr->AddStatisticsTask(kTriggerMask); AliAnalysisDataContainer *cstatsout = (AliAnalysisDataContainer*)mgr->GetOutputs()->FindObject("cstatsout"); cstatsout->SetFileName("EventStat_temp_AOD.root"); // PID response gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskSE *setupTask = AddTaskPIDResponse(isMC); // PIDqa gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa(); PIDQA->SelectCollisionCandidates(AliVEvent::kAny); // MultSelection gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"); AliMultSelectionTask *taskMult = AddTaskMultSelection(); if(isMC){ if (gSystem->Getenv("CONFIG_PERIOD")){ TString periodName = gSystem->Getenv("CONFIG_PERIOD"); taskMult->SetAlternateOADBforEstimators(periodName); } } // Vertex QA macroName="$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckVertexAOD.C"; if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){ gROOT->LoadMacro(macroName.Data()); Double_t maxMult=500.; if(iCollisionType==kPbPb || iCollisionType==kXeXe) maxMult=10000.; AliAnalysisTaskCheckVertexAOD *taskVert = AddTaskCheckVertexAOD("QA",maxMult,AliVEvent::kAnyINT,isMC); }else{ printf("Macro %s not found -> task will not be executed\n",macroName.Data()); } // Track QA macroName="$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckAODTracks.C"; if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){ gROOT->LoadMacro(macroName.Data()); Bool_t usMCtruthForPID=isMC; AliAnalysisTaskCheckAODTracks* taskAODtr = AddTaskCheckAODTracks("QA",isMC,usMCtruthForPID); if(iCollisionType==kPbPb || iCollisionType==kXeXe) taskAODtr->SetUpperMultiplicity(10000.); }else{ printf("Macro %s not found -> task will not be executed\n",macroName.Data()); } // HF deltaAOD QA macroName="$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskBasicHFQA.C"; if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){ gROOT->LoadMacro(macroName.Data()); AliAnalysisTaskSEHFQA* dqaHF = AddTaskBasicHFQA(AliAnalysisTaskSEHFQA::kD0toKpi,isMC,"QA"); }else{ printf("Macro %s not found -> task will not be executed\n",macroName.Data()); } if(isMC){ macroName="$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskDmesonMCPerform.C"; if(gSystem->Exec(Form("ls %s > /dev/null 2>&1",macroName.Data()))==0){ gROOT->LoadMacro(macroName.Data()); AliAnalysisTaskDmesonMCPerform* dMCp = AddTaskDmesonMCPerform("QA"); }else{ printf("Macro %s not found -> task will not be executed\n",macroName.Data()); } } TChain *chainAOD = new TChain("aodTree"); TChain *chainAODfriend = new TChain("aodTree"); chainAOD->Add("AliAOD.root"); chainAODfriend->Add("AliAOD.VertexingHF.root"); chainAOD->AddFriend(chainAODfriend); TStopwatch timer; timer.Start(); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->SetSkipTerminate(kTRUE); mgr->StartAnalysis("local", chainAOD); } gSystem->Exec("rm TreeOfAODTracks.root"); timer.Print(); }
void AddAnalysisTasks(const char *suffix) { TString ss(suffix); ss.ToLower(); Bool_t ibarrel = (ss.Contains("barrel"))?kTRUE:kFALSE; IlcAnalysisManager *mgr = IlcAnalysisManager::GetAnalysisManager(); mgr->SetCommonFileName(Form("QAresults%s.root",suffix)); // Statistics task mgr->AddStatisticsTask(kTriggerMask); // // CDB connection // if (doCDBconnect) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C"); IlcTaskCDBconnect *taskCDB = AddTaskCDBconnect(); if (!taskCDB) return; IlcCDBManager *cdb = IlcCDBManager::Instance(); cdb->SetDefaultStorage("raw://"); taskCDB->SetRunNumber(run_number); } // // Event Statistics (Jan Fiete) // if (doEventStat) { gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); IlcPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE /*MC*/); IlcAnalysisDataContainer *cstatsout = (IlcAnalysisDataContainer*)mgr->GetOutputs()->FindObject("cstatsout"); cstatsout->SetFileName(Form("EventStat_temp%s.root", suffix)); } // // Centrality (A. Toia) // if (doCentrality) { if (!iCollisionType) { printf("Disabling centrality task for p-p\n"); doCentrality = kFALSE; } else { gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); IlcCentralitySelectionTask *taskCentrality = AddTaskCentrality(); } } // Vertexing (A. Dainese) // if (doVertex) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskVertexESD.C"); IlcAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kFALSE, kTriggerMask); taskvertexesd->SelectCollisionCandidates(kTriggerMask); } // TPC QA (E. Sicking) // if (doQAsym) { // offline trigger in AddTask gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C"); IlcAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell); } // // VZERO QA (C. Cheshkov) // if (doVZERO && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C"); IlcAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0); // taskv0qa->SelectCollisionCandidates(); } if (doVZEROPbPb && iCollisionType==1) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/VZERO/AddTaskVZEROPbPb.C"); IlcAnaVZEROPbPb* taskV0PbPb = (IlcAnaVZEROPbPb*)AddTaskVZEROPbPb(0); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-"); taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-"); } // // TPC (Jacek Otwinowski & Michael Knichel) // // // Optionally MC information can be used by setting the 1st argument to true // Optionally friends information can be switched off by setting the 2st argument // to false // Optionally highMult axis can be used by setting the 3st argument to true (for PbPb) if (doTPC && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C"); IlcPerformanceTask *tpcQA = 0; if (iCollisionType) { // High multiplicity Pb-Pb tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kTRUE); } else { // Low multiplicity (pp) tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE); } tpcQA->SelectCollisionCandidates(kTriggerMask); } // HLT (Alberica Toia) if (doHLT && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C"); IlcPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE,0,kTRUE); hltQA->SelectCollisionCandidates(kTriggerMask); } // // SPD (A. Mastroserio) // if (doSPD) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C"); IlcAnalysisTaskSPD* taskspdqa = (IlcAnalysisTaskSPD*)AddTaskSPDQA(); // Request from Annalisa if (iCollisionType) taskspdqa->SetHeavyIonMode(); taskspdqa->SelectCollisionCandidates(kTriggerMask); taskspdqa->SetOCDBInfo(run_number, "raw://"); } // // SDD (F. Prino) // if (doSDD) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddSDDPoints.C"); IlcAnalysisTaskSE* tasksdd = AddSDDPoints(); tasksdd->SelectCollisionCandidates(kTriggerMask); } // // SSD dEdx (Marek Chojnacki) // if (doSSDdEdx) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C"); IlcAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA(); taskssddedx->SelectCollisionCandidates(kTriggerMask); } // // ITS // if (doITS) { // hardcoded non-zero trigger mask gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskPerformanceITS.C"); IlcAnalysisTaskITSTrackingCheck *itsQA = 0; IlcAnalysisTaskITSTrackingCheck *itsQACent0010 = 0; IlcAnalysisTaskITSTrackingCheck *itsQACent3050 = 0; IlcAnalysisTaskITSTrackingCheck *itsQACent6080 = 0; if(iCollisionType==0) { itsQA = AddTaskPerformanceITS(kFALSE); } else { itsQA = AddTaskPerformanceITS(kFALSE); itsQACent0010 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,3500,10000); itsQACent3050 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,590,1570); itsQACent6080 = AddTaskPerformanceITS(kFALSE,kFALSE,kFALSE,70,310); } } // // ITS saTracks, align (F.Prino) // if (doITSsaTracks) { // offline trigger in AddTask gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskITSsaTracks.C"); IlcAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kFALSE,kFALSE); itssaTracks->SelectCollisionCandidates(kTriggerMask); } if (doITSalign) { // no offline trigger selection gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskITSAlign.C"); IlcAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011); } // // TRD (Alex Bercuci, M. Fasel) // if(doTRD && ibarrel) { // no offline trigger selection gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C"); // steer individual TRD tasks Bool_t doCheckESD(kTRUE), // IlcTRDcheckESD doCheckDET(kTRUE), // IlcTRDcheckDET doEffic(kTRUE), // IlcTRDefficiency doResolution(kTRUE),// IlcTRDresolution doCheckPID(kTRUE), // IlcTRDcheckPID doV0Monitor(kFALSE);// IlcTRDv0Monitor AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor)); } // // ZDC (Chiara Oppedisano) // if(doZDC && ibarrel) { // hardcoded kMB trigger mask gROOT->LoadMacro("$ILC_ROOT/PWGPP/ZDC/AddTaskZDCQA.C"); IlcAnalysisTaskSE *taskZDC = AddTaskZDCQA(); taskZDC->SelectCollisionCandidates(kTriggerMask); } // // Calorimetry (Gustavo Conesa) // if(doCALO) { gROOT->LoadMacro("$ILC_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C"); IlcAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE); taskCaloQA->SetDebugLevel(0); // offline mask set in AddTask to kMB taskCaloQA->SelectCollisionCandidates(kTriggerMask); // Add a new calo task with EMC1 trigger only taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE, "", "EMC7"); taskCaloQA->SetDebugLevel(0); taskCaloQA->SelectCollisionCandidates(kTriggerEMC); } // // Muon Trigger // if(doMUONTrig) { // no offline trigger selection gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C"); IlcAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency(); } // // Impact parameter resolution ([email protected], [email protected]) // if (doImpParRes && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskImpParRes.C"); IlcAnalysisTaskSE* taskimpparres=0; if(iCollisionType==0) { taskimpparres= AddTaskImpParRes(); } else { taskimpparres= AddTaskImpParRes(kFALSE,-1,kFALSE,kFALSE); } taskimpparres->SelectCollisionCandidates(kTriggerMask); } // // MUON QA (Philippe Pillot) // if (doMUON) { // trigger analysis internal gROOT->LoadMacro("$ILC_ROOT/PWGPP/PilotTrain/AddTaskMuonQA.C"); IlcAnalysisTaskSE* taskmuonqa= AddTaskMuonQA(); } // // TOF (Francesca Bellini) // if (doTOF && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/TOF/AddTaskTOFQA.C"); IlcAnalysisTaskTOFqa *tofQA = AddTaskTOFQA(); tofQA->SelectCollisionCandidates(kTriggerMask); } // // PIDResponse(JENS) // if (doPIDResponse && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); IlcAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse(); PIDResponse->SelectCollisionCandidates(kTriggerMask); } // // PIDqa(JENS) // if (doPIDqa && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); IlcAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa(); PIDQA->SelectCollisionCandidates(kTriggerMask); } // // HMPID QA (Giacomo Volpe) // if (doHMPID && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/HMPID/AddTaskHmpidQA.C"); IlcAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kFALSE); // offline mask set in AddTask to kMB taskhmpidqa->SelectCollisionCandidates(kTriggerMask); } // T0 QA (Alla Mayevskaya) if (doT0 && ibarrel) { // no offline trigger selection gROOT->LoadMacro("$ILC_ROOT/PWGPP/T0/AddTaskT0QA.C"); IlcT0AnalysisTaskQA* taskt0qa= AddTaskT0QA(); taskt0qa->SelectCollisionCandidates(kTriggerMask); } // FMD QA (Christian Holm Christiansen) if (doFMD && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C"); // Parameters: usemc, usecentrality IlcAnalysisTaskSE *forwardQA = (IlcAnalysisTaskSE *)AddTaskForwardQA(kFALSE, kFALSE); // No offline trigger config. needed (see #84077) } // // PHOS QA (Boris Polishchuk) // if (doPHOS) { gROOT->LoadMacro("$ILC_ROOT/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C"); IlcAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt"); taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask); taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0); IlcAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7"); taskPHOSCellQA2->SelectCollisionCandidates(IlcVEvent::kPHI7); taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0); // Pi0 QA fo PbPb if (iCollisionType) { gROOT->LoadMacro("$ILC_ROOT/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C"); IlcAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0); } } if (doPHOSTrig) { gROOT->LoadMacro("$ILC_ROOT/PWGGA/PHOSTasks/PHOS_TriggerQA/macros/AddTaskPHOSTriggerQA.C"); IlcAnalysisTaskPHOSTriggerQA *taskPHOSTrig = AddTaskPHOSTriggerQA(NULL); } // // EMCAL QA (Gustavo Conesa) // if (doEMCAL) { gROOT->LoadMacro("$ILC_ROOT/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C"); IlcAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA(); } // // FLOW and BF QA (C.Perez && A.Rodriguez) // if (doFBFqa && ibarrel) { gROOT->LoadMacro("$ILC_ROOT/PWGPP/macros/AddTaskFBFqa.C"); IlcAnalysisTaskSE *qaFBFMB = (IlcAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE); qaFBFMB->SelectCollisionCandidates(IlcVEvent::kMB); IlcAnalysisTaskSE *qaFBFSC = (IlcAnalysisTaskSE*) AddTaskFBFqa("qaFBFsc",kFALSE); qaFBFSC->SelectCollisionCandidates(IlcVEvent::kSemiCentral); IlcAnalysisTaskSE *qaFBFCE = (IlcAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE); qaFBFCE->SelectCollisionCandidates(IlcVEvent::kCentral); } }
void AddTask_GammaCaloDalitzV1_pPb( Int_t trainConfig = 1, //change different set of cuts Bool_t isMC = kFALSE, //run MC Int_t enableQAMesonTask = 0, //enable QA in AliAnalysisTaskGammaConvV1 Int_t enableQAPhotonTask = 0, // enable additional QA task TString fileNameInputForWeighting = "MCSpectraInput.root", // path to file for weigting input Int_t doWeightingPart = 0, //enable Weighting TString generatorName = "DPMJET", TString cutnumberAODBranch = "8000000060084000001500000", // cutnumber for AOD branch Bool_t enableExtendedMatching = kFALSE, //enable or disable extended matching histograms for conversion electrons <-> cluster Bool_t isUsingTHnSparse = kTRUE, //enable or disable usage of THnSparses for background estimation Bool_t enableV0findingEffi = kFALSE ) { Int_t isHeavyIon = 2; // ================== GetAnalysisManager =============================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error(Form("AddTask_GammaConvV1_%i",trainConfig), "No analysis manager found."); return ; } // ================== GetInputEventHandler ============================= AliVEventHandler *inputHandler=mgr->GetInputEventHandler(); //========= Add PID Reponse to ANALYSIS manager ==== if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AddTaskPIDResponse(isMC); } Printf("here \n"); //========= Set Cutnumber for V0Reader ================================ //06000078400100001500000000 TString cutnumberPhoton = "06000078400100007500000000"; TString cutnumberEvent = "80000003"; TString cutnumberElectron = "90005400000002000000"; //Electron Cuts Bool_t doEtaShift = kFALSE; AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); //========= Add V0 Reader to ANALYSIS manager if not yet existent ===== TString V0ReaderName = Form("V0ReaderV1_%s_%s",cutnumberEvent.Data(),cutnumberPhoton.Data()); if( !(AliV0ReaderV1*)mgr->GetTask(V0ReaderName.Data()) ){ AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1(V0ReaderName.Data()); fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE); fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output fV0ReaderV1->SetUseAODConversionPhoton(kTRUE); fV0ReaderV1->SetProduceV0FindingEfficiency(enableV0findingEffi); if (!mgr) { Error("AddTask_V0ReaderV1", "No analysis manager found."); return; } AliConvEventCuts *fEventCuts=NULL; if(cutnumberEvent!=""){ fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data()); fEventCuts->SetPreSelectionCutFlag(kTRUE); fEventCuts->SetV0ReaderName(V0ReaderName); if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){ fEventCuts->DoEtaShift(doEtaShift); fV0ReaderV1->SetEventCuts(fEventCuts); fEventCuts->SetFillCutHistograms("",kTRUE); } } // Set AnalysisCut Number AliConversionPhotonCuts *fCuts=NULL; if(cutnumberPhoton!=""){ fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data()); fCuts->SetPreSelectionCutFlag(kTRUE); fCuts->SetIsHeavyIon(isHeavyIon); fCuts->SetV0ReaderName(V0ReaderName); if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){ fV0ReaderV1->SetConversionCuts(fCuts); fCuts->SetFillCutHistograms("",kTRUE); } } if(inputHandler->IsA()==AliAODInputHandler::Class()){ // AOD mode fV0ReaderV1->AliV0ReaderV1::SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data())); } fV0ReaderV1->Init(); AliLog::SetGlobalLogLevel(AliLog::kFatal); //connect input V0Reader mgr->AddTask(fV0ReaderV1); mgr->ConnectInput(fV0ReaderV1,0,cinput); } //================================================ //========= Add Electron Selector ================ if( !(AliDalitzElectronSelector*)mgr->GetTask("ElectronSelector") ){ AliDalitzElectronSelector *fElectronSelector = new AliDalitzElectronSelector("ElectronSelector"); // Set AnalysisCut Number AliDalitzElectronCuts *fElecCuts=0; if( cutnumberElectron!=""){ fElecCuts= new AliDalitzElectronCuts(cutnumberElectron.Data(),cutnumberElectron.Data()); if(fElecCuts->InitializeCutsFromCutString(cutnumberElectron.Data())){ fElectronSelector->SetDalitzElectronCuts(fElecCuts); fElecCuts->SetFillCutHistograms("",kTRUE); } } fElectronSelector->Init(); mgr->AddTask(fElectronSelector); AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); //connect input V0Reader mgr->ConnectInput (fElectronSelector,0,cinput1); } //================================================ //========= Add task to the ANALYSIS manager ===== //================================================ AliAnalysisTaskGammaCaloDalitzV1 *task=NULL; task= new AliAnalysisTaskGammaCaloDalitzV1(Form("GammaCaloDalitz_%i",trainConfig)); task->SetIsHeavyIon(isHeavyIon); task->SetIsMC(isMC); task->SetV0ReaderName(V0ReaderName); // Cut Numbers to use in Analysis Int_t numberOfCuts = 2; if ( trainConfig == 1 || trainConfig == 2 ) numberOfCuts = 4; TString *eventCutArray = new TString[numberOfCuts]; TString *photonCutArray = new TString[numberOfCuts]; TString *clusterCutArray = new TString[numberOfCuts]; TString *electronCutArray = new TString[numberOfCuts]; TString *mesonCutArray = new TString[numberOfCuts]; //************************************************ EMCAL clusters ********************************************************** if ( trainConfig == 1){ // min energy = 0.3 GeV/c eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1111100043022030000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 eventCutArray[1] = "80052013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1111100043022030000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kEMC7 eventCutArray[2] = "80000013"; photonCutArray[2] = "00200009327002008250400000"; clusterCutArray[2] = "1111100043022030000"; electronCutArray[2] = "90475400233102623110"; mesonCutArray[2] = "0263103100000000"; //standart cut, kINT7 eventCutArray[3] = "80052013"; photonCutArray[3] = "00200009327002008250400000"; clusterCutArray[3] = "1111100043022030000"; electronCutArray[3] = "90475400233102623110"; mesonCutArray[3] = "0263103100000000"; //standard cut, kEMC7 } else if ( trainConfig == 2 ){ eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "2000000048033200000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 eventCutArray[1] = "80062013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "2000000048033200000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kPHI7 eventCutArray[2] = "80000013"; photonCutArray[2] = "00200009327002008250400000"; clusterCutArray[2] = "2000000048033200000"; electronCutArray[2] = "90475400233102623110"; mesonCutArray[2] = "0263103100000000"; //standart cut, kINT7 eventCutArray[3] = "80062013"; photonCutArray[3] = "00200009327002008250400000"; clusterCutArray[3] = "2000000048033200000"; electronCutArray[3] = "90475400233102623110"; mesonCutArray[3] = "0263103100000000"; //standard cut, kPHI7 } else if ( trainConfig == 3){ // min energy = 0.3 GeV/c eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1111100053032230000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1331100053032230000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kEMC7 } else if ( trainConfig == 4){ eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "2000000048033200000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "2444400048033200000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kPHI7 } else if ( trainConfig == 5 ){ eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1002100053032230000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 with TRD eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1001300053032230000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kINT7 No TRD } else if ( trainConfig == 6 ) { eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "2000000048033300000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "2444400048033300000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kINT7 } else if ( trainConfig == 7 ){ // min energy = 0.3 GeV/c eventCutArray[0] = "80000013"; photonCutArray[0] = "00200009327002008250400000"; clusterCutArray[0] = "1221100053032230000"; electronCutArray[0] = "90475400233102623710"; mesonCutArray[0] = "0263103100000000"; //standart cut, kINT7 eventCutArray[1] = "80000013"; photonCutArray[1] = "00200009327002008250400000"; clusterCutArray[1] = "1331100053032230000"; electronCutArray[1] = "90475400233102623710"; mesonCutArray[1] = "0263103100000000"; //standard cut, kEMC7 } else { Error(Form("GammaConvDalitzCalo_%i",trainConfig), "wrong trainConfig variable no cuts have been specified for the configuration"); return; } TList *EventCutList = new TList(); TList *ConvCutList = new TList(); TList *ClusterCutList = new TList(); TList *ElectronCutList = new TList(); TList *MesonCutList = new TList(); TList *HeaderList = new TList(); if (doWeightingPart==1) { TObjString *Header1 = new TObjString("pi0_1"); HeaderList->Add(Header1); } if (doWeightingPart==2){ TObjString *Header3 = new TObjString("eta_2"); HeaderList->Add(Header3); } if (doWeightingPart==3) { TObjString *Header1 = new TObjString("pi0_1"); HeaderList->Add(Header1); TObjString *Header3 = new TObjString("eta_2"); HeaderList->Add(Header3); } EventCutList->SetOwner(kTRUE); AliConvEventCuts **analysisEventCuts = new AliConvEventCuts*[numberOfCuts]; ConvCutList->SetOwner(kTRUE); AliConversionPhotonCuts **analysisCuts = new AliConversionPhotonCuts*[numberOfCuts]; ClusterCutList->SetOwner(kTRUE); AliCaloPhotonCuts **analysisClusterCuts = new AliCaloPhotonCuts*[numberOfCuts]; ElectronCutList->SetOwner(kTRUE); AliDalitzElectronCuts **analysisElectronCuts = new AliDalitzElectronCuts*[numberOfCuts]; MesonCutList->SetOwner(kTRUE); AliConversionMesonCuts **analysisMesonCuts = new AliConversionMesonCuts*[numberOfCuts]; for(Int_t i = 0; i<numberOfCuts; i++){ //create AliCaloTrackMatcher instance, if there is none present TString caloCutPos = clusterCutArray[i]; caloCutPos.Resize(1); TString TrackMatcherName = Form("CaloTrackMatcher_%s",caloCutPos.Data()); if( !(AliCaloTrackMatcher*)mgr->GetTask(TrackMatcherName.Data()) ){ AliCaloTrackMatcher* fTrackMatcher = new AliCaloTrackMatcher(TrackMatcherName.Data(),caloCutPos.Atoi()); fTrackMatcher->SetV0ReaderName(V0ReaderName); mgr->AddTask(fTrackMatcher); mgr->ConnectInput(fTrackMatcher,0,cinput); } analysisEventCuts[i] = new AliConvEventCuts(); analysisEventCuts[i]->SetV0ReaderName(V0ReaderName); analysisEventCuts[i]->InitializeCutsFromCutString(eventCutArray[i].Data()); EventCutList->Add(analysisEventCuts[i]); analysisEventCuts[i]->SetFillCutHistograms("",kFALSE); analysisCuts[i] = new AliConversionPhotonCuts(); analysisCuts[i]->SetV0ReaderName(V0ReaderName); analysisCuts[i]->InitializeCutsFromCutString(photonCutArray[i].Data()); analysisCuts[i]->SetIsHeavyIon(isHeavyIon); ConvCutList->Add(analysisCuts[i]); analysisCuts[i]->SetFillCutHistograms("",kFALSE); analysisClusterCuts[i] = new AliCaloPhotonCuts(); analysisClusterCuts[i]->SetV0ReaderName(V0ReaderName); analysisClusterCuts[i]->SetCaloTrackMatcherName(TrackMatcherName); analysisClusterCuts[i]->InitializeCutsFromCutString(clusterCutArray[i].Data()); ClusterCutList->Add(analysisClusterCuts[i]); analysisClusterCuts[i]->SetExtendedMatching(enableExtendedMatching); analysisClusterCuts[i]->SetFillCutHistograms(""); analysisElectronCuts[i] = new AliDalitzElectronCuts(); if( !analysisElectronCuts[i]->InitializeCutsFromCutString(electronCutArray[i].Data())) { cout<< "ERROR: analysisElectronCuts [ " <<i<<" ] "<<endl; return 0; } ElectronCutList->Add(analysisElectronCuts[i]); analysisElectronCuts[i]->SetFillCutHistograms("",kFALSE,electronCutArray[i].Data()); analysisMesonCuts[i] = new AliConversionMesonCuts(); analysisMesonCuts[i]->InitializeCutsFromCutString(mesonCutArray[i].Data()); MesonCutList->Add(analysisMesonCuts[i]); analysisMesonCuts[i]->SetFillCutHistograms(""); analysisEventCuts[i]->SetAcceptedHeader(HeaderList); } task->SetEventCutList(numberOfCuts,EventCutList); task->SetConversionCutList(numberOfCuts,ConvCutList); task->SetCaloCutList(numberOfCuts,ClusterCutList); task->SetMesonCutList(numberOfCuts,MesonCutList); task->SetElectronCutList(numberOfCuts,ElectronCutList); task->SetMoveParticleAccordingToVertex(kTRUE); task->SetDoMesonAnalysis(kTRUE); task->SetDoMesonQA(enableQAMesonTask); //Attention new switch for Pi0 QA task->SetDoPhotonQA(enableQAPhotonTask); //Attention new switch small for Photon QA task->SetDoClusterQA(1); //Attention new switch small for Cluster QA task->SetUseTHnSparse(isUsingTHnSparse); //connect containers AliAnalysisDataContainer *coutput = mgr->CreateContainer(Form("GammaCaloDalitz_%i",trainConfig), TList::Class(), AliAnalysisManager::kOutputContainer,Form("GammaCaloDalitz_%i.root",trainConfig)); mgr->AddTask(task); mgr->ConnectInput(task,0,cinput); mgr->ConnectOutput(task,1,coutput); return; }
void AddAnalysisTasks(const char *cdb_location) { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); mgr->SetCommonFileName("QAresults.root"); // Statistics task mgr->AddStatisticsTask(kTriggerMask); // // CDB connection // if (doCDBconnect) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C"); AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, run_number); if (!taskCDB) return; } // // Event Statistics (Jan Fiete) // if (doEventStat) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kTRUE /*MC*/); } // // PIDResponse(JENS) // if (doPIDResponse) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse(kTRUE); PIDResponse->SelectCollisionCandidates(kTriggerMask); } // // Centrality (A. Toia) // if (doCentrality) { if(run_flag >= 1500) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"); AliMultSelectionTask *taskMult = AddTaskMultSelection(); taskMult->SetAlternateOADBforEstimators(periodName); } else // old scheme is only valid for PbPb if (iCollisionType == kPbPb) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(); taskCentrality->SetMCInput(); } } // Vertexing (A. Dainese) // if (doVertex) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskVertexESD.C"); // Specific setting for MC AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kTRUE, kTriggerMask); taskvertexesd->SelectCollisionCandidates(kTriggerMask); } // TPC QA (E. Sicking) // if (doQAsym) { // offline trigger in AddTask gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskQAsym.C"); AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell); } // // VZERO QA (C. Cheshkov) // if (doVZERO) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskVZEROQA.C"); AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0); // taskv0qa->SelectCollisionCandidates(); } if (doVZEROPbPb) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/VZERO/AddTaskVZEROPbPb.C"); AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(run_number); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-"); // taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-"); } // // TPC (Jacek Otwinowski & Michael Knichel) // // // Optionally MC information can be used by setting the 1st argument to true // Optionally friends information can be switched off by setting the 2st argument // to false // Optionally highMult axis can be used by setting the 3st argument to true (for PbPb) if (doTPC) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C"); AliPerformanceTask *tpcQA = 0; if (iCollisionType==kPbPb || iCollisionType == kXeXe) { // High multiplicity Pb-Pb tpcQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kTRUE); } else { // Low multiplicity (pp) tpcQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kFALSE); } tpcQA->SelectCollisionCandidates(kTriggerMask); AliPerformanceRes::SetMergeEntriesCut(5000000); } // HLT (Alberica Toia) if (doHLT) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C"); AliPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kTRUE, kTRUE, kFALSE,0,kTRUE); hltQA->SelectCollisionCandidates(kTriggerMask); } // // SPD (A. Mastroserio) // if (doSPD) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskSPDQA.C"); AliAnalysisTaskSPD* taskspdqa = (AliAnalysisTaskSPD*)AddTaskSPDQA(); // Request from Annalisa if (iCollisionType==kPbPb || iCollisionType == kXeXe) taskspdqa->SetHeavyIonMode(); taskspdqa->SelectCollisionCandidates(kTriggerMask); taskspdqa->SetOCDBInfo(run_number, "raw://"); } // // SDD (F. Prino) // if (doSDD) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddSDDPoints.C"); AliAnalysisTaskSE* tasksdd = AddSDDPoints(); tasksdd->SelectCollisionCandidates(kTriggerMask); } // // SSD dEdx (Marek Chojnacki) // if (doSSDdEdx) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C"); AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA(); taskssddedx->SelectCollisionCandidates(kTriggerMask); } // // ITS // if (doITS) { // hardcoded non-zero trigger mask gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceITS.C"); AliAnalysisTaskITSTrackingCheck *itsQA = 0; AliAnalysisTaskITSTrackingCheck *itsQACent0010 = 0; AliAnalysisTaskITSTrackingCheck *itsQACent3050 = 0; AliAnalysisTaskITSTrackingCheck *itsQACent6080 = 0; itsQA = AddTaskPerformanceITS(kTRUE); if(iCollisionType==kPbPb) { itsQACent0010 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,3500,10000); itsQACent3050 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,590,1570); itsQACent6080 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,70,310); } else if(iCollisionType==kXeXe) { itsQACent0010 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,2000,6000); itsQACent3050 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,350,1000); itsQACent6080 = AddTaskPerformanceITS(kTRUE,kFALSE,kFALSE,40,200); } } // // ITS saTracks, align (F.Prino) // if (doITSsaTracks) { // offline trigger in AddTask gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskITSsaTracks.C"); AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kTRUE,kFALSE); itssaTracks->SelectCollisionCandidates(kTriggerMask); } if (doITSalign) { // no offline trigger selection gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskITSAlign.C"); AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011); } // // Global tracks + V0s QA // if(doESDTracks) { // protection for bug fixed in v5-09-14 Bool_t disable=kTRUE; if(gSystem->Getenv("ALIEN_JDL_PACKAGES")){ TString packg=gSystem->Getenv("ALIEN_JDL_PACKAGES"); TObjArray* pkgs=packg.Tokenize("##"); Int_t np=pkgs->GetEntries(); Int_t ver,n1,n2; Char_t str2[20]; for(Int_t i=0; i<np; i++){ TObjString* str=(TObjString*)pkgs->At(i); TString s=str->GetString(); if(s.Contains("AliPhysics")){ s.ReplaceAll("VO_ALICE@",""); sscanf(s.Data(),"AliPhysics::v%d-%d-%d-%s",&ver,&n1,&n2,str2); if(ver>=5 && n1>=9 && n2>=14){ printf("%s -> enable ESD track QA\n",s.Data()); disable=kFALSE; }else{ disable=kTRUE; printf("%s -> disable ESD track QA\n",s.Data()); } } } } if(!disable){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskCheckESDTracks.C"); AliAnalysisTaskCheckESDTracks* taskestr=AddTaskCheckESDTracks("QA",kFALSE,kTRUE,kTRUE); taskestr->SetPtBinning(160,0.,40.); taskestr->SelectCollisionCandidates(kTriggerMask); } } // // TRD (Alex Bercuci, M. Fasel) // if(doTRD) { // no offline trigger selection // steer individual TRD tasks Bool_t doCheckESD(kTRUE), // AliTRDcheckESD doCheckDET(kTRUE), // AliTRDcheckDET doEffic(kTRUE), // AliTRDefficiency doResolution(kTRUE),// AliTRDresolution doCheckPID(kFALSE), // AliTRDcheckPID doV0Monitor(kFALSE);// AliTRDv0Monitor AliTRDpwgppHelper::AddTrainPerformanceTRD(AliTRDpwgppHelper::Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor)); // no offline trigger selection // gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTrainPerformanceTRD.C"); // steer individual TRD tasks // Bool_t // doCheckESD(kTRUE), // AliTRDcheckESD // doCheckDET(kTRUE), // AliTRDcheckDET // doEffic(kTRUE), // AliTRDefficiency // doResolution(kTRUE),// AliTRDresolution // doCheckPID(kFALSE), // AliTRDcheckPID // doV0Monitor(kFALSE);// AliTRDv0Monitor // AddTrainPerformanceTRD(Translate(doCheckESD, doCheckDET, doEffic, doResolution, doCheckPID, doV0Monitor)); } // // ZDC (Chiara Oppedisano) // if(doZDC) { // hardcoded kMB trigger mask gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/ZDC/AddTaskZDCQA.C"); AliAnalysisTaskSE *taskZDC = AddTaskZDCQA(); taskZDC->SelectCollisionCandidates(kTriggerMask); } // // Calorimetry (Gustavo Conesa) // if(doCALO) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C"); AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("default"); taskCaloQA->SetDebugLevel(0); taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetEMCALGeometryName("EMCAL_COMPLETE12SMV1_DCAL_8SM"); taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetImportGeometryFromFile(kFALSE); taskCaloQA->GetAnalysisMaker()->GetCaloUtils()->SetNumberOfSuperModulesUsed(20); AliAnaCalorimeterQA * caloqa = (AliAnaCalorimeterQA*) taskCaloQA->GetAnalysisMaker()->GetListOfAnalysisContainers()->At(0); AliHistogramRanges* histoRanges = caloqa->GetHistogramRanges(); histoRanges->SetHistoPhiRangeAndNBins(77*TMath::DegToRad(), 330*TMath::DegToRad(), 253) ; // offline mask set in AddTask to kMB // taskCaloQA->SelectCollisionCandidates(kTriggerMask); // Add a new calo task with EMC1 trigger only // taskCaloQA = AddTaskCalorimeterQA("trigEMC"); // taskCaloQA->SelectCollisionCandidates(kTriggerEMC); // gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C"); // AliAnalysisTaskCaloTrackCorrelation*taskCaloQA= AddTaskCalorimeterQA("ESD", 2012, kFALSE, kTRUE); // taskCaloQA->SetDebugLevel(0); // offline mask set in AddTask to kMB // taskCaloQA->SelectCollisionCandidates(kTriggerMask); // Add a new calo task with EMC1 trigger only // taskCaloQA= AddTaskCalorimeterQA("ESD", 2012, kFALSE, kTRUE, "", "EMC7"); // taskCaloQA->SetDebugLevel(0); // taskCaloQA->SelectCollisionCandidates(kTriggerEMC); // gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C"); // AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kTRUE); // taskCaloQA->SetDebugLevel(0); // offline mask set in AddTask to kMB // taskCaloQA->SelectCollisionCandidates(kTriggerMask); // Add a new calo task with EMC1 trigger only // taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kTRUE, "", "EMC7"); // taskCaloQA->SetDebugLevel(0); // taskCaloQA->SelectCollisionCandidates(kTriggerEMC); } // // Muon Trigger // if(doMUONTrig) { // no offline trigger selection gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskMTRchamberEfficiency.C"); AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency(kTRUE); } // // Muon Efficiency (not used) // if(doMUONEff) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMUONTrackingEfficiency.C"); AliAnalysisTaskMuonTrackingEff *muonEfficiency = AddTaskMUONTrackingEfficiency(kTRUE,kTRUE,""); if (!isMuonOnly) muonEfficiency->SelectCollisionCandidates(kTriggerMask); muonEfficiency->UseMCLabel(kTRUE); } // // Muon Performance (Philippe Pillot) // // if (doMUONPerf) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/MUON/dep/AddTaskMuonPerformance.C"); AliAnalysisTaskMuonPerformance* muonPerformance = AddTaskMuonPerformance(); if (!isMuonOnly) muonPerformance->SelectCollisionCandidates(kTriggerMask); muonPerformance->UseMCKinematics(kTRUE); muonPerformance->SetMCTrigLevelFromMatchTrk(kTRUE); } // // V0-Decay Reconstruction (Ana Marin) (not used) // if (doV0) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskV0QA.C"); AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kTRUE); } // // Impact parameter resolution ([email protected], [email protected]) // if (doImpParRes) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskImpParRes.C"); AliAnalysisTaskSE* taskimpparres=0; // Specific setting for MC if(iCollisionType==kpp || iCollisionType==kpPb || iCollisionType==kPbp) { taskimpparres= AddTaskImpParRes(kTRUE); } else { taskimpparres= AddTaskImpParRes(kTRUE,-1,kTRUE,kFALSE); } taskimpparres->SelectCollisionCandidates(kTriggerMask); } // // MUON QA (Philippe Pillot) // if (doMUON) { // trigger analysis internal gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskMuonQA.C"); AliAnalysisTaskMuonQA* taskmuonqa = AddTaskMuonQA(kFALSE); taskmuonqa->GetTrackCuts()->SetIsMC(kTRUE); } // // TOF (Francesca Bellini) // if (doTOF) { // gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C"); // AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA(kFALSE); // tofQA->SelectCollisionCandidates(kTriggerMask); gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/TOF/AddTaskTOFqaID.C"); AliAnalysisTaskTOFqaID *tofQA = AddTaskTOFqaID(kFALSE, AliVEvent::kAnyINT, 0, kFALSE, "", kTRUE, 0); // tofQA->SelectCollisionCandidates(kTriggerMask); } // // PIDqa(JENS) // if (doPIDqa) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa(); PIDQA->SelectCollisionCandidates(kTriggerMask); } // // HMPID QA (Giacomo Volpe) // if (doHMPID) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/HMPID/AddTaskHmpidQA.C"); AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kTRUE); // offline mask set in AddTask to kMB taskhmpidqa->SelectCollisionCandidates(kTriggerMask); } // T0 QA (Alla Mayevskaya) if (doT0) { // no offline trigger selection gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/T0/AddTaskT0QA.C"); AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA(); taskt0qa->SelectCollisionCandidates(kTriggerMask); } // FMD QA (Christian Holm Christiansen) if (doFMD) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C"); // Parameters: usemc, usecentrality AliAnalysisTaskSE *forwardQA = (AliAnalysisTaskSE *)AddTaskForwardQA(kTRUE, (Bool_t)doCentrality); // No offline trigger config. needed (see #84077) } // // PHOS QA (Boris Polishchuk) // if (doPHOS) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/CaloCellQA/macros/AddTaskCaloCellsQA.C"); //AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_AnyInt"); AliAnalysisTaskCaloCellsQA *taskPHOSCellQA1 = AddTaskCaloCellsQA(5, 1, NULL,"PHOSCellsQA_AnyInt"); taskPHOSCellQA1->SelectCollisionCandidates(kTriggerMask); taskPHOSCellQA1->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0); //AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(4, 1, NULL,"PHOSCellsQA_PHI7"); AliAnalysisTaskCaloCellsQA *taskPHOSCellQA2 = AddTaskCaloCellsQA(5, 1, NULL,"PHOSCellsQA_PHI7"); taskPHOSCellQA2->SelectCollisionCandidates(AliVEvent::kPHI7); taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0); // Pi0 QA fo PbPb if (iCollisionType == kPbPb || iCollisionType == kXeXe) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C"); AliAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0); } } if (doPHOSTrig) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_TriggerQA/macros/AddTaskPHOSTriggerQA.C"); AliAnalysisTaskPHOSTriggerQA *taskPHOSTrig = AddTaskPHOSTriggerQA(NULL); } // // EMCAL QA (Gustavo Conesa) // if (doEMCAL) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C"); AliAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA(); } // // EvTrk QA (Zaida) // if (doEvTrk) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EvTrkSelection/AddSingleTrackEfficiencyTaskForAutomaticQA.C"); AliAnalysisTask *task = AddSingleTrackEfficiencyTaskForAutomaticQA(); } // // AD QA (Michal Broz)) // if (doAD) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/AD/AddTaskADQA.C"); AliAnalysisTaskADQA *task = AddTaskADQA(); } // // FLOW and BF QA (C.Perez && A.Rodriguez) // if (doFBFqa) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFBFqa.C"); AliAnalysisTaskSE *qaFBFMB = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE); qaFBFMB->SelectCollisionCandidates(AliVEvent::kMB); AliAnalysisTaskSE *qaFBFSC = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFsc",kFALSE); qaFBFSC->SelectCollisionCandidates(AliVEvent::kSemiCentral); AliAnalysisTaskSE *qaFBFCE = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE); qaFBFCE->SelectCollisionCandidates(AliVEvent::kCentral); } }
//______________________________________________________________________________ void AddAnalysisTasks(const char *cdb_location) { // Add all analysis task wagons to the train AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); // // Tender and supplies. Needs to be called for every event. // AliAnalysisManager::SetCommonFileName("AODQA.root"); if (useTender) { gROOT->LoadMacro("$ALICE_PHYSICS/ANALYSIS/TenderSupplies/AddTaskTender.C"); // IF V0 tender needed, put kTRUE below AliAnalysisTaskSE *tender = AddTaskTender(useV0tender); // tender->SetDebugLevel(2); } // Clean Geometry: Ruben // gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/CalibMacros/commonMacros/CleanGeom.C++"); // CleanGeom* clgmTask = new CleanGeom("cleanGeom"); // mgr->AddTask(clgmTask); // AliAnalysisDataContainer *dummyInp = mgr->GetCommonInputContainer(); // if (dummyInp) mgr->ConnectInput(clgmTask,0,dummyInp); // // PIDResponse(JENS) // if (doPIDResponse) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse(); // PIDResponse->SetUserDataRecoPass(1); // PIDResponse->SelectCollisionCandidates(AliVEvent::kAny); } // // PIDqa(JENS) // if (doPIDqa) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa(); PIDQA->SelectCollisionCandidates(AliVEvent::kAny); } // CDB connection // if (doCDBconnect && !useTender) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C"); AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, 0 /*run_number*/); if (!taskCDB) return; AliCDBManager *cdb = AliCDBManager::Instance(); cdb->SetDefaultStorage(cdb_location); // taskCDB->SetRunNumber(run_number); } if (usePhysicsSelection) { // Physics selection task gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); mgr->RegisterExtraFile("event_stat.root"); AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(useMC); mgr->AddStatisticsTask(AliVEvent::kAny); } //Jacek if (iPWGPP) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskFilteredTree.C"); AddTaskFilteredTree("FilterEvents_Trees.root"); } // Centrality if (useCentrality) { if ( run_flag >= 1500 ) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"); AliMultSelectionTask *taskMult = AddTaskMultSelection(); } else { // old scheme is only valid for PbPb if ( iCollision == kPbPb ) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(); //taskCentrality->SelectCollisionCandidates(AliVEvent::kAny); } } } // --- PWGLF - Forward ([email protected]) ----------------------------- if (iPWGLFForward && usePhysicsSelection) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskForwardMult.C"); UShort_t pwglfForwardSys = 0; // iCollision+1; // pp:1, PbPb:2, pPb:3 UShort_t pwglfSNN = 0; // GeV, 0==unknown Short_t pwglfField = 0; AddTaskForwardMult(useMC && useTR, // Need track-refs pwglfForwardSys, // Collision system pwglfSNN, pwglfField); gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/FORWARD/analysis2/AddTaskCentralMult.C"); AddTaskCentralMult(useMC, pwglfForwardSys, pwglfSNN, pwglfField); } //PWGAgammaconv if (iPWGGAgammaconv) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/GammaConv/macros/AddTask_ConversionAODProduction.C"); Int_t dataset=iCollision; if( iCollision == kXeXe) dataset=kPbPb; if( iCollision == kPbp || iCollision == kpPb ) dataset=2; AliAnalysisTask *taskconv = AddTask_ConversionAODProduction(dataset, kFALSE, periodName); mgr->RegisterExtraFile("AliAODGammaConversion.root"); } if (iESDfilter) { // ESD filter task configuration. gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/ESDfilter/macros/AddTaskESDFilter.C"); if (iMUONcopyAOD) { printf("Registering delta AOD file\n"); mgr->RegisterExtraFile("AliAOD.Muons.root"); } Bool_t muonWithSPDTracklets = (iCollision==kPbPb || iCollision==kXeXe) ? kFALSE : kTRUE; // add SPD information to muon AOD only for pp AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER, iMUONcopyAOD, // write Muon AOD kFALSE, // write dimuon AOD kFALSE, // usePhysicsSelection kFALSE, // centrality OBSOLETE kTRUE, // enable TPS only tracks kFALSE, // disable cascades kFALSE, // disable kinks run_flag, // run flag (YY00) 3, // muonMCMode //kTRUE, // useV0Filter kFALSE, // useV0Filter - turned off for PCM to make sense muonWithSPDTracklets, isMuonCaloPass, iPWGGAgammaconv); // Add PCMV0 AliEMCALGeometry::GetInstance("",""); } // ********** PWG3 wagons ****************************************************** // PWGHF vertexing if (iPWGHFvertexing) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/vertexingHF/macros/AddTaskVertexingHF.C"); Int_t configHF=0; if(iCollision == kPbPb || iCollision == kXeXe) configHF=1; AliAnalysisTaskSEVertexingHF *taskvertexingHF = AddTaskVertexingHF(configHF,train_name,"",run_number,periodName); // Now we need to keep in sync with the ESD filter if (!taskvertexingHF) ::Warning("AnalysisTrainNew", "AliAnalysisTaskSEVertexingHF cannot run for this train conditions - EXCLUDED"); else mgr->RegisterExtraFile("AliAOD.VertexingHF.root"); taskvertexingHF->SelectCollisionCandidates(0); } // PWGDQ JPSI filtering (only pp) if (iPWGDQJPSIfilter && (iCollision==kpp)) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGDQ/dielectron/macros/AddTaskJPSIFilter.C"); AliAnalysisTaskSE *taskJPSIfilter = AddTaskJPSIFilter(); if (!taskJPSIfilter) ::Warning("AnalysisTrainNew", "AliAnalysisTaskDielectronFilter cannot run for this train conditions - EXCLUDED"); else mgr->RegisterExtraFile("AliAOD.Dielectron.root"); taskJPSIfilter->SelectCollisionCandidates(0); } // PWGHF D2h if (iPWGHFd2h) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/vertexingHF/AddD2HTrain.C"); AddD2HTrain(kFALSE, 1,0,0,0,0,0,0,0,0,0,0); } // ********** PWG4 wagons ****************************************************** // Jet analysis // Configurations flags, move up? TString kDeltaAODJetName = "AliAOD.Jets.root"; // Bool_t kIsPbPb = (iCollision==kPbPb || iCollision==kXeXe); TString kDefaultJetBackgroundBranch = ""; TString kJetSubtractBranches = ""; UInt_t kHighPtFilterMask = 272;// from esd filter UInt_t iPhysicsSelectionFlag = 0; if (iJETAN) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJets.C"); // Default jet reconstructor running on ESD's AliAnalysisTaskJets *taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction if (!taskjets) ::Fatal("AnalysisTrainNew", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED"); if(kDeltaAODJetName.Length()>0) taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data()); if (iJETANdelta) { // AddTaskJetsDelta("AliAOD.Jets.root"); // need to modify this accordingly in the add task jets mgr->RegisterExtraFile(kDeltaAODJetName.Data()); TString cTmp(""); if(kIsPbPb){ // UA1 intrinsic background subtraction taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data()); } // SICONE taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtration to be done later.... if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data()); cTmp = taskjets->GetNonStdBranch(); if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data()); // Add the clusters.. gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJetCluster.C"); AliAnalysisTaskJetCluster *taskCl = 0; Float_t fCenUp = 0; Float_t fCenLo = 0; Float_t fTrackEtaWindow = 0.9; taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip taskCl->SetBackgroundCalc(kTRUE); taskCl->SetNRandomCones(10); taskCl->SetCentralityCut(fCenLo,fCenUp); taskCl->SetGhostEtamax(fTrackEtaWindow); kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch()); taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15); taskCl->SetCentralityCut(fCenLo,fCenUp); if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data()); taskCl->SetNRandomCones(10); kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch()); taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15); taskCl->SetCentralityCut(fCenLo,fCenUp); if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data()); kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch()); // DO THE BACKGROUND SUBTRACTION if(kIsPbPb&&kJetSubtractBranches.Length()){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/macros/AddTaskJetBackgroundSubtract.C"); AliAnalysisTaskJetBackgroundSubtract *taskSubtract = 0; taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,1,"B0","B%d"); taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data()); if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data()); } } } }
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(...)
TString Setup ( Int_t nmix, const char *options, const char *outputFileName, const char *macroPath = "." ) { // prepare output TString out(""); // // === EXAMINE OPTIONS ========================================================================== // // this is done using the utility 'RsnOptions.C' // which provides a unique way to interpret them TString opt(options); opt.ToUpper(); Bool_t isMC = opt.Contains("MC") || (!opt.Contains("DATA")); Bool_t isPP = opt.Contains("PP") || (!opt.Contains("PBPB")); Bool_t isESD = opt.Contains("ESD"); Bool_t useTender = opt.Contains("Tender"); Bool_t noV0 = opt.Contains("NOV0"); // // === LOAD LIBRARIES =========================================================================== // // load analysis libraries gSystem->Load("libCore"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libMinuit"); gSystem->Load("libPhysics"); gSystem->Load("libTree"); gSystem->Load("libSTEERBase"); gSystem->Load("libESD"); gSystem->Load("libAOD"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libEventMixing"); gSystem->Load("libCORRFW"); gSystem->Load("libPWGLFresonances"); // tender-related libraries if (isESD && useTender) { ::Info("AnalysisSetup", "Loading tender libraries"); gSystem->Load("libTender"); gSystem->Load("libTenderSupplies"); } else if (!isESD) { useTender = kFALSE; } // load development RSN library if (!AliAnalysisAlien::SetupPar("PWGLFresonances.par")) return ""; // // === CREATE ANALYSIS MANAGER ================================================================== // AliAnalysisManager *mgr = new AliAnalysisManager("RsnAnalysisManager"); mgr->SetCommonFileName(outputFileName); ::Info("AnalysisSetup", "Common file name: %s", outputFileName); // // === INPUT / OUTPUT HANDLER CONFIGURATION ===================================================== // if (isESD) { out = "esdTree"; ::Info("AnalysisSetup", "Creating ESD handler"); AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); if (isMC) { ::Info("AnalysisSetup", "Creating MC handler"); AliMCEventHandler *mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); } } else { out = "aodTree"; ::Info("AnalysisSetup", "Creating AOD handler"); AliAODInputHandler *aodHandler = new AliAODInputHandler(); mgr->SetInputEventHandler(aodHandler); } // // === Tender TASK (ESD only -- optional) ======================================================= // if (isESD && useTender) { ::Info("AnalysisSetup", "Adding tender (and then accepting V0 info)", options); gROOT->LoadMacro(Form("%s/AddTaskTender.C", macroPath)); AddTaskTender(); noV0 = kFALSE; } // // === PHYSICS SELECTION (ESD only) ============================================================= // if (isESD) { ::Info("AnalysisSetup", "Add physics selection by default on ESD analysis"); gROOT->LoadMacro("$(ALICE_PHYSICS)/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(isMC); if (noV0) { ::Info("AnalysisSetup", "Skip of V0 info is required"); physSelTask->GetPhysicsSelection()->SetSkipV0(kTRUE); } } // // === CENTRALITY/PLANE (ESD only) ============================================================== // if (isESD && !isPP) { ::Info("AnalysisSetup", "Add centrality and event plane computation tasks"); gROOT->LoadMacro("$(ALICE_PHYSICS)/OADB/macros/AddTaskCentrality.C"); gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskEventplane.C"); AliCentralitySelectionTask* taskCentrality = (AliCentralitySelectionTask*)AddTaskCentrality(); if (isMC) { ::Info("AnalysisSetup", "Setting centrality computation for MC"); taskCentrality->SetMCInput(); } AddTaskEventplane(); } // // === PID RESPONSE ============================================================================= // gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskPIDResponse.C"); AddTaskPIDResponse(isMC,kTRUE,kTRUE); //gROOT->LoadMacro("$(ALICE_ROOT)/ANALYSIS/macros/AddTaskPIDqa.C "); //AddTaskPIDqa(); // // === OTHER TASKS ============================================================================== // // add RSN task gROOT->LoadMacro(Form("%s/AddTaskLStarPPb.C", macroPath)); if (!AddTaskLStarPPb(isMC, isPP, macroPath, nmix)) return ""; ::Info("AnalysisSetup", "Setup successful"); return out; }
void 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 AddTask_GammaConvDalitzV1_pp( Int_t trainConfig = 1, //change different set of cuts Bool_t isMC = kFALSE, //run MC TString fileNameInputForWeighting = "MCSpectraInput.root", // path to file for weigting input Int_t enableMatBudWeightsPi0 = 0, // 1 = three radial bins, 2 = 10 radial bins TString filenameMatBudWeights = "MCInputFileMaterialBudgetWeights.root" ) { Int_t isHeavyIon = 0; // ================== GetAnalysisManager =============================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error(Form("AddTask_GammaConvDalitzV1_%i",trainConfig), "No analysis manager found."); return ; } // ================== GetInputEventHandler ============================= AliVEventHandler *inputHandler=mgr->GetInputEventHandler(); //========= Add PID Reponse to ANALYSIS manager ==== if(!(AliPIDResponse*)mgr->GetTask("PIDResponseTask")){ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AddTaskPIDResponse(isMC); } //========= Set Cutnumber for V0Reader ================================ //TString cutnumber = "00000000000840010015000000"; TString cutnumberPhoton = "06000008400100007500000000"; TString cutnumberEvent = "00000103"; AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); //========= Add V0 Reader to ANALYSIS manager if not yet existent ===== TString V0ReaderName = Form("V0ReaderV1_%s_%s",cutnumberEvent.Data(),cutnumberPhoton.Data()); if( !(AliV0ReaderV1*)mgr->GetTask(V0ReaderName.Data()) ){ AliV0ReaderV1 *fV0ReaderV1 = new AliV0ReaderV1(V0ReaderName.Data()); fV0ReaderV1->SetUseOwnXYZCalculation(kTRUE); fV0ReaderV1->SetCreateAODs(kFALSE);// AOD Output fV0ReaderV1->SetUseAODConversionPhoton(kTRUE); AliConvEventCuts *fEventCuts=NULL; if(cutnumberEvent!=""){ fEventCuts= new AliConvEventCuts(cutnumberEvent.Data(),cutnumberEvent.Data()); fEventCuts->SetPreSelectionCutFlag(kTRUE); fEventCuts->SetV0ReaderName(V0ReaderName); if(fEventCuts->InitializeCutsFromCutString(cutnumberEvent.Data())){ fV0ReaderV1->SetEventCuts(fEventCuts); fEventCuts->SetFillCutHistograms("",kTRUE); } } // Set AnalysisCut Number AliConversionPhotonCuts *fCuts=NULL; if(cutnumberPhoton!=""){ fCuts= new AliConversionPhotonCuts(cutnumberPhoton.Data(),cutnumberPhoton.Data()); fCuts->SetPreSelectionCutFlag(kTRUE); fCuts->SetIsHeavyIon(isHeavyIon); fCuts->SetV0ReaderName(V0ReaderName); if(fCuts->InitializeCutsFromCutString(cutnumberPhoton.Data())){ fV0ReaderV1->SetConversionCuts(fCuts); fCuts->SetFillCutHistograms("",kTRUE); } } if(inputHandler->IsA()==AliAODInputHandler::Class()){ // AOD mode fV0ReaderV1->AliV0ReaderV1::SetDeltaAODBranchName(Form("GammaConv_%s_gamma",cutnumberAODBranch.Data())); } fV0ReaderV1->Init(); AliLog::SetGlobalLogLevel(AliLog::kInfo); //connect input V0Reader mgr->AddTask(fV0ReaderV1); mgr->ConnectInput(fV0ReaderV1,0,cinput); } if( !(AliDalitzElectronSelector*)mgr->GetTask("ElectronSelector") ){ AliDalitzElectronSelector *fElectronSelector = new AliDalitzElectronSelector("ElectronSelector"); //ConfigV0ReaderV1(fV0ReaderV1,ConvCutnumber,IsHeavyIon); // Set AnalysisCut Number AliDalitzElectronCuts *fElecCuts=0; TString ElecCuts = "30105400000003300000"; if( ElecCuts!=""){ fElecCuts= new AliDalitzElectronCuts(ElecCuts.Data(),ElecCuts.Data()); if(fElecCuts->InitializeCutsFromCutString(ElecCuts.Data())){ fElectronSelector->SetDalitzElectronCuts(fElecCuts); fElecCuts->SetFillCutHistograms("",kTRUE); } } fElectronSelector->Init(); mgr->AddTask(fElectronSelector); //connect input fElectronSelector mgr->ConnectInput (fElectronSelector,0,cinput); } //================================================ //========= Add task to the ANALYSIS manager ===== // find input container AliAnalysisTaskGammaConvDalitzV1 *task=NULL; task= new AliAnalysisTaskGammaConvDalitzV1(Form("GammaConvDalitzV1_%i",trainConfig)); task->SetIsHeavyIon(0); task->SetIsMC(isMC); task->SetV0ReaderName(V0ReaderName); CutHandlerConvDalitz cuts; if(trainConfig == 1){ cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202221710"); // standard cut number for pp7TeV cuts.AddCut("00000113", "00200009360300007800004000", "0163103100900000", "20475400253202221710"); // train configs 2 to 4 for estimation of systematics of standard cut number pp7TeV } else if (trainConfig == 2) { cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "10475400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "30475400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253201221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253203221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202121710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202321710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253302221710"); } else if (trainConfig == 3) { cuts.AddCut("00000113", "00200009360300007900004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300007200004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300007100004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300001800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300002800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200049360300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200019360300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20475400253202222710"); } else if (trainConfig == 4) { cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20575400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20775400253202221710"); cuts.AddCut("00000113", "00200009260300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009660300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20425400253202221710"); cuts.AddCut("00000113", "00200009360300007800004000", "0263103100900000", "20407200253202221710"); cuts.AddCut("00000113", "00200009320300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00000113", "00200009305100007800004000", "0263103100900000", "20475400253202221710"); } else if (trainConfig == 102) { cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "10475400253202221710"); cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "30475400253202221710"); cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253201221710"); cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253203221710"); cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253202121710"); cuts.AddCut("00010113", "00200009360300007800004000", "0263103100900000", "20475400253202321710"); } else if (trainConfig == 103) { cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202321710"); cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202301710"); } else if (trainConfig == 104) { // to be used with MBW cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202321710"); cuts.AddCut("00010113", "00200009266300008854404000", "0263103100900000", "20475400253202301710"); } else if (trainConfig == 202) { cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253202221710"); cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "10475400253202221710"); cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "30475400253202221710"); cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253201221710"); cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253203221710"); cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253202121710"); cuts.AddCut("00074113", "00200009360300007800004000", "0263103100900000", "20475400253202321710"); } else { Error(Form("GammaConvV1_%i",trainConfig), "wrong trainConfig variable no cuts have been specified for the configuration"); return; } if(!cuts.AreValid()){ cout << "\n\n****************************************************" << endl; cout << "ERROR: No valid cuts stored in CutHandlerConvDalitz! Returning..." << endl; cout << "****************************************************\n\n" << endl; return; } Int_t numberOfCuts = cuts.GetNCuts(); TList *EventCutList = new TList(); TList *ConvCutList = new TList(); TList *MesonCutList = new TList(); TList *ElecCutList = new TList(); TList *HeaderList = new TList(); TObjString *Header2 = new TObjString("BOX"); HeaderList->Add(Header2); EventCutList->SetOwner(kTRUE); AliConvEventCuts **analysisEventCuts = new AliConvEventCuts*[numberOfCuts]; ConvCutList->SetOwner(kTRUE); AliConversionPhotonCuts **analysisCuts = new AliConversionPhotonCuts*[numberOfCuts]; MesonCutList->SetOwner(kTRUE); AliConversionMesonCuts **analysisMesonCuts = new AliConversionMesonCuts*[numberOfCuts]; ElecCutList->SetOwner(kTRUE); AliDalitzElectronCuts **analysisElecCuts = new AliDalitzElectronCuts*[numberOfCuts]; Bool_t initializedMatBudWeigths_existing = kFALSE; for(Int_t i = 0; i<numberOfCuts; i++){ TString cutName( Form("%s_%s_%s_%s",(cuts.GetEventCut(i)).Data(),(cuts.GetPhotonCut(i)).Data(),(cuts.GetElecCut(i)).Data(),(cuts.GetMesonCut(i)).Data() ) ); analysisEventCuts[i] = new AliConvEventCuts(); analysisEventCuts[i]->SetV0ReaderName(V0ReaderName); analysisEventCuts[i]->InitializeCutsFromCutString((cuts.GetEventCut(i)).Data()); EventCutList->Add(analysisEventCuts[i]); analysisEventCuts[i]->SetFillCutHistograms("",kFALSE); analysisCuts[i] = new AliConversionPhotonCuts(); if (enableMatBudWeightsPi0 > 0){ if (isMC > 0){ if (analysisCuts[i]->InitializeMaterialBudgetWeights(enableMatBudWeightsPi0,filenameMatBudWeights)){ initializedMatBudWeigths_existing = kTRUE;} else {cout << "ERROR The initialization of the materialBudgetWeights did not work out." << endl;} } else {cout << "ERROR 'enableMatBudWeightsPi0'-flag was set > 0 even though this is not a MC task. It was automatically reset to 0." << endl;} } analysisCuts[i]->SetV0ReaderName(V0ReaderName); analysisCuts[i]->InitializeCutsFromCutString((cuts.GetPhotonCut(i)).Data()); ConvCutList->Add(analysisCuts[i]); analysisCuts[i]->SetFillCutHistograms("",kFALSE); analysisMesonCuts[i] = new AliConversionMesonCuts(); analysisMesonCuts[i]->InitializeCutsFromCutString((cuts.GetMesonCut(i)).Data()); MesonCutList->Add(analysisMesonCuts[i]); analysisMesonCuts[i]->SetFillCutHistograms(""); analysisElecCuts[i] = new AliDalitzElectronCuts(); analysisElecCuts[i]->InitializeCutsFromCutString((cuts.GetElecCut(i)).Data()); ElecCutList->Add(analysisElecCuts[i]); analysisElecCuts[i]->SetFillCutHistograms("",kFALSE,cutName); analysisEventCuts[i]->SetAcceptedHeader(HeaderList); } task->SetEventCutList(numberOfCuts,EventCutList); task->SetConversionCutList(numberOfCuts,ConvCutList); task->SetMesonCutList(MesonCutList); task->SetElectronCutList(ElecCutList); task->SetMoveParticleAccordingToVertex(kTRUE); if (initializedMatBudWeigths_existing) { task->SetDoMaterialBudgetWeightingOfGammasForTrueMesons(kTRUE); } //task->SetDoMesonAnalysis(kTRUE); //if (enableQAMesonTask) task->SetDoMesonQA(kTRUE); //Attention new switch for Pi0 QA //if (enableQAMesonTask) task->SetDoPhotonQA(kTRUE); //Attention new switch small for Photon QA //connect containers AliAnalysisDataContainer *coutput = mgr->CreateContainer(Form("GammaConvDalitzV1_%i",trainConfig), TList::Class(), AliAnalysisManager::kOutputContainer,Form("GammaConvDalitzV1_%i.root",trainConfig)); mgr->AddTask(task); mgr->ConnectInput(task,0,cinput); mgr->ConnectOutput(task,1,coutput); return; }
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 runGridDeuteronTree(TString mode="terminate", TString fname="DeuteronTreeTest") { AliLog::SetGlobalDebugLevel(5); //__________________________________________________________________________ // Use AliRoot includes to compile our task gROOT->ProcessLine(".include $ALICE_ROOT/include"); gROOT->ProcessLine(".include $ALICE_PHYSICS/include"); gSystem->Load("libPWGTools.so"); gSystem->Load("libPWGLFnuclex.so"); // Create and configure the alien handler plugin AliAnalysisGrid *alienHandler = CreateAlienHandler(mode,fname); if (!alienHandler) return; // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("testAnalysis"); // Connect plug-in to the analysis manager mgr->SetGridHandler(alienHandler); AliESDInputHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); Bool_t mc = kFALSE; //if(sub == 2) //mc = kTRUE; // Add PIDResponse task gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskPIDResponse *taskPID=AddTaskPIDResponse(mc,kTRUE,kTRUE); // Add Physics Selec gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(); // Add centrality gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(); //taskCentrality->SetPass(2); // Change if changing pass // Add AliPPVsMultUtils task // AliAnalysisUtils* utils = new AliAnalysisUtils(); // add DPhiCorrelations task from $ALICE_PHYSICS/../src/PWGCF/Correlations/DPhi/AliAnalysisTaskPhiCorrelations[.cxx .h] //gROOT->LoadMacro("AliAnalysisTaskPhiCorrelations.cxx+g"); gROOT->LoadMacro("$ALICE_PHYSICS/../src/PWGLF/NUCLEX/Nuclei/DeuteronpA/macros/AddTaskDeuteronTree.C"); AliAnalysisDeuteronTree *taskDeuteronTree = AddTaskDeuteronTree("DeuteronTreeTest"); taskDeuteronTree->SelectCollisionCandidates(AliVEvent::kINT7); //mgr->SetDebugLevel(5); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); // Start analysis in grid. mgr->StartAnalysis("grid",100); // local analysis //TChain *chain = new TChain("aodTree"); //chain->AddFile("./traintest/__alice__data__2010__LHC10d__000126158__ESDs__pass2__AOD147_root_archive_AliAOD_2/0002/root_archive/AliAOD.root"); //mgr->StartAnalysis("local",chain); }
//______________________________________________________________________________ void 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 run(const Char_t *files=NULL, Bool_t mc=kFALSE, Bool_t tpid=kTRUE, Bool_t tchg=kFALSE, Bool_t tpp=kTRUE, Long64_t nev=1234567890, Long64_t first = 0) { TStopwatch timer; timer.Start(); // VERY GENERAL SETTINGS //AliLog::SetGlobalLogLevel(AliLog::kError); if(gSystem->Load("libANALYSIS.so")<0) return; if(gSystem->Load("libANALYSISalice.so")<0) return; if(gSystem->Load("libTender.so")<0) return; if(gSystem->Load("libTenderSupplies.so")<0) return; // if(gSystem->Load("libMES.so")<0) return; if(gSystem->Load("libPWGLFspectra.so")<0) return; // DEFINE DATA CHAIN TChain *chain = NULL; if(!files) chain = MakeChainLST(); else chain = MakeChainLST(files); if(!chain) return; chain->Lookup(); chain->GetListOfFiles()->Print(); Long64_t nfound=chain->GetEntries(); printf("\tENTRIES FOUND [%lli] REQUESTED [%lli]\n", nfound, nev>nfound?nfound:nev); // BUILD ANALYSIS MANAGER AliAnalysisManager *mgr = new AliAnalysisManager("Multiplicity and Event Shape"); AliESDInputHandler *esdH = new AliESDInputHandler(); AliMCEventHandler *mcH(NULL); mgr->SetInputEventHandler(esdH); if(mc) mgr->SetMCtruthEventHandler(mcH = new AliMCEventHandler()); //mgr->SetDebugLevel(10); mgr->SetSkipTerminate(kTRUE); // LOAD tasks // ******************* PID response ****************** gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); if(!mc) AddTaskPIDResponse(); else AddTaskPIDResponse(kTRUE,kTRUE,kTRUE,2); // ******************* Tenders *********************** AliTender *aliTender(NULL); gROOT->LoadMacro("$ALICE_PHYSICS/TENDER/TenderSupplies/AddTaskTender.C"); if(!mc){ // for DATA aliTender = (AliTender*)AddTaskTender(!mc, kTRUE, kTRUE, kTRUE, kTRUE, kFALSE, kTRUE, kFALSE, kFALSE); // (useV0, useTPC, !!! useTOF=kFALSE for MC !!!, useTRD, usePID, useVTX, useT0, useEmc, usePtFix) } else { // for MC aliTender = (AliTender*)AddTaskTender(!mc, kTRUE, kFALSE, kTRUE, kTRUE, kTRUE, kTRUE, kFALSE, kFALSE); // (useV0, useTPC, !!! useTOF=kFALSE for MC !!!, useTRD, usePID, useVTX, useT0, useEmc, usePtFix) } aliTender->SetHandleOCDB(kTRUE); //aliTender->SetDefaultCDBStorage(Form("alien://folder=/alice/data/2010/OCDB?cacheFolder=%s/local", gSystem->ExpandPathName("$HOME"))); // aliTender->SetDefaultCDBStorage(Form("local://%s/local/alice/data/2010/OCDB", gSystem->ExpandPathName("$HOME"))); // ******************* Physics Selection ************* gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask *physSelTask = AddTaskPhysicsSelection(mc); // 0 = real data; 1 = MC // ******************* MES Tender ****************** gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMEStender.C"); AddMEStender(mc); // ******************* MES PID task ****************** if(tpid){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESpidTask.C"); AddMESpidTask(mc); } // // // ******************* MES CHG task ****************** if(tchg){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESchgTask.C"); AddMESchgTask(mc); } // // // ******************* MES ppCol task ****************** if(tpp){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/MultEvShape/AddMESppColTask.C"); AddMESppColTask(mc); } if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("local", chain, nev, first); timer.Stop(); timer.Print(); // verbosity printf("\tCLEANING TASK LIST:\n"); mgr->GetTasks()->Delete(); if(mcH) delete mcH; delete esdH; delete chain; }
void 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(); }