void runAliTask() { TStopwatch timer; timer.Start(); // gSystem->Load("libTree.so"); // gSystem->Load("libGeom.so"); // gSystem->Load("libVMC.so"); // gSystem->Load("libPhysics.so"); // //____________________________________________________// // //_____________Setting up required packages___________// // //____________________________________________________// // gSystem->Load("libSTEERBase.so"); // gSystem->Load("libESD.so"); // gSystem->Load("libAOD.so"); // gSystem->Load("libANALYSIS.so"); // gSystem->Load("libANALYSISalice.so"); // gROOT->ProcessLine(".include $ALICE_ROOT/include"); // // //___________Compile analysis task using AClic____________// // gROOT->LoadMacro("../task/AliAnalysisTaskPt.cxx+g"); // // // gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); TChain* chain = CreateESDChain("files.txt", 2); //____________________________________________// // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); AliESDInputHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); //____________________________________________// // 1st Pt task AliAnalysisTaskPt *task1 = new AliAnalysisTaskPt("TaskPt"); mgr->AddTask(task1); // Create containers for input/output AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", TH1::Class(),AliAnalysisManager::kOutputContainer,"Pt.ESD.root"); //____________________________________________// mgr->ConnectInput(task1,0,cinput1); mgr->ConnectOutput(task1,0,coutput1); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); //mgr->StartAnalysis("local",chain); timer.Stop(); timer.Print(); }
void runLocal() { TStopwatch timer; timer.Start(); gSystem->Load("libCore.so"); gSystem->Load("libTree.so"); gSystem->Load("libGeom.so"); gSystem->Load("libVMC.so"); gSystem->Load("libPhysics.so"); //____________________________________________________// //_____________Setting up required packages___________// //____________________________________________________// gSystem->Load("libSTEERBase.so"); gSystem->Load("libSTEER.so"); gSystem->Load("libESD.so"); gSystem->Load("libAOD.so"); gSystem->Load("libANALYSIS.so"); gSystem->Load("libANALYSISalice.so"); gROOT->ProcessLine(".include $ALICE_ROOT/include"); gROOT->ProcessLine(".include $ALICE_ROOT/PHOS"); //___________Compile analysis task using AClic____________// gROOT->LoadMacro("EqEnCalibTask.cxx+g"); // chain using tags // AliTagAnalysis *tagAna = new AliTagAnalysis("ESD"); // tagAna->ChainLocalTags("tags"); // // AliRunTagCuts *runCuts = new AliRunTagCuts(); // AliLHCTagCuts *lhcCuts = new AliLHCTagCuts(); // AliDetectorTagCuts *detCuts = new AliDetectorTagCuts(); // AliEventTagCuts *evCuts = new AliEventTagCuts(); // // evCuts->SetMultiplicityRange(11,12); // TChain* chain = 0x0; // chain = tagAna->QueryTags(runCuts, lhcCuts, detCuts, evCuts); // chain using list of files. gROOT->LoadMacro("$ALICE_ROOT/PWGUD/macros/CreateESDChain.C"); TChain* chain = CreateESDChain("files.txt", 10); // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); AliESDInputHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer(); // Create the task EqEnCalibTask *task = new EqEnCalibTask("EqEnCalibTask"); //task.SetDebugLevel(4); mgr->AddTask(task); mgr->ConnectInput(task, 0, cinput0); AliAnalysisDataContainer *outContainer = mgr->CreateContainer("outContainer", TList::Class(),AliAnalysisManager::kOutputContainer, "ee-calib.output.root"); mgr->ConnectOutput(task, 1, outContainer); // Start the task mgr->SetDebugLevel(1); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("local",chain); timer.Stop(); timer.Print(); }
void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Int_t aProof = kFALSE, Int_t requiredData = 1, const char* option = "") { // runWhat options: 0 = AlidNdEtaTask // 1 = AlidNdEtaCorrectionTask // 2 = both // // aProof option: 0 no proof // 1 proof with chain // 2 proof with dataset // // requiredData option: 0 = only ESD // 1 = ESD+MC // 2 = RAW (ESD+check on event type) // // option is passed to the task(s) // option SAVE is removed and results in moving the output files to maps/<ds name>/<trigger>/<det> // TString taskName; if (runWhat == 0 || runWhat == 2) { Printf("Running AlidNdEtaTask"); } if (runWhat == 1 || runWhat == 2) { Printf("Running AlidNdEtaCorrectionTask"); if (requiredData != 1) { Printf("AlidNdEtaCorrectionTask needs MC. Exiting..."); return; } } if (nRuns < 0) nRuns = 1234567890; if (aProof) { TProof::Open("alice-caf"); Bool_t fullAliroot = kFALSE; // Enable the needed package if (1) { gProof->UploadPackage("$ALICE_ROOT/STEERBase"); gProof->EnablePackage("$ALICE_ROOT/STEERBase"); gProof->UploadPackage("$ALICE_ROOT/ESD"); gProof->EnablePackage("$ALICE_ROOT/ESD"); gProof->UploadPackage("$ALICE_ROOT/AOD"); gProof->EnablePackage("$ALICE_ROOT/AOD"); gProof->UploadPackage("$ALICE_ROOT/ANALYSIS"); gProof->EnablePackage("$ALICE_ROOT/ANALYSIS"); gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice"); gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice"); } else if (!fullAliroot) { gProof->UploadPackage("$ALICE_ROOT/AF-v4-18-12-AN.par"); gProof->EnablePackage("AF-v4-18-12-AN"); } else { // needed if ITS recpoints are accessed, see AlidNdEtaTask, FULLALIROOT define statement gProof->UploadPackage("$ALICE_ROOT/v4-18-15-AN-all.par"); gProof->EnablePackage("v4-18-15-AN-all"); gProof->Exec("TGrid::Connect(\"alien://\")", kTRUE); // TODO add this to loadlibs.C gProof->Exec("gSystem->Load(\"libXMLParser\")", kTRUE); } gProof->UploadPackage("$ALICE_ROOT/PWG0base"); gProof->EnablePackage("$ALICE_ROOT/PWG0base"); } else { gSystem->AddIncludePath("-I${ALICE_ROOT}/include/ -I${ALICE_ROOT}/PWG0/ -I${ALICE_ROOT}/PWG0/dNdEta/"); gSystem->Load("libVMC"); gSystem->Load("libTree"); gSystem->Load("libProof"); gSystem->Load("libSTEERBase"); gSystem->Load("libESD"); gSystem->Load("libAOD"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libPWG0base"); } // Create the analysis manager mgr = new AliAnalysisManager; // Add ESD handler if (fullAliroot) AliESDInputHandler* esdH = new AliESDInputHandlerRP; // for RecPoints else AliESDInputHandler* esdH = new AliESDInputHandler; esdH->SetInactiveBranches("FMD AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks MuonTracks TrdTracks"); mgr->SetInputEventHandler(esdH); AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn; //AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn | AliPWG0Helper::kSPDOnlyL0; //AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPCITS | AliPWG0Helper::kFieldOn; AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kAcceptAll | AliTriggerAnalysis::kOfflineFlag; //AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kAcceptAll | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle; //AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kSPDGFOBits | AliTriggerAnalysis::kOfflineFlag; //AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kSPDGFOBits | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle; //AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0AND | AliTriggerAnalysis::kOfflineFlag; //AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0OR | AliTriggerAnalysis::kOfflineFlag; //AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0OR | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle; AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kMCFlags; //AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kE710Cuts; AliPWG0Helper::PrintConf(analysisMode, trigger, diffTreatment); AliESDtrackCuts* esdTrackCuts = 0; if (!(analysisMode & AliPWG0Helper::kSPD)) { // selection of esd tracks gROOT->ProcessLine(".L ../CreateStandardCuts.C"); esdTrackCuts = CreateTrackCuts(analysisMode); if (!esdTrackCuts) { printf("ERROR: esdTrackCuts could not be created\n"); return; } esdTrackCuts->SetHistogramsOn(kTRUE); } cInput = mgr->GetCommonInputContainer(); // remove SAVE option if set Bool_t save = kFALSE; TString optStr(option); if (optStr.Contains("SAVE")) { optStr = optStr(0,optStr.Index("SAVE")) + optStr(optStr.Index("SAVE")+4, optStr.Length()); save = kTRUE; } // physics selection gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); physicsSelectionTask = AddTaskPhysicsSelection((requiredData == 2) ? kFALSE : kTRUE); // 900 GeV if (0 && requiredData == 2) { physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #769 #3119"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL #446 #2554"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1C-ABCE-NOPF-ALL #1334 #2228"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1-E-NOPF-ALL #790"); } // 7 TeV, run 114783 if (0 && requiredData == 2) { physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #345"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL #2130"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1C-ABCE-NOPF-ALL #3018"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1-E-NOPF-ALL #1238"); } // 7 TeV, run 114786,98 if (0 && requiredData == 2) { physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1B-ABCE-NOPF-ALL #346"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1A-ABCE-NOPF-ALL #2131"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1C-ABCE-NOPF-ALL #3019"); physicsSelectionTask->GetPhysicsSelection()->AddBGTriggerClass("+CINT1-E-NOPF-ALL #1238"); //physicsSelectionTask->GetPhysicsSelection()->Initialize(114786); } // FO efficiency (for MC) if (0 && requiredData != 2) { //const char* fastORFile = "spdFOEff_run104824_52.root"; //const char* fastORFile = "spdFOEff_run104867_92.root"; //const char* fastORFile = "spdFOEff_run105054_7.root"; const char* fastORFile = "spdFOEff_run114931.root"; Printf("NOTE: Simulating FAST-OR efficiency on the analysis level using file %s", fastORFile); TFile::Open(fastORFile); spdFOEff = (TH1F*) gFile->Get("spdFOEff"); physicsSelectionTask->GetPhysicsSelection()->Initialize(114931); physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis()->SetSPDGFOEfficiency(spdFOEff); } // V0 syst. study if (0) { Printf("NOTE: Systematic study for VZERO enabled!"); physicsSelectionTask->GetPhysicsSelection()->Initialize(104867); for (Int_t i=0; i<1; i++) { // for MC and data //physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(15, 61.5, 86.5); physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(6); // only for MC //physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(0, 0, 125); //physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(0); } } // BG study //physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1A-ABCE-NOPF-ALL"); //physicsSelectionTask->GetPhysicsSelection()->AddCollisionTriggerClass("+CINT1C-ABCE-NOPF-ALL"); // Create, add task if (runWhat == 0 || runWhat == 2) { Load("AlidNdEtaTask", aDebug); task = new AlidNdEtaTask(optStr); if (requiredData == 1) task->SetReadMC(); //physicsSelectionTask->GetPhysicsSelection()->SetBin0Callback("AlidNdEtaTask"); // syst. error flags //task->SetUseMCVertex(); //task->SetUseMCKine(); //task->SetOnlyPrimaries(); //task->SetFillPhi(); //task->SetSymmetrize(); // INEL>0 definition if (trigger & AliTriggerAnalysis::kOneParticle) task->SetMultAxisEta1(); task->SetTrigger(trigger); task->SetAnalysisMode(analysisMode); task->SetTrackCuts(esdTrackCuts); //task->SetDeltaPhiCut(0.064); task->SetDiffTreatment(diffTreatment); mgr->AddTask(task); // Attach input mgr->ConnectInput(task, 0, cInput); // Attach output cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer); mgr->ConnectOutput(task, 1, cOutput); } if (runWhat == 1 || runWhat == 2) { Load("AlidNdEtaCorrectionTask", aDebug); task2 = new AlidNdEtaCorrectionTask(optStr); // syst. error flags //task2->SetFillPhi(); //task2->SetOnlyPrimaries(); //task2->SetSymmetrize(); // to account for gaps in real life SPD geometry task2->SetSkipParticles(); // INEL>0 definition if (trigger & AliTriggerAnalysis::kOneParticle) task2->SetMultAxisEta1(); task2->SetTrigger(trigger); task2->SetAnalysisMode(analysisMode); task2->SetTrackCuts(esdTrackCuts); //task2->SetDeltaPhiCut(0.064); task2->SetDiffTreatment(diffTreatment); mgr->AddTask(task2); // Attach input mgr->ConnectInput(task2, 0, cInput); // Attach output cOutput = mgr->CreateContainer("cOutput2", TList::Class(), AliAnalysisManager::kOutputContainer); mgr->ConnectOutput(task2, 0, cOutput); } if (requiredData == 1) { // Enable MC event handler AliMCEventHandler* handler = new AliMCEventHandler; handler->SetReadTR(kFALSE); mgr->SetMCtruthEventHandler(handler); } // Enable debug printouts if (aDebug) mgr->SetDebugLevel(2); // Run analysis mgr->InitAnalysis(); mgr->PrintStatus(); if (aProof == 2) { // process dataset mgr->StartAnalysis("proof", data, nRuns, offset); if (save) { TString path("maps/"); path += TString(data).Tokenize("/")->Last()->GetName(); UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags; switch (triggerNoFlags) { case AliTriggerAnalysis::kMB1: path += "/mb1"; break; case AliTriggerAnalysis::kMB2: path += "/mb2"; break; case AliTriggerAnalysis::kMB3: path += "/mb3"; break; case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break; case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break; case AliTriggerAnalysis::kAcceptAll: path += "/all"; break; case AliTriggerAnalysis::kV0AND: path += "/v0and"; break; case AliTriggerAnalysis::kV0OR: path += "/v0or"; break; case AliTriggerAnalysis::kNSD1: path += "/nsd1"; break; case AliTriggerAnalysis::kMB1Prime: path += "/mb1prime"; break; default: Printf("ERROR: Trigger undefined for path to files"); return; } if (trigger & AliTriggerAnalysis::kOneParticle) path += "-onepart"; if (strlen(requireClass) > 0 && strlen(rejectClass) == 0) { path += Form("/%s", requireClass); } else if (strlen(rejectClass) > 0) path += Form("/%s--%s", requireClass, rejectClass); if (analysisMode & AliPWG0Helper::kSPD) path += "/spd"; if (analysisMode & AliPWG0Helper::kSPDOnlyL0) path += "onlyL0"; if (analysisMode & AliPWG0Helper::kTPC) path += "/tpc"; if (analysisMode & AliPWG0Helper::kTPCITS) path += "/tpcits"; gSystem->mkdir(path, kTRUE); if (runWhat == 0 || runWhat == 2) { gSystem->Rename("analysis_esd_raw.root", path + "/analysis_esd_raw.root"); if (requiredData == 1) gSystem->Rename("analysis_mc.root", path + "/analysis_mc.root"); } if (runWhat == 1 || runWhat == 2) { if (optStr.Contains("process-types")) gSystem->Rename("correction_mapprocess-types.root", path + "/correction_mapprocess-types.root"); else gSystem->Rename("correction_map.root", path + "/correction_map.root"); } gSystem->Rename("event_stat.root", path + "/event_stat.root"); Printf(">>>>> Moved files to %s", path.Data()); } } else if (aProof == 3) { gROOT->ProcessLine(".L CreateChainFromDataSet.C"); ds = gProof->GetDataSet(data)->GetStagedSubset(); chain = CreateChainFromDataSet(ds, "esdTree", nRuns); mgr->StartAnalysis("local", chain, 1234567890, offset); } else { // Create chain of input files gROOT->LoadMacro("../CreateESDChain.C"); chain = CreateESDChain(data, nRuns, offset); //chain = CreateChain("TE", data, nRuns, offset); mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain); } }
void runLocal(const char *chainlistfile, int dataFromAlien=0) { TStopwatch timer; timer.Start(); printf("*** Connect to AliEn ***\n"); if (dataFromAlien) TGrid::Connect("alien://"); gSystem->Load("libProofPlayer"); //____________________________________________________// //_____________Setting up STEERBase.par_______________// //____________________________________________________// setupPar("STEERBase"); gSystem->Load("libSTEERBase"); //____________________________________________________// //_____________Setting up ESD.par_____________________// //____________________________________________________// setupPar("ESD"); gSystem->Load("libVMC"); gSystem->Load("libESD"); //____________________________________________________// //_____________Setting up AOD.par_____________________// //____________________________________________________// setupPar("AOD"); gSystem->Load("libAOD"); //_________________________________________________________// //_____________Setting up ANALYSIS.par_____________________// //_________________________________________________________// setupPar("ANALYSIS"); gSystem->Load("libANALYSIS"); //_________________________________________________________// //_____________Setting up ANALYSISalice.par________________// //_________________________________________________________// setupPar("ANALYSISalice"); gSystem->Load("libANALYSISalice"); //____________________________________________________// //_____________Setting up PWG2AOD.par_________________// //____________________________________________________// setupPar("PWG2AOD"); gSystem->Load("libPWG2AOD"); //____________________________________________________// //_____________Setting up PWG2femtoscopy.par__________// //____________________________________________________// setupPar("PWG2femtoscopy"); gSystem->Load("libPWG2femtoscopy"); //____________________________________________________// //_____________Setting up PWG2femtoscopyUser.par______// //____________________________________________________// setupPar("PWG2femtoscopyUser"); gSystem->Load("libPWG2femtoscopyUser"); //ANALYSIS PART gSystem->SetIncludePath("-I$ROOTSYS/include -I\"/usr/local/CERN/root/include\" -I./PWG2femtoscopy/FEMTOSCOPY/AliFemto -I./PWG2femtoscopyUser/FEMTOSCOPY/AliFemtoUser -I./ESD -I./AOD -I./ANALYSIS -I./PWG2AOD/AOD"); gROOT->LoadMacro("ConfigFemtoAnalysis.C++"); //____________________________________________// //Usage of event tags AliTagAnalysis *analysis = new AliTagAnalysis(); TChain *chain = 0x0; // chain = analysis->GetChainFromCollection(collectionfile,"esdTree"); if (dataFromAlien) { AliTagAnalysis *analysis = new AliTagAnalysis(); chain = analysis->GetChainFromCollection(chainlistfile,"esdTree"); } else { gROOT->LoadMacro("CreateESDChain.C"); chain = CreateESDChain(chainlistfile,500); } //____________________________________________// // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); AliESDInputHandler* esdH = new AliESDInputHandler; AliMCEventHandler *mcH = new AliMCEventHandler; esdH->SetInactiveBranches("FMD CaloCluster"); mgr->SetInputEventHandler(esdH); mgr->SetMCtruthEventHandler(mcH); //____________________________________________// // 1st Pt task AliAnalysisTaskFemto *task1 = new AliAnalysisTaskFemto("TaskFemto"); mgr->AddTask(task1); // Create containers for input/output // AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("input0", TTree::Class(), AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("clist1", TList::Class(),AliAnalysisManager::kOutputContainer,"Femto.ESD.root"); //____________________________________________// cinput1->SetData(chain); mgr->ConnectInput(task1,0,cinput1); mgr->ConnectOutput(task1,0,coutput1); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("local",chain); timer.Stop(); timer.Print(); }
//______________________________________________________________________________ void RunGrid( const char* runtype = "grid", // local, proof or grid const char *gridmode = "test", // Set the run mode (can be "full", "test", "offline", "submit" or "terminate"). Full & Test work for proof const Long64_t nentries = 400, // for local and proof mode, ignored in grid mode. Set to 1234567890 for all events. const Long64_t firstentry = 0, // for local and proof mode, ignored in grid mode const char *proofdataset = "/alice/data/LHC10c_000120821_p1", // path to dataset on proof cluster, for proof analysis const char *proofcluster = "alice-caf.cern.ch", // which proof cluster to use in proof mode const char *taskname = "Deuterons2011ESD" ) { // check run type if(runtype != "local" && runtype != "proof" && runtype != "grid"){ Printf("\n\tIncorrect run option, check first argument of run macro"); Printf("\tint runtype = local, proof or grid\n"); return; } Printf("%s analysis chosen",runtype); gROOT->ProcessLine(".include $ALICE_ROOT/include"); gSystem->AddIncludePath("-I$ALICE_ROOT/include"); gSystem->AddIncludePath("-I$ALICE_ROOT/PWGHF/vertexingHF"); // Load analysis specific libraries //===================================================================== gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER/STEER -I$ALICE_ROOT/STEER/STEERBase -I$ALICE_ROOT/STEER/ESD -I$ALICE_ROOT/STEER/AOD -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/OADB -I$ALICE_ROOT/PWGHF -I$ALICE_ROOT/PWGHF/base -I$ALICE_ROOT/PWGHF/vertexingHF -I$ALICE_ROOT/PWG/FLOW/Base -I$ALICE_ROOT/PWG/FLOW/Tasks -g"); gSystem->Load("libTree.so"); gSystem->Load("libGeom.so"); gSystem->Load("libPhysics.so"); gSystem->Load("libVMC.so"); gSystem->Load("libMinuit.so"); gSystem->Load("libSTEERBase.so"); gSystem->Load("libESD.so"); gSystem->Load("libAOD.so"); gSystem->Load("libANALYSIS.so"); gSystem->Load("libOADB.so"); gSystem->Load("libANALYSISalice.so"); gSystem->Load("libCORRFW.so"); gSystem->Load("libPWGHFbase.so"); gSystem->Load("libPWGflowBase.so"); gSystem->Load("libPWGflowTasks.so"); gSystem->Load("libPWGHFvertexingHF.so"); // Load analysis specific libraries //===================================================================== //------ Create AlienPlugin --------------------- AliAnalysisGrid *plugin = 0x0; TChain *chain = 0x0; if (runtype != "local") { plugin = CreateAlienHandler(taskname, gridmode, proofcluster, proofdataset); if(!plugin) return; } else { gROOT->LoadMacro("$ALICE_ROOT/PWGCF/Correlations/macros/dphicorrelations/CreateESDChain.C"); chain = CreateESDChain("ESDs.txt"); } //---- Create the analysis manager AliAnalysisManager* mgr = new AliAnalysisManager(taskname); if(plugin) mgr->SetGridHandler(plugin); // Input AliESDInputHandler* iH = new AliESDInputHandler("handler","handler for my analisys"); mgr->SetInputEventHandler(iH); //-------------------------------------------------------------- // Other tasks // Physics selection gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask *physSel = AddTaskPhysicsSelection(kFALSE); // useMC // Centrality selection gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentr = AddTaskCentrality(); // PID response gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskPIDResponse *pidTask = AddTaskPIDResponse(kFALSE); // useMC // PID QA gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); AliAnalysisTaskPIDqa *pidQATask = AddTaskPIDqa(); gROOT->LoadMacro("./AliAnalysisTaskFlowd.cxx+g");//$ALICE_ROOT/PWGLF/STRANGENESS/Cascades/AliAnalysisTaskCheckCascadePbPb.cxx++g"); gROOT->LoadMacro("./AddTaskFlowd.C");//$ALICE_ROOT/PWGLF/STRANGENESS/Cascades/macros/AddTaskCheckCascadePbPb.C"); AliAnalysisTaskFlowd *task = AddTaskFlowd(kTRUE); //__________________________________________________________________________ // Disable debug printouts mgr->SetDebugLevel(3); AliLog::SetGlobalLogLevel(AliLog::kFatal); AliLog::SetGlobalDebugLevel(0); //__________________________________________________________________________ if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); // Start analysis in grid. if (runtype == "local") mgr->StartAnalysis(runtype,chain,nentries,firstentry); else mgr->StartAnalysis(runtype,nentries,firstentry); }
void CreateChain(const anaModes mode, TChain * chain){ //Fills chain with data TString ocwd = gSystem->WorkingDirectory(); //----------------------------------------------------------- //Analysis of CAF data locally and with PROOF //----------------------------------------------------------- if(mode ==mPROOF || mode ==mLocalCAF){ // Chain from CAF gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); // The second parameter is the number of input files in the chain chain = CreateESDChain("ESD12001.txt", 5); } //--------------------------------------- //Local files analysis //--------------------------------------- else if(mode == mLocal){ //If you want to add several ESD files sitting in a common directory INDIR //Specify as environmental variables the directory (INDIR), the number of files //to analyze (NFILES) and the pattern name of the directories with files (PATTERN) if(gSystem->Getenv("INDIR")) kInDir = gSystem->Getenv("INDIR") ; else cout<<"INDIR not set, use default: "<<kInDir<<endl; if(gSystem->Getenv("PATTERN")) kPattern = gSystem->Getenv("PATTERN") ; else cout<<"PATTERN not set, use default: "<<kPattern<<endl; if(gSystem->Getenv("NFILES")) kFile = atoi(gSystem->Getenv("NFILES")) ; else cout<<"NFILES not set, use default: "<<kFile<<endl; //Check if env variables are set and are correct if ( kInDir && kFile) { printf("Get %d files from directory %s\n",kFile,kInDir); if ( ! gSystem->cd(kInDir) ) {//check if ESDs directory exist printf("%s does not exist\n", kInDir) ; return ; } cout<<"INDIR : "<<kInDir<<endl; cout<<"NFILES : "<<kFile<<endl; cout<<"PATTERN : " <<kPattern<<endl; TString datafile=""; if(kInputData == "ESD") datafile = "AliESDs.root" ; else if(kInputData == "AOD") datafile = "AliAOD.root" ; else if(kInputData == "MC") datafile = "galice.root" ; //Loop on ESD files, add them to chain Int_t event =0; Int_t skipped=0 ; char file[120] ; for (event = 0 ; event < kFile ; event++) { sprintf(file, "%s/%s%d/%s", kInDir,kPattern,event,datafile.Data()) ; TFile * fESD = 0 ; //Check if file exists and add it, if not skip it if ( fESD = TFile::Open(file)) { if ( fESD->Get(kTreeName) ) { printf("++++ Adding %s\n", file) ; chain->AddFile(file); } } else { printf("---- Skipping %s\n", file) ; skipped++ ; } } printf("number of entries # %lld, skipped %d\n", chain->GetEntries(), skipped*100) ; } else { TString input = "AliESDs.root" ; cout<<">>>>>> No list added, take a single file <<<<<<<<< "<<input<<endl; chain->AddFile(input); } }// local files analysis //------------------------------ //GRID xml files //----------------------------- else if(mode == mGRID){ //Get colection file. It is specified by the environmental //variable XML if(gSystem->Getenv("XML") ) kXML = gSystem->Getenv("XML"); else sprintf(kXML, "collection.xml") ; if (!TFile::Open(kXML)) { printf("No collection file with name -- %s -- was found\n",kXML); return ; } else cout<<"XML file "<<kXML<<endl; //Load necessary libraries and connect to the GRID gSystem->Load("libNetx") ; gSystem->Load("libRAliEn"); TGrid::Connect("alien://") ; //Feed Grid with collection file //TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\", 0)", kXML)); TGridCollection * collection = (TGridCollection*) TAlienCollection::Open(kXML); if (! collection) { AliError(Form("%s not found", kXML)) ; return kFALSE ; } TGridResult* result = collection->GetGridResult("",0 ,0); // Makes the ESD chain printf("*** Getting the Chain ***\n"); for (Int_t index = 0; index < result->GetEntries(); index++) { TString alienURL = result->GetKey(index, "turl") ; cout << "================== " << alienURL << endl ; chain->Add(alienURL) ; } }// xml analysis gSystem->ChangeDirectory(ocwd.Data()); }
void runFlowTaskCentralityKinkTrain( Int_t mode = mLocal, Bool_t useFlowParFiles = kFALSE, Bool_t DATA = kTRUE, const Char_t* dataDir="fileList", Int_t nEvents = 1e4, Int_t offset=0 ) { // Time: TStopwatch timer; timer.Start(); // Load needed libraries: LoadLibraries(mode,useFlowParFiles); // Create analysis manager: AliAnalysisManager *mgr = new AliAnalysisManager("FlowAnalysisManager"); // Chains: if(mode == mLocal) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGUD/macros/CreateESDChain.C"); TChain* chain = CreateESDChain(dataDir, nEvents, offset); //TChain* chain = CreateAODChain(dataDir, nEvents, offset); } // Connect plug-in to the analysis manager: if(mode == mGrid) { gROOT->LoadMacro("CreateAlienHandler.C"); AliAnalysisGrid *alienHandler = CreateAlienHandler(useFlowParFiles); if(!alienHandler) return; mgr->SetGridHandler(alienHandler); } // Event handlers: AliVEventHandler* esdH = new AliESDInputHandler; mgr->SetInputEventHandler(esdH); if (!DATA) { AliMCEventHandler *mc = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mc); } // Task to check the offline trigger: gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AddTaskPhysicsSelection(!DATA); //Add the centrality determination task gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask* centSelTask = AddTaskCentrality(); if (!DATA) centSelTask->SetMCInput(); //add the PID response task gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskPIDResponse* pidresponsetask = AddTaskPIDResponse(!DATA); //Add the TOF tender //gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/AddTaskTenderTOF.C"); //AddTaskTenderTOF(); // Setup kink analysis per centrality bin: gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityKink.C"); for (Int_t i=binfirst; i<binlast+1; i++) { Float_t lowCentralityBinEdge = centralityArray[i]; Float_t highCentralityBinEdge = centralityArray[i+1]; AddTaskFlowCentralityKink( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kUnknown, AliFlowTrackCuts::kTOFbeta, -1,2,kTRUE ); AddTaskFlowCentralityKink( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kUnknown, AliFlowTrackCuts::kTOFbeta, 1,2,kTRUE ); AddTaskFlowCentralityKink( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kUnknown, AliFlowTrackCuts::kTOFbeta, -1,3 ); AddTaskFlowCentralityKink( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kUnknown, AliFlowTrackCuts::kTOFbeta, 1,3 ); } // end of for (Int_t i=0; i<numberOfCentralityBins; i++) // Setup kaon analysis per centrality bin: gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityPID.C"); for (Int_t i=binfirst; i<binlast+1; i++) { Float_t lowCentralityBinEdge = centralityArray[i]; Float_t highCentralityBinEdge = centralityArray[i+1]; AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kKaon, AliFlowTrackCuts::kTOFbeta, -1,2,kTRUE ); AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kKaon, AliFlowTrackCuts::kTOFbeta, 1,2,kTRUE ); AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kKaon, AliFlowTrackCuts::kTOFbeta, -1,3 ); AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kKaon, AliFlowTrackCuts::kTOFbeta, 1,3 ); } // end of for (Int_t i=0; i<numberOfCentralityBins; i++) // Setup He3 analysis per centrality bin: gROOT->LoadMacro("$ALICE_PHYSICS/PWGCF/FLOW/macros/Kinks/AddTaskFlowCentralityPID.C"); for (Int_t i=binfirst; i<binlast+1; i++) { Float_t lowCentralityBinEdge = centralityArray[i]; Float_t highCentralityBinEdge = centralityArray[i+1]; AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kHe3, AliFlowTrackCuts::kTPCNuclei, -1,2,kTRUE ); AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kHe3, AliFlowTrackCuts::kTPCNuclei, 1,2,kTRUE ); AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kHe3, AliFlowTrackCuts::kTPCNuclei, -1,3 ); AddTaskFlowCentralityPID( lowCentralityBinEdge, highCentralityBinEdge, commonOutputFileName, AliPID::kHe3, AliFlowTrackCuts::kTPCNuclei, 1,3 ); } // end of for (Int_t i=0; i<numberOfCentralityBins; i++) // Enable debug printouts: mgr->SetDebugLevel(2); // Run the analysis: if(!mgr->InitAnalysis()) return; mgr->PrintStatus(); if(mode == mLocal) { mgr->StartAnalysis("local",chain); } else if(mode == mPROOF) { mgr->StartAnalysis("proof",dataDir,nEvents,offset); } else if(mode == mGrid) { mgr->StartAnalysis("grid"); } // Print real and CPU time used for analysis: timer.Stop(); timer.Print(); } // end of void runFlowTaskCentralityPIDTrain(...)
void CPVanalysis(const TString dataset="") { gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libPhysics"); //load analysis framework gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_ROOT/PHOS"); // A task can be compiled dynamically with AClic gROOT->LoadMacro("AliAnalysisTaskCPV.cxx+g"); // Connect to alien TString token = gSystem->Getenv("GRID_TOKEN") ; token="OK"; if ( token == "OK" ) TGrid::Connect("alien://"); else Printf("You are not connected to the GRID") ; // AliInfo("You are not connected to the GRID") ; cout << "CPVanalysis: processing collection " << dataset << endl; // Create the chain TChain* chain; if (dataset.Contains(".txt")) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/CreateESDChain.C"); chain = CreateESDChain(dataset.Data(), 1000); } else if (dataset.Contains(".xml")) { chain = new TChain("esdTree"); TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset)); TAlienResult* result = collection->GetGridResult("",0 ,0); TList* rawFileList = result->GetFileInfoList(); for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) { TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(counter)) ; const char * rawFile = fi->GetCurrentUrl()->GetUrl() ; printf("Processing %s\n", rawFile) ; chain->Add(rawFile); printf("Chain: %d entries.\n",chain->GetEntries()); } } // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("CPVanalysis"); // ESD input handler AliESDInputHandler* esdH = new AliESDInputHandler(); esdH->SetReadFriends(kFALSE); mgr->SetInputEventHandler(esdH); // Debug level mgr->SetDebugLevel(0); //PID task gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTask *taskPID = AddTaskPIDResponse(/*Bool_t isMC=*/ kFALSE, /*Bool_t autoMCesd=*/kTRUE, /*Bool_t tuneOnData=*/kTRUE); // // Add physics selection gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(); physSelTask->GetPhysicsSelection()->SetUseBXNumbers(kFALSE);// ---> ??? // Add my task AliAnalysisTaskCPV *task1 = new AliAnalysisTaskCPV("CPVanalysis"); // task1->SelectCollisionCandidates(AliVEvent::kMB); mgr->AddTask(task1); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("histCPV1",TList::Class(),AliAnalysisManager::kOutputContainer,"CPVanalysis.root"); AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("histCPV2",TList::Class(),AliAnalysisManager::kOutputContainer,"CPVanalysis.root"); ((AliInputEventHandler*)mgr->GetInputEventHandler())->SetNeedField(1); // Connect input/output mgr->ConnectInput(task1 , 0, cinput); mgr->ConnectOutput(task1, 1, coutput1); mgr->ConnectOutput(task1, 2, coutput2); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } }