// definition of variables ranges const Double_t nevtmin = 0; const Double_t nevtmax = 5; const Double_t trigmin = 0; const Double_t trigmax = 4; const Int_t trigsidemin = 0; const Int_t trigsidemax = 4; const Int_t chargemin = -3; const Int_t chargemax = 3; const Double_t ymin = -4.5; const Double_t ymax = -2.0; const Double_t etamin = -4.5; const Double_t etamax = -2.0; const Double_t rabsmin = 15; const Double_t rabsmax = 90; const Double_t ptmin = 0; const Double_t ptmax = 100; const Double_t thabsmin = 170; const Double_t thabsmax = 180; const Double_t vzmin = -50; const Double_t vzmax = 50; const Double_t dcamin = 0; const Double_t dcamax = 100; const Double_t pmin = 0; const Double_t pmax = 100; const Double_t mmin = 0; const Double_t mmax = 15; // Resonances const Int_t PDG = 553; // Upsilon ///// Setting up the container grid // CONTAINER DEFINITION UInt_t nevent = 0; // number of event UInt_t y = 1; // dimuon rapidity UInt_t pt = 2; // dimuon pt UInt_t imass = 3; // dimuon invariant mass UInt_t trig = 4; // single muon track-trigger matching UInt_t ptmu = 5; // single muon pt UInt_t pmu = 6; // single muon p UInt_t trigside = 7; // event trigger side (AC, B, E) UInt_t rabsmu = 8; // single muon Rabs UInt_t charge = 9; // total charge of dimuon tracks UInt_t etamu = 10; // single muon eta UInt_t thabsmu = 11; // single muon theta_abs UInt_t vzmu = 12; // single muon Vz UInt_t dcamu = 13; // single muon DCA // Setting up the container grid UInt_t nstep = 5 ; //number of selection steps : MC and ESD for simulation, CINT1B, CMUS1B for real data const Int_t nvar = 14; //number of variables on the grid const Int_t nbin1 = 5; const Int_t nbin2 = 15; const Int_t nbin3 = 100; const Int_t nbin4 = 300; const Int_t nbin5 = 40; const Int_t nbin6 = 100; const Int_t nbin7 = 100; const Int_t nbin8 = 4; const Int_t nbin9 = 300; const Int_t nbin10 = 6; const Int_t nbin11 = 100; const Int_t nbin12 = 200; const Int_t nbin13 = 100; const Int_t nbin14 = 100; class AliAnalysisGrid; class TChain; Bool_t AliCFMuonResUpsilon( const char* runtype = "local", // local, proof or grid const char* taskname = "CFMuonResUpsilon", // task name const bool readAOD = 0, // 1 = AOD based analysis const bool readMC = 0, // 1 = Read MC const bool usePlugin = 0, // grid mode : use plugin const char* gridmode = "test" // plugin mode ("full","test","offline","submit" or "terminate" ) { //load the required aliroot libraries gSystem->Load("libCore.so"); gSystem->Load("libTree.so"); gSystem->Load("libGeom.so"); gSystem->Load("libVMC.so"); gSystem->Load("libPhysics.so"); gSystem->Load("libSTEERBase"); gSystem->Load("libESD"); gSystem->Load("libAOD") ; gSystem->Load("libANALYSIS") ; gSystem->Load("libANALYSISalice") ; //load correction framework library gSystem->Load("libCORRFW.so") ; //compile online the task class gSystem->SetIncludePath("-I. -I$ALICE_ROOT/include -I$ROOTSYS/include -I$ALICE_ROOT/PWG3/muon"); gROOT->LoadMacro("./AliCFMuonResUpsilon.cxx++g"); // Setting Container // ----------------------------------------------- // arrays for the number of bins in each dimension Int_t iBin[nvar]; iBin[0]=nbin1; iBin[1]=nbin2; iBin[2]=nbin3; iBin[3]=nbin4; iBin[4]=nbin5; iBin[5]=nbin6; iBin[6]=nbin7; iBin[7]=nbin8; iBin[8]=nbin9; iBin[9]=nbin10; iBin[10]=nbin11; iBin[11]=nbin12; iBin[12]=nbin13; iBin[13]=nbin14; // arrays for lower bounds : Double_t *binLim1=new Double_t[nbin1+1]; Double_t *binLim2=new Double_t[nbin2+1]; Double_t *binLim3=new Double_t[nbin3+1]; Double_t *binLim4=new Double_t[nbin4+1]; Double_t *binLim5=new Double_t[nbin5+1]; Double_t *binLim6=new Double_t[nbin6+1]; Double_t *binLim7=new Double_t[nbin7+1]; Double_t *binLim8=new Double_t[nbin8+1]; Double_t *binLim9=new Double_t[nbin9+1]; Double_t *binLim10=new Double_t[nbin10+1]; Double_t *binLim11=new Double_t[nbin11+1]; Double_t *binLim12=new Double_t[nbin12+1]; Double_t *binLim13=new Double_t[nbin13+1]; Double_t *binLim14=new Double_t[nbin14+1]; // values for bin lower bounds for(Int_t i=0; i<=nbin1; i++) binLim1[i]=(Double_t)nevtmin+(nevtmax-nevtmin)/nbin1*(Double_t)i ; for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Double_t)ymin+(ymax-ymin)/nbin2*(Double_t)i ; for(Int_t i=0; i<=nbin3; i++) binLim3[i]=(Double_t)ptmin+(ptmax-ptmin)/nbin3*(Double_t)i ; for(Int_t i=0; i<=nbin4; i++) binLim4[i]=(Double_t)mmin+(mmax-mmin)/nbin4*(Double_t)i ; for(Int_t i=0; i<=nbin5; i++) binLim5[i]=(Double_t)trigmin+(trigmax-trigmin)/nbin5*(Double_t)i ; for(Int_t i=0; i<=nbin6; i++) binLim6[i]=(Double_t)ptmin+(ptmax-ptmin)/nbin6*(Double_t)i ; for(Int_t i=0; i<=nbin7; i++) binLim7[i]=(Double_t)pmin+(pmax-pmin)/nbin7*(Double_t)i ; for(Int_t i=0; i<=nbin8; i++) binLim8[i]=(Double_t)trigsidemin+(trigsidemax-trigsidemin)/nbin8*(Double_t)i ; for(Int_t i=0; i<=nbin9; i++) binLim9[i]=(Double_t)rabsmin+(rabsmax-rabsmin)/nbin9*(Double_t)i ; for(Int_t i=0; i<=nbin10; i++) binLim10[i]=(Double_t)chargemin+(chargemax-chargemin)/nbin10*(Double_t)i ; for(Int_t i=0; i<=nbin11; i++) binLim11[i]=(Double_t)etamin+(etamax-etamin)/nbin11*(Double_t)i ; for(Int_t i=0; i<=nbin12; i++) binLim12[i]=(Double_t)thabsmin+(thabsmax-thabsmin)/nbin12*(Double_t)i ; for(Int_t i=0; i<=nbin13; i++) binLim13[i]=(Double_t)vzmin+(vzmax-vzmin)/nbin13*(Double_t)i ; for(Int_t i=0; i<=nbin14; i++) binLim14[i]=(Double_t)dcamin+(dcamax-dcamin)/nbin14*(Double_t)i ; // one container of 2 steps (MC and ESD) with 12 variables AliCFContainer* container = new AliCFContainer("container","container for tracks",nstep,nvar,iBin); // setting the bin limits container -> SetBinLimits(nevent,binLim1); container -> SetBinLimits(y,binLim2); container -> SetBinLimits(pt,binLim3); container -> SetBinLimits(imass,binLim4); container -> SetBinLimits(trig,binLim5); container -> SetBinLimits(ptmu,binLim6); container -> SetBinLimits(pmu,binLim7); container -> SetBinLimits(trigside,binLim8); container -> SetBinLimits(rabsmu,binLim9); container -> SetBinLimits(charge,binLim10); container -> SetBinLimits(etamu,binLim11); container -> SetBinLimits(thabsmu,binLim12); container -> SetBinLimits(vzmu,binLim13); container -> SetBinLimits(dcamu,binLim14); // create AliCFManager AliCFManager* man = new AliCFManager(); // set particle container man->SetParticleContainer(container); // ---------------------------------------------- // check run type if(runtype != "local" && runtype != "proof" && runtype != "grid") { printf("Incorrect runtype! choose \"local\", \"prootf\" or \"grid\"\n"); return; } printf("runtype : %s\n", runtype); // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager(Form("%sAnalysis",taskname)); // set run mode if (runtype == "grid" && usePlugin) { // grid mode // set package for grid(API,ROOT,ALIROOT) const char *package[3] = {"V1.1x","v5-28-00a","v4-21-18-AN"}; AliAnalysisGrid *alienHandler = CreateAlienHandler(taskname,gridmode,package); if (!alienHandler) return; mgr->SetGridHandler(alienHandler); } else { // local mode if (readAOD) { // AOD analysisChain = new TChain("aodTree"); if(readMC) { analysisChain->Add("/home/sahn/alice/mc_prod/PDC09/AODs-100421-100436v2/000/033/AliAODs.root"); // PDC09 AOD //analysisChain->Add("/home/sahn/alice/mc_prod/upsilon/local/run/muonAcc/residual/AODs/AliAODs.root"); // muon acceptance production with residual alignment AOD } else { analysisChain->Add("/home/sahn/alice/p2_prod/LHC10g/AODs/135658/019/AliAOD.Dimuons.root"); // LHC10g-run135658 AOD //analysisChain->Add("/home/sahn/alice/p2_prod/LHC10g/AODs/135658/020/AliAOD.Dimuons.root"); // LHC10g-run135658 AOD } } else { // ESD analysisChain = new TChain("esdTree"); if(readMC) { analysisChain->Add("/home/sahn/alice/mc_prod/upsilon/local/run/muonAcc/residual/005/AliESDs.root"); // muon acceptance production with residual alignment } else { analysisChain->Add("/home/sahn/alice/p2_prod/LHC10g/000135748/ESDs/pass1/10000135748001.150/AliESDs.root"); // LHC10g-run135748 } } } // create the task AliCFMuonResUpsilon *task = new AliCFMuonResUpsilon(taskname); // Set list TList* qaList = new TList(); //CREATE THE CUTS // Choice of the Resonance if(readMC && !readAOD) { AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts"); mcGenCuts->SetRequirePdgCode(PDG); mcGenCuts->SetQAOn(qaList); // Set a pt range of the resonance AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts"); mcKineCuts->SetPtRange(ptmin,ptmax); mcKineCuts->SetQAOn(qaList); // Create and fill the list associated TObjArray* mcList = new TObjArray(0) ; mcList->AddLast(mcKineCuts); mcList->AddLast(mcGenCuts); // kinematic cuts on muons rapidity AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts"); recKineCuts->SetRapidityRange(ymin,ymax); recKineCuts->SetQAOn(qaList); TObjArray* recList = new TObjArray(0) ; recList->AddLast(recKineCuts); man->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList); man->SetParticleCutsList(AliCFManager::kPartAccCuts,recList); } else if(readMC && readAOD) { // for MC in AOD task->SetRequirePdgCode(PDG); task->SetPtRange(ptmin,ptmax); task->SetRapidityRange(ymin,ymax); } task->SetCFManager(man); //here is set the CF manager task->SetQAList(qaList); if(readAOD) task->SetReadAODData(); if(readMC) task->SetReadMCInfo(); if(readMC && !readAOD) { AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); } if(readAOD) { AliAODInputHandler *dataHandler = new AliAODInputHandler(); mgr->SetInputEventHandler(dataHandler); if(!readMC){ // physics selection gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(); } } else { AliESDInputHandler *dataHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(dataHandler); if(!readMC) { // physics selection gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(); } } // Create and connect containers for input/output AliAnalysisDataContainer *cinput = mgr->CreateContainer("cchain",TChain::Class(),AliAnalysisManager::kInputContainer); // output data Char_t file[256]; sprintf(file,"container.%s.%s.%s.%s.root",taskname,runtype,readAOD ? "AOD":"ESD",readMC ? "MC":"Real"); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist0", TH1D::Class(),AliAnalysisManager::kOutputContainer,file); AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("container", AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,file); mgr->AddTask(task); mgr->ConnectInput(task,0,mgr->GetCommonInputContainer()); mgr->ConnectOutput(task,1,coutput1); mgr->ConnectOutput(task,2,coutput2); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); if(usePlugin) mgr->StartAnalysis(runtype); else mgr->StartAnalysis(runtype,analysisChain); return kTRUE ; } AliAnalysisGrid* CreateAlienHandler(const char *taskname, const char *gridmode, const char* package[3]) { //if (!AliAnalysisGrid::CreateToken()) return NULL; AliAnalysisAlien *plugin = new AliAnalysisAlien(); // AliEn plugin mode plugin->SetRunMode(gridmode); // SE copy test //plugin->SetCheckCopy(kFALSE); // JDL Merge plugin->SetMergeViaJDL(kTRUE); plugin->SetOneStageMerging(kFALSE); plugin->SetMaxMergeStages(3); // Set package plugin->SetAPIVersion(package[0]); plugin->SetROOTVersion(package[1]); plugin->SetAliROOTVersion(package[2]); plugin->SetDataPattern("ESDs/pass1/*AliESDs.root"); // Set run numbers //______________________________________________________ // LHC10f plugin->SetGridDataDir("/alice/data/2010/LHC10f/"); const Int_t nruns=24; Int_t run_number[nruns] = { 133006, 133010, 133327, 133330, 133414, 133419, 133563, 133800, 133924, 133969, 133985, 134094, 134198, 134204, 134304, 134497, 134666, 134679, 134685, 134690, 134841, 134905, 134914, 134919 }; plugin->SetGridWorkingDir(Form("workdir-%s",taskname)); //______________________________________________________ // LHC10g /* plugin->SetGridDataDir("/alice/data/2010/LHC10g/"); const Int_t nruns=12; Int_t run_number[nruns] = { 135658, 135704, 135709, 135712, 135748, 135761, 135795, 136177, 136180, 136189, 136372, 136376 }; plugin->SetGridWorkingDir(Form("workdir-%s",taskname)); */ // Set Prefix for real data plugin->SetRunPrefix("000"); // Adding run numbers for(int i=0; iAddRunNumber(run_number[i]); } // output and etc. plugin->SetGridOutputDir("output"); plugin->SetAnalysisSource("AliCFMuonResUpsilon.cxx"); plugin->SetAdditionalLibs("AliCFMuonResUpsilon.h AliCFMuonResUpsilon.cxx"); //plugin->SetSplitMaxInputFileNumber(20); plugin->SetTTL(86400); plugin->SetInputFormat("xml-single"); plugin->SetPrice(1); plugin->SetUseSubmitPolicy(); return plugin; }