//___________________________________________________________ void runAlien(TString data, TString mode = "test", Bool_t MC = kFALSE){ if(!gSystem->Getenv("ALICE_ROOT")){ printf("AliRoot has to be initialized\n"); return; } // check for valid modes const int kModes = 5; TString allowed_modes[kModes] = {"proof", "prooftest", "test", "full", "submit"}; Bool_t isValid = kFALSE; mode.ToLower(); for(int imode = 0; imode < kModes; imode++){ if(!mode.CompareTo(allowed_modes[imode])) isValid = kTRUE; } if(!isValid){ printf("invalid analysis mode selected\n"); return; } analysis_mode = mode; Bool_t proofmode = mode.Contains("proof"); // libraries to be loaded gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libCORRFW"); gSystem->Load("libPWGhfe"); // Create Analysis Manager AliAnalysisManager *runAnalysis = new AliAnalysisManager("Heavy Flavour Electron Analysis"); runAnalysis->SetCommonFileName(output_file.Data()); runAnalysis->SetInputEventHandler(new AliESDInputHandler); if(MC) runAnalysis->SetMCtruthEventHandler(new AliMCEventHandler); AliAnalysisAlien *alienhandler = CreateAlienHandler(proofmode); printf("alienhandler %p\n", alienhandler); runAnalysis->SetGridHandler(alienhandler); //return; // Specify input (runs or dataset) if(!proofmode){ // Query sample ID and runs TString sample; TArrayI listofruns; DecodeDataString(data, sample, listofruns); AddInput(alienhandler, sample, listofruns, MC); } else { alienhandler->SetProofDataSet(data); } // Add Tasks gROOT->LoadMacro(Form("%s/OADB/macros/AddTaskPhysicsSelection.C", gSystem->Getenv("ALICE_ROOT"))); gROOT->LoadMacro(Form("%s/PWG3/hfe/macros/AddTaskHFE.C", gSystem->Getenv("ALICE_ROOT"))); AddTaskPhysicsSelection(MC); AddTaskHFE(); // @TODO: MC and PbPb flag to be fixed // Run Analysis TString anamode = proofmode ? "proof" : "grid"; if(runAnalysis->InitAnalysis()){ runAnalysis->PrintStatus(); runAnalysis->StartAnalysis(anamode); } }
void runProofFwdDetsQA(const char * dataset = "/COMMON/COMMON/LHC09a4_run8101X",Long64_t nentries=100000, Long64_t firstentry=0) { gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->AddIncludePath("-I$ALICE_ROOT/include"); // Connect to Proof gEnv->SetValue("XSec.GSI.DelegProxy","2"); TProof::Open("cheshkov:PWG0@alicecaf"); // Upload and enable packages: please use the correct version! gProof->UploadPackage("/afs/cern.ch/alice/caf/sw/ALICE/PARs/v4-16-Release/AF-v4-16"); gProof->EnablePackage("/afs/cern.ch/alice/caf/sw/ALICE/PARs/v4-16-Release/AF-v4-16"); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("AliAnaFwdDetsQA"); AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliVEventHandler* handler = new AliMCEventHandler; mgr->SetMCtruthEventHandler(handler); // Create task gProof->Load(Form("%s/PWGPP/AliAnaFwdDetsQA.cxx++g", gSystem->Getenv("ALICE_ROOT"))); AliAnalysisTask *task = new AliAnaFwdDetsQA("AliAnaFwdDetsQA"); // Add task mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "FwdDetsQA.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); // Enable debug printouts mgr->SetDebugLevel(3); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); TFileCollection *proofColl = gProof->GetDataSet(dataset); TChain *chain = new TChain("esdTree"); chain->AddFileInfoList((TCollection*)(proofColl->GetList())); mgr->StartAnalysis("proof", chain, nentries, firstentry); // mgr->StartAnalysis("proof",dataset,nentries,firstentry); }
void RunLinkToMCAnalysisExample(const char* esdFile = "./AliESDs.root") { // Load needed libraries gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libPhysics"); gSystem->Load("libSTEERBase"); gSystem->Load("libESD"); gSystem->Load("libAOD"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libPWGHFbase"); gSystem->Load("libPWGmuon"); // Create the TChain for esdTrees in the AliESDs.root file. TChain* chain = new TChain("esdTree"); chain->Add(esdFile); if (!chain) return; // Create the analysis manager and event handlers. AliAnalysisManager* mgr = new AliAnalysisManager("Analysis Train", "An example analysis train setup for AliAnalysisTaskLinkToMC."); AliESDInputHandler* esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetReadTR(kTRUE); AliAODHandler* aodHandler = new AliAODHandler(); mgr->SetOutputEventHandler(aodHandler); aodHandler->SetOutputFileName("AliAOD.root"); // Create the analysis task and setup the parameters. AliAnalysisTaskLinkToMC* linktask = new AliAnalysisTaskLinkToMC("Task to link ESD tracks to corresponding MC tracks."); linktask->MinClusters(6); linktask->HardCutLimitX(4); linktask->HardCutLimitY(4); linktask->SigmaCut(5.); linktask->MinClustersInSt45(3); linktask->StationMustMatch(1, true); // At least one cluster in station 1 must match. linktask->StationMustMatch(2, true); // At least one cluster in station 2 must match. linktask->StationMustMatch(3, true); // At least one cluster in station 3 must match. linktask->GenerateHistograms(true); mgr->AddTask(linktask); // Create the input and output containers and connect them up to the analysis task. AliAnalysisDataContainer* cinEsd = mgr->GetCommonInputContainer(); AliAnalysisDataContainer* coutAod = mgr->GetCommonOutputContainer(); AliAnalysisDataContainer* coutHists = mgr->CreateContainer("cHists", TList::Class(), AliAnalysisManager::kOutputContainer, "hists.root"); mgr->ConnectInput(linktask, 0, cinEsd); mgr->ConnectOutput(linktask, 0, coutAod); mgr->ConnectOutput(linktask, 1, coutHists); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } }
void runTOFCalibTaskOnProof() { TStopwatch timer; timer.Start(); printf("*** Open PROOF ***"); gEnv->SetValue("XSec.GSI.DelegProxy","2"); TProof::Open("alicecaf"); gProof->UploadPackage("STEERBase.par"); gProof->EnablePackage("STEERBase"); gProof->UploadPackage("ESD.par"); gProof->EnablePackage("ESD"); gProof->UploadPackage("AOD.par"); gProof->EnablePackage("AOD"); gProof->UploadPackage("ANALYSIS.par"); gProof->EnablePackage("ANALYSIS"); gProof->UploadPackage("ANALYSISalice.par"); gProof->EnablePackage("ANALYSISalice"); gProof->Load("AliTOFArray.cxx++g"); gProof->Load("AliTOFCalibTask.cxx++g"); gROOT->LoadMacro("AddTaskTOFCalib.C"); cout << "Loaded AddTaskTOFCalib macro "<< endl; gProof->ShowEnabledPackages(); //ANALYSIS PART //____________________________________________// // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); AliESDInputHandler* esdH = new AliESDInputHandler; esdH->SetInactiveBranches("FMD CaloCluster"); mgr->SetInputEventHandler(esdH); Bool_t domc = kFALSE; if (domc) { AliMCEventHandler *mcH = new AliMCEventHandler; mgr->SetMCtruthEventHandler(mcH); } //____________________________________________// // 1st TOFCalib task AliTOFCalibTask *taskTOFCalib = AddTaskTOFCalib(); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("proof","/COMMON/COMMON/LHC08c11_10TeV_0.5T",1000); timer.Stop(); timer.Print(); }
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 runProofT0analysis(const char * dataset = "/COMMON/COMMON/LHC09a4_10TeV_200k#esdTree",Long64_t nentries=20000, Long64_t firstentry=0) { // Connect to Proof TProof::Open("proof://[email protected]"); //TProof::Open("lxb6046"); // Upload and enable packages: please use the correct version! gProof->UploadPackage("AF-v4-16"); gProof->EnablePackage("AF-v4-16"); gProof->ShowDataSets(); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("AliT0MultiplicityTask"); AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliVEventHandler* handler = new AliMCEventHandler; mgr->SetMCtruthEventHandler(handler); // Create task // gProof->Load("AliMCComparisonTrack.cxx++g"); gProof->Load("AliT0MultiplicityTask.cxx++g"); AliAnalysisTask *task = new AliT0MultiplicityTask("AliT0MultiplicityTask"); // Add task mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->CreateContainer("cchain", TChain::Class(), AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *coutput = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "MultHist.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); // Enable debug printouts mgr->SetDebugLevel(3); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("proof",dataset,nentries,firstentry); }
void QAmerge(const char *dir, Int_t stage) { // Merging method TStopwatch timer; timer.Start(); TString outputDir = dir; TString outputFiles = "QAresults.root,EventStat_temp.root"; TString mergeExcludes = ""; TObjArray *list = outputFiles.Tokenize(","); TIter *iter = new TIter(list); TObjString *str; TString outputFile; Bool_t merged = kTRUE; while((str=(TObjString*)iter->Next())) { outputFile = str->GetString(); // Skip already merged outputs if (!gSystem->AccessPathName(outputFile)) { printf("Output file <%s> found. Not merging again.",outputFile.Data()); continue; } if (mergeExcludes.Contains(outputFile.Data())) continue; merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, stage); if (!merged) { printf("ERROR: Cannot merge %s\n", outputFile.Data()); continue; } } TString infolog = "fileinfo.log"; AliAnalysisAlien::MergeInfo(infolog, dir); // read the analysis manager from file if (!outputDir.Contains("Stage")) { ofstream out; out.open("outputs_valid", ios::out); out.close(); return; } AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); mgr->SetRunFromPath(mgr->GetRunFromAlienPath(dir)); mgr->SetSkipTerminate(kFALSE); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); AliLog::SetGlobalLogLevel(AliLog::kError); TTree *tree = NULL; gROOT->cd(); mgr->StartAnalysis("gridterminate", tree); ofstream out; out.open("outputs_valid", ios::out); out.close(); timer.Print(); }
void AnalysisMacroGlob(TString dataset="/alice/sim/LHC10f8f_130844", TString outFName="glovar.root", Int_t nEvents = 5000, Int_t nEventsSkip = 0) { // TString format = GetFormatFromDataSet(dataset); // // ALICE stuff AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) mgr = new AliAnalysisManager("Test train"); // Bool_t isMC = dataset.Contains("sim"); InputHandlerSetup(format,kFALSE,isMC); gProof->Load("AliTaskGlobVar.cxx++g"); // /* gROOT->LoadMacro("AddTaskGlobVar.C"); AliTaskGlobVar *task = AddTaskGlobVar(outFName.Data()); */ AliTaskGlobVar *task = new AliTaskGlobVar("AliTaskGlobVar"); // create output container AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("clist", TList::Class(),AliAnalysisManager::kOutputContainer,outFName.Data()); // add our task to the manager mgr->AddTask(task); // // finaly connect input and output mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task,1,coutput1); // if (!isMC) { AddPhysicsSelection(); task->SelectCollisionCandidates( AliVEvent::kUserDefined ); task->SetUseMC(kFALSE); } else task->SetUseMC(kTRUE); // else task->SelectCollisionCandidates( AliVEvent::kMB); // // Run analysis mgr->InitAnalysis(); // process dataset mgr->StartAnalysis("proof", dataset.Data(), nEvents, nEventsSkip); // TString evstCmd = "if [ -e event_stat.root ]; then \nmv event_stat.root evstat_"; evstCmd += outFName; evstCmd += " \nfi"; gSystem->Exec( evstCmd.Data() ); }
void runProofTRDComparison(const char *dataset="/PWG0/COMMON/run30000X_10TeV_0.5T",Long64_t nentries=1000, Long64_t firstentry=0) { // Connect to Proof TProof::Open("lxb6046"); // Upload and enable packages: please use the correct version! gProof->UploadPackage("AF-v4-14"); gProof->EnablePackage("AF-v4-14"); // Create the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("AliTRDComparison"); AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); // Enable MC event handler AliVEventHandler* handler = new AliMCEventHandler; mgr->SetMCtruthEventHandler(handler); // Create task gProof->Load("AliMCComparisonTrack.cxx++g"); gProof->Load("AliTRDComparisonTask.cxx++g"); AliAnalysisTask *task = new AliTRDComparisonTask("AliTRDComparisonTask"); // Add task mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer* cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer* coutput = mgr->CreateContainer("coutput", TList::Class(), AliAnalysisManager::kOutputContainer, "AliTRDComparisonHist.root"); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); // Enable debug printouts mgr->SetDebugLevel(3); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); mgr->StartAnalysis("proof",dataset,nentries,firstentry); }
void 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(); }
Bool_t RunAnalysisManager(TString anSrc = "proof", TString anMode = "test", Long64_t nEvents = 1e10, Long64_t nSkip = 0) { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Printf("Error [RunAnalysisManager] : mgr is null !!!"); return kFALSE; } // Run analysis mgr->InitAnalysis(); mgr->PrintStatus(); if ((!anSrc.CompareTo("proof")) || (!anSrc.CompareTo("local"))) { mgr->StartAnalysis(anSrc.Data(), nEvents, nSkip); } else { mgr->StartAnalysis(anSrc.Data()); } return kTRUE; }
void PrintManager(TObject *mgrObj) { AliAnalysisManager *mgr = (AliAnalysisManager *)mgrObj; if (!mgr->InitAnalysis()) return; mgr->RunLocalInit(); mgr->PrintStatus(); Printf("Analysis Manager : %s '%s'",mgr->GetName(),mgr->GetTitle() ); TObjArray *a = mgr->GetTasks(); if (a) Printf("Tasks total : %d",a->GetEntries()); TIter next(mgr->GetTasks()); AliAnalysisTask *task; while ((task = (AliAnalysisTask *) next())) { if (task->IsA() == AliRsnMiniAnalysisTask::Class()) { Printf(" Task [RSN-MINI] : %s '%s'",task->GetName(),task->GetTitle()); AliRsnMiniAnalysisTask *rsnMiniTask = (AliRsnMiniAnalysisTask *)task; rsnMiniTask->Print(); } else if (task->IsA() == AliRsnAnalysisTask::Class()) { Printf(" Task [RSN-----] : %s '%s'",task->GetName(),task->GetTitle()); AliRsnAnalysisTask *rsnTask = (AliRsnAnalysisTask *)task; rsnTask->Print(); AliVEventHandler *ih = mgr->GetInputEventHandler(); if (ih == AliMultiInputEventHandler::Class()) { AliMultiInputEventHandler *ihMulti = (AliMultiInputEventHandler *) ih; TIter nextIH(ihMulti->InputEventHandlers()); AliRsnInputHandler *rsnIH = 0; while ((ih = (AliVEventHandler *) nextIH())) { if (ih->IsA() == AliRsnInputHandler::Class()) { rsnIH = ih; AliRsnDaughterSelector *ds = rsnIH->GetSelector(); ds->Print(); } } } } else { Printf(" Task [--------] : %s '%s'",task->GetName(),task->GetTitle()); } } }
void runGridpPb(const char *config = "config.txt"){ // // run analysis // TGrid::Connect("alien://"); // Create Lookup with sample information TMap sampleinfos; Generate_Sample_Lookup(sampleinfos); ConfigParser(config); // Configure alien plugin AliAnalysisAlien *plugin = CreateGridHandler(); if(!CreateTrainDir(plugin, sampleinfos)){ printf("Cannot setup output directory\n"); return; } if(!MakeSample(plugin, sampleinfos)){ printf("Cannot create data sample\n"); return; } if(!g_plugin_mode.CompareTo("full")){ // full mode, creating config files for the merging stage GenerateMergeConfigs(); } AliAnalysisManager *mgr = new AliAnalysisManager("tpctofanalysis"); mgr->SetGridHandler(plugin); SetupTrain(sampleinfos); // Run train if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); // Start analysis in grid. mgr->StartAnalysis("grid"); }
void TaskBuzzer(UInt_t config, const char *collection="wn.xml") { printf("Running buzzer with: %s\n", ConfigName(config)); TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("PilotAnalysis", "No grid connection"); return; } TChain *chain = CreateChain(collection, "ESD"); // Load libraries gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD"); LoadLibraries(); // Create manager AliAnalysisManager *mgr = new AliAnalysisManager("ESDfiltering", "Production train"); mgr->SetNSysInfo(100); // Input handler AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP(); // AliESDInputHandler *esdHandler = new AliESDInputHandler(); esdHandler->SetReadFriends(kTRUE); esdHandler->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(esdHandler); if (config & kAOD) { // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); if (!mergeExcludes.IsNull()) mergeExcludes += " "; mergeExcludes += "AliAOD.root"; mgr->SetOutputEventHandler(aodHandler); } // AnalysisTasks AddAnalysisTasks(config); mgr->SetDebugLevel(1); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } }
//______________________________________________________________________________ void AODmerge() { // Merging method. No staging and no terminate phase. TStopwatch timer; timer.Start(); TString outputDir = "wn.xml"; TString outputFiles = "EventStat_temp.root,AODQA.root,AliAOD.root,AliAOD.VertexingHF.root,AliAODGammaConversion.root,FilterEvents_Trees.root,AliAOD.Muons.root"; TString mergeExcludes = ""; TObjArray *list = outputFiles.Tokenize(","); TIter *iter = new TIter(list); TObjString *str; TString outputFile; Bool_t merged = kTRUE; while((str=(TObjString*)iter->Next())) { outputFile = str->GetString(); // Skip already merged outputs if (!gSystem->AccessPathName(outputFile)) { printf("Output file <%s> found. Not merging again.",outputFile.Data()); continue; } if (mergeExcludes.Contains(outputFile.Data())) continue; merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, 0); if (!merged) { printf("ERROR: Cannot merge %s\n", outputFile.Data()); continue; } } // all outputs merged, validate AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); mgr->InitAnalysis(); mgr->SetGridHandler(new AliAnalysisAlien); mgr->StartAnalysis("gridterminate",0); ofstream out; out.open("outputs_valid", ios::out); out.close(); timer.Print(); }
void AnalysisTrainLocalEmcalFjetSparseMaker() { const TString sDataset = "/DATA04/xzhang/alice/lists/LHC11hPass2AOD145.txt"; //============================================================================= if (LoadLibraries()) { ::Error("AnalysisTrainLocalEmcalFjetSparseMaker.C::AnalysisTrainLocalEmcalFjetSparseMaker","Load libraries failed!"); return; } TChain *chain = CreateChain(sDataset); if (!chain) { ::Error("AnalysisTrainLocalEmcalFjetSparseMaker.C::AnalysisTrainLocalEmcalFjetSparseMaker", "Creating input chain failed!"); return; } //============================================================================= AliAnalysisManager *mgr = new AliAnalysisManager("AnalysisTrainLocalEmcalFjetSparseMaker", "Analysis Train Local EMCal Bkg SM"); //mgr->SetDebugLevel(3); gROOT->LoadMacro("AddTasksEmcalFjetSparseMaker.C"); if (AddTasksEmcalFjetSparseMaker()) return; if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local",chain); } return; }
//______________________________________________________________________________ void runPmdTask(Bool_t isGrid = 0, Bool_t isMC = 0, const char *gridmode = "test") { if (isGrid) { Printf("Strating the Grid Job "); Printf("Grid Mode %s",gridmode); if (isMC) Printf("It is Data Type Run"); if (!isMC) Printf("It is MC Type Run"); } // Load the needed libraries most of // them already loaded by aliroot //-------------------------------------- gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libXMLIO"); gSystem->Load("libPhysics"); gSystem->Load("libSTEERBase"); gSystem->Load("libESD"); gSystem->Load("libAOD"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); // Use AliRoot includes to compile our task gROOT->ProcessLine(".include $ALICE_INSTALL/include"); AliAnalysisManager *mgr = new AliAnalysisManager("PMDAnalysis"); if(isGrid) { gROOT->LoadMacro("CreateAlienHandler.C"); AliAnalysisGrid *alienHandler = CreateAlienHandler(gridmode); if (!alienHandler) return; mgr->SetGridHandler(alienHandler); } // TChain * chain; // if(!isGrid) { // gROOT->LoadMacro("CreateESDChain.C"); // use it if you know it // chain = CreateESDChain("file.txt", 10); // } TChain * chain = new TChain("esdTree"); if(!isGrid) { ifstream file_collect(incollection); TString line; while (line.ReadLine(file_collect) ) { chain->Add(line.Data()); } } if(isMC) { AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); AliMCEventHandler *mc = new AliMCEventHandler(); //mc->SetReadTR(kTRUE); mgr->SetMCtruthEventHandler(mc); gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(isMC); physicsSelTask->GetPhysicsSelection()->SetAnalyzeMC(); gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *centralityTask = AddTaskCentrality(); } else { AliVEventHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(isMC); gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *centralityTask = AddTaskCentrality(); } gROOT->LoadMacro("AliPMDAnalysisTaskPbPb.cxx++g"); gROOT->LoadMacro("AddAliPMDAnalysisTaskPbPb.C"); AddAliPMDAnalysisTaskPbPb("MyTask",isMC); // Enable debug printouts mgr->SetDebugLevel(0); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); if(isGrid) mgr->StartAnalysis("grid"); else mgr->StartAnalysis("local",chain); };
//________________________________________________________________ void runAAF(Int_t nFilesMax, char* type, char* textFileName, Int_t task) { Int_t analysisMC = 0; Bool_t debug = kTRUE; Bool_t readTR = kFALSE; Bool_t esdAna = kTRUE; // run ESD analysis (kTRUE) or AOD analysis (kFALSE) Int_t runtype = -1; if(strstr(type,"aod") != NULL) { esdAna = kFALSE;; // AOD analysis cout << "Performing AOD analysis" << endl; } else cout << "Performing ESD analysis" << endl; const Char_t* treeName = GetTreeName(esdAna); if(strstr(type,"PbPb") != NULL) runtype = 2; // PbPb if(strstr(type,"pp") != NULL) runtype = 3; // pp if(strstr(type,"900") != NULL){ // 900GeV pp if(runtype != -1){ printf("conflicting run types\n"); return; } runtype = 1; } if(runtype == -1) runtype = 0; // 7TeV pp char *test; test = strstr(type,"MC"); if(test != NULL){ analysisMC = kTRUE; cout << "Test: " << test << endl; if(sscanf(test,"MC%d",&analysisMC)){ // cout << "**************" << analysisMC << endl; if(!analysisMC) analysisMC = 1; } } cout << "MonteCarlo " << analysisMC << endl; const char* alirootver = "v5-02-17-AN"; Int_t mode = -1; // mode 1: PROOF, 2: GRID, 0: LOCAL printf("===================================================================\n"); if(strstr(type,"proof") != NULL){ if(mode != -1){ printf("===== CONFLICTING TYPES =====\n"); return; } mode = 1; printf("=============== RUNNING ANALYSIS IN CAF MODE ================\n"); } if(strstr(type,"grid") != NULL){ if(mode != -1){ printf("===== CONFLICTING TYPES =====\n"); return; } printf("=============== RUNNING ANALYSIS IN GRID MODE ================\n"); mode = 2; } if(strstr(type,"local") != NULL || mode<0){ if(mode != -1){ printf("===== CONFLICTING TYPES =====\n"); return; } printf("=============== RUNNING ANALYSIS IN LOCAL MODE ================\n"); mode = 0; } printf("===================================================================\n"); printf("===================================================================\n"); if (analysisMC) printf(":: use MC TRUE\n"); else printf(":: use MC FALSE\n"); if (readTR) printf(":: read TR TRUE\n"); else printf(":: read TR FALSE\n"); if (debug) printf(":: debugging TRUE\n"); else printf(":: debugging FALSE\n"); Char_t taskname[128]; switch(task){ case 1: sprintf(taskname,"HighPtDeDxCosmic"); break; case 2: sprintf(taskname,"HighPtDeDx"); break; case 3: sprintf(taskname,"HighPtDeDxV0"); break; case 4:{ sprintf(taskname,"EffDecomposition"); } break; default: printf("Unknown task\n"); return; } Char_t nameouputfiles[1280]={0}; if(runtype ==2){ for(Int_t i=0;i<6;++i){ //Char_t tmpname[128]={0}; sprintf(nameouputfiles,"%s %s_Tree_%1.0f_%1.0f.root",nameouputfiles,taskname,minCent[i],maxCent[i]); } } if(runtype ==3){ sprintf(nameouputfiles,"%s %s_Tree.root",taskname); } cout<<"Files to be stored:"<<nameouputfiles<<endl; // Load common libraries gSystem->Load("libTree.so"); gSystem->Load("libPhysics.so"); gSystem->Load("libGeom.so"); gSystem->Load("libVMC.so"); gSystem->Load("libSTEERBase.so"); gSystem->Load("libESD.so"); gSystem->Load("libAOD.so"); gSystem->Load("libCDB.so"); gSystem->Load("libANALYSIS.so"); gSystem->Load("libANALYSISalice.so"); // tender gROOT->ProcessLine(Form(".include %s/include", gSystem->ExpandPathName("$ALICE_ROOT"))); cout << "mode " << mode << ", type " << type << endl; if (mode == 1){ cout << "Connecting to CAF..." << endl; gEnv->SetValue("XSec.GSI.DelegProxy","2"); //const char* AAF = "*****@*****.**"; const char* AAF = "*****@*****.**"; if(strstr(type,"reset") != NULL) TProof::Reset(AAF,kFALSE); // TProof::Reset("*****@*****.**",kTRUE); // TProof::Open(AAF); TProof::Open(AAF, "workers=10"); TList *list = new TList(); list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "CDB")); gProof->EnablePackage(Form("VO_ALICE@AliRoot::%s",alirootver), list); cout << "Connected to " << AAF << endl; } // Load the analysis macro (old version); should be removed when the library will be decided Char_t loadtask[128]; if(task==4) { sprintf(loadtask,"AliAnaTaskV0%s.cxx++", taskname); }else{ sprintf(loadtask,"AliAnalysisTask%s.cxx++", taskname); } if(mode == 1){ // PROOF // switch(task){ // case 1: // ch fluct // break; // case 2: // high pt dedx //gProof->Load("DebugClasses.C++g"); // break; // case 3: // high pt v0s // gProof->Load("DebugClasses.C++g"); // break; // default: // printf("Unknown task\n"); // return; // } gProof->Load(loadtask); }else{ if(task==2) { cout << "Analysis task is loaded with AliRoot" << endl; } else { gROOT->LoadMacro(loadtask); } } // Make the analysis manager AliAnalysisManager* mgr = new AliAnalysisManager("PID histos", "testing analysis"); // Dataset switch(mode){ case 1: // PROOF TFileCollection* proofColl = gProof->GetDataSet(textFileName); TFileCollection* stagedColl = proofColl->GetStagedSubset(); TChain* chain = CreateChainCAF(nFilesMax, stagedColl, treeName); // TChain* chain = CreateChainCAF(nFilesMax, textFileName, treeName, analysisMC); break; case 2: // GRID //gSystem->Setenv("alien_CLOSE_SE", "ALICE::GSI::SE2"); // gSystem->Setenv("alien_CLOSE_SE", "ALICE::NIHAM::FILE"); TGrid::Connect("alien://"); //gSystem->Setenv("alien_CLOSE_SE", "ALICE::GSI::SE2"); // gSystem->Setenv("alien_CLOSE_SE", "ALICE::NIHAM::FILE"); Char_t gridmode[64]; sprintf(gridmode, "full"); if(strstr(type,"term") != NULL) sprintf(gridmode, "terminate"); if(strstr(type,"off") != NULL) sprintf(gridmode, "offline"); if(strstr(type,"sub") != NULL) sprintf(gridmode, "submit"); if(strstr(type,"test") != NULL) sprintf(gridmode, "test"); gROOT->LoadMacro("CreateAlienHandler.C"); // AliAnalysisGrid *alienHandler = CreateAlienHandler(nFilesMax, analysisMC, runtype, taskname, gridmode); AliAnalysisGrid *alienHandler = CreateAlienHandler(nFilesMax, analysisMC, esdAna, taskname, nameouputfiles, gridmode, textFileName, alirootver, task); if (!alienHandler) return; // DOES NOT WORK BECAUSE THERE ARE NO GETTERS? // // Here we can add extra files to the plugin // switch(task){ // case 1: // ch fluct // break; // case 2: // high pt dedx // alienHandler->SetAnalysisSource(Form("DebugClasses.C %s", alienHandler->GetAnalysisSource())); // alienHandler->SetAdditionalLibs(Form("DebugClasses.C %s", alienHandler->GetAdditionalLibs())); // break; // case 3: // high pt v0s // alienHandler->SetAnalysisSource(Form("DebugClasses.C %s", alienHandler->GetAnalysisSource())); // alienHandler->SetAdditionalLibs(Form("DebugClasses.C %s", alienHandler->GetAdditionalLibs())); // break; // default: // printf("Unknown task\n"); // return; // } // Connect plugin to the analysis manager mgr->SetGridHandler(alienHandler); break; case 0: // LOCAL // Process data - chain AliXRDPROOFtoolkit tool; TChain* chain = tool.MakeChain(textFileName,treeName, 0, 100); chain->Lookup(); break; default: printf("Unknown mode"); return; } // ESD input handler if(esdAna) { AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); } else { AliAODInputHandler* aodHandler = new AliAODInputHandler(); mgr->SetInputEventHandler(aodHandler); } // Monte Carlo handler if (analysisMC) { AliMCEventHandler* mcHandler = new AliMCEventHandler(); if(esdAna) mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetReadTR(readTR); } // Debug if needed if (debug) mgr->SetDebugLevel(3); // ######### Centrality task ############### cout<<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<endl; cout<<"esdAna="<<esdAna<<" runtype="<<runtype<<endl; // ######### PHYSICS SELECTION ############### if (esdAna) { // PC: 17/8-15: this does not work for AODs..... cout << "Adding task physics selection" << endl; gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(); if (analysisMC) { AliPhysicsSelection* physSel = physSelTask->GetPhysicsSelection(); physSel->SetAnalyzeMC(); } } if(esdAna && runtype==2) { // only for ESD and PbPb gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentrality = AddTaskCentrality(); //taskCentrality->SetPass(2); if (analysisMC) taskCentrality->SetMCInput(); } // ######### PID task ############### if(task == 2) { cout << "Loading macro in AliRoot!" << endl; gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/SPECTRA/IdentifiedHighPt/train/macros/AddTask.C"); cout << "Adding task!" << endl; AliAnalysisTask* taskPid = AddTask(analysisMC, taskname, runtype, kTriggerInt, minCent, maxCent); } else { cout << "Adding AliAnaTaskV0EffDecomposition" << endl; gROOT->LoadMacro("AddTask.C"); AliAnalysisTask* taskPid = AddTask(taskname); } // Run the analysis if (mgr->InitAnalysis()){ mgr->PrintStatus(); switch(mode){ case 1: // PROOF mgr->StartAnalysis("proof",chain); break; case 2: // GRID mgr->StartAnalysis("grid"); break; case 0: mgr->StartAnalysis("local",chain); break; default: printf("Unknown mode\n"); return; } } }
//==================================================================== void runGloAlgTask ( TString data="wn.xml", //TString data="algColl.txt", Int_t nEvents=-1, UInt_t trigSel = AliVEvent::kAny ) { // if (!gGrid) { TGrid::Connect("alien://"); if (!gGrid) {printf("Cannot connect\n");exit(1);} } // gROOT->ProcessLine(Form(".include $ALICE_ROOT/include $ALICE_PHYSICS/include ./ %s",gSystem->pwd())); gSystem->SetIncludePath(Form("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_PHYSICS/include -I./ -I%s",gSystem->pwd())); printf("Include line: %s",gSystem->GetIncludePath()); // if (gClassTable->GetID("AliAlgSteer")<0) { gSystem->Load("libAlg.so"); } // gROOT->ProcessLine(".L AliGloAlgTask.cxx++g"); // AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) mgr = new AliAnalysisManager("mgr"); // TChain *chain = data.EndsWith(".xml") ? CreateChainXML(data) : CreateChainTXT(data); TString formatFr = "AliESDfriends.root"; if (barrelFlag) formatFr = "AliESDfriends_Barrel.root"; printf("Deduced friend name : %s\n",formatFr.Data()); // InputHandlerSetup(formatFr.Data()); // //================================================================================ // printf("Requesting physics selection in %s mode\n",useMC ? "MC":"Data"); // gROOT->LoadMacro("$ALICE_ROOT/../src/ANALYSIS/macros/AddTaskPhysicsSelection.C"); // AliPhysicsSelectionTask* physicsSelectionTask = AddTaskPhysicsSelection(useMC); //================================================================================== // AliGloAlgTask *algTask = new AliGloAlgTask("alg"); //------------------------------------------- algTask->SetTriggerSelection(trigSel); algTask->SetConfMacroName("alignConf.C"); // algTask->SetConfMacroName("pedeF/alignConf.C"); algTask->SetIniParFileName("millepede.res"); // algTask->SetApplyMPSolAlignment(kTRUE); //------------------------------------------- AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("clist", TList::Class(),AliAnalysisManager::kOutputContainer,"mpStatOut.root"); mgr->AddTask(algTask); // mgr->ConnectInput(algTask, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(algTask,1,coutput1); // if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); // Start analysis in grid. if (nEvents<0) nEvents = chain->GetEntries(); mgr->StartAnalysis("localfile",chain,nEvents); // }
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 RunPerformanceTrain(Char_t *file="esd.root", Int_t runNumber = 2, const char* triggerClass ="CINT1B-ABCE-NOPF-ALL", Bool_t bUseMCInfo=kFALSE, Bool_t bUseESDfriend=kTRUE, Bool_t bGrid=kFALSE) { // // Grid settings // use GSI::SE if(bGrid) { gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE"); TGrid * alien = TGrid::Connect("alien://",0,0,"t"); gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE"); } // // Train Configuration // Int_t iPWGPPperfTPC = 1; // Test TPC performance Int_t iPWGPPperfTRD = 0; // Test TRD performance Int_t iPWGPPperfITS = 0; // Test ITS performance Int_t iPWGPPperfCalo = 0; // Test Calo performance Int_t iPWGPPperfMuonTrig = 0; // Test Muon Trigger performance Int_t iPWGPPperfMuonEff = 0; // Test Muon Efficiency performance Int_t iPWGPPperfTOF = 0; // Test TOF-TPC matching performance Int_t iPWGPPperfPrimVertex = 0; // Test Primary Vertex performance Int_t iPWGPPv0QA = 0; // V0 algorithm QA task // // Load Libraries // gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libTender"); gSystem->Load("libCORRFW"); gSystem->Load("libTPCcalib"); gSystem->Load("libPWGPP"); gSystem->Load("libPHOSUtils"); gSystem->Load("libEMCALUtils"); gSystem->Load("libPWG4PartCorrBase"); gSystem->Load("libPWG4PartCorrDep"); gSystem->Load("libPWGmuon"); // The class is here // // OCDB Configuration // AliCDBManager *cdbManager = AliCDBManager::Instance(); cdbManager->SetDefaultStorage("local:///lustre/alice/alien/alice/data/2009/OCDB"); //cdbManager->SetDefaultStorage("local://$ALICE_PHYSICS/OCDB"); //cdbManager->SetSpecificStorage("GRP/GRP/Data", Form("local://%s",gSystem->pwd())); cdbManager->SetRun(runNumber); //cdbManager->SetCacheFlag(kFALSE); // initialize magnetic field from the GRP manager. //if(magField==0) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", 0., 0., AliMagF::k2kG)); //if(magField==1) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1., AliMagF::k2kG)); //if(magField==2) TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1., AliMagF::k5kG)); /* AliGRPManager grpMan; grpMan.ReadGRPEntry(); grpMan.SetMagField(); AliRunInfo *runInfo = grpMan.GetRunInfo(); // // Load geometry // */ AliGeomManager::LoadGeometry(); // // Swtich off all AliInfo (too much output!) // AliLog::SetGlobalLogLevel(AliLog::kError); // // Create input ESD chain // /* gROOT->LoadMacro("$ALICE_PHYSICS/PWG0/CreateESDChain.C"); TChain* chain = CreateESDChain(list,nFiles,fistFile); if(!chain) { Error("RunPerformanceTrain","ESD chain not created!"); return; } */ TChain *chain = new TChain("esdTree"); if(!chain) { Error("RunPerformanceTrain","ESD chain not created!"); return; } chain->Add(file); chain->Lookup(); // // Create analysis manager // AliAnalysisManager *mgr = new AliAnalysisManager; if(!mgr) { Error("RunPerformanceTrain","AliAnalysisManager not set!"); return; } // // Set ESD input handler // AliESDInputHandler* esdH = new AliESDInputHandler; if(!esdH) { Error("RunPerformanceTrain","AliESDInputHandler not created!"); return; } if(bUseESDfriend) esdH->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(esdH); /* // // Set RecPoints and ESD input handler // AliESDInputHandlerRP* rpH = new AliESDInputHandlerRP; if(!rpH) { Error("RunPerformanceTrain","AliESDInputHandlerRP not created!"); return; } if(bUseESDfriend) rpH->SetActiveBranches("ESDfriend"); mgr->SetInputEventHandler(rpH); */ // // Set MC input handler // if(bUseMCInfo) { AliMCEventHandler* mcH = new AliMCEventHandler; if(!mcH) { Error("RunPerformanceTrain","AliMCEventHandler not created!"); return; } mcH->SetReadTR(kTRUE); mgr->SetMCtruthEventHandler(mcH); } // // Add task to AliAnalysisManager // // // TPC performance // if(iPWGPPperfTPC) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceTPC.C"); AliPerformanceTask *tpcQA = AddTaskPerformanceTPC(bUseMCInfo,bUseESDfriend,triggerClass); if(!tpcQA) { Error("RunPerformanceTrain","AliPerformanceTask not created!"); return; } } else { Printf("RunPerformanceTrain: TPC Performance - EXCLUDED!"); } // // TRD perormance // if(iPWGPPperfTRD) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTrainPerformanceTRD.C"); if(!AddTrainPerformanceTRD(bUseMCInfo,bUseESDfriend)) { Error("RunPerformanceTrain","TrainPerformanceTRD not created!"); return; } } else { Printf("RunPerformanceTrain: TRD TrainPerformanceTRD - EXCLUDED!"); } // // ITS performance // if(iPWGPPperfITS) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskPerformanceITS.C"); AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(bUseMCInfo); if(!itsQA) { Error("RunPerformanceTrain","AliAnalysisTaskITSTrackingCheck not created!"); return; } } else { Printf("RunPerformanceTrain: AliAnalysisTaskITSTrackingCheck - EXCLUDED!"); } // // Calorimeter Performance // if(iPWGPPperfCalo) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG4/macros/AddTaskCalorimeterQA.C"); AliAnalysisTaskParticleCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD",bUseMCInfo,kFALSE); if(!taskCaloQA) { Error("RunPerformanceTrain","AliAnalysisTaskParticleCorrelation not created!"); return; } mgr->AddTask(taskCaloQA); } else { Printf("RunPerformanceTrain: AliAnalysisTaskParticleCorrelation - EXCLUDED!"); } // // Muon Trigger // if(iPWGPPperfMuonTrig) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskMTRchamberEfficiency.C"); AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency(); if(!taskMuonTrig) { Error("RunPerformanceTrain","AliAnalysisTaskTrigChEff not created!"); return; } mgr->AddTask(taskMuonTrig); } else { Printf("RunPerformanceTrain: AliAnalysisTaskTrigChEff - EXCLUDED!"); } // // Muon Efficiency // if(iPWGPPperfMuonEff) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG3/muondep/AddTaskMUONTrackingEfficiency.C"); AliAnalysisTaskMuonTrackingEff *taskMuonTrackEff = AliAnalysisTaskMuonTrackingEff(); if(!taskMuonTrackEff) { Error("RunPerformanceTrain","AliAnalysisTaskMuonTrackingEff not created!"); return; } mgr->AddTask(taskMuonTrackEff); } else { Printf("RunPerformanceTrain: Muon Efficiency - EXCLUDED!"); } // // TOF performance // if(iPWGPPperfTOF) { // } else { Printf("RunPerformanceTrain: TOF - EXCLUDED!"); } // // PWGPP Primary Vertex // if(iPWGPPperfPrimVertex) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskVertexESD.C"); AliAnalysisTaskVertexESD *taskPrimVertex = AddTaskVertexESD(); if(!taskPrimVertex) { Error("RunPerformanceTrain","AliAnalysisTaskVertexESD not created!"); return; } } else { Printf("RunPerformanceTrain: AliAnalysisTaskVertexESD - EXCLUDED!"); } // // PWGPP V0 QA // if (iPWGPPv0QA) { gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/macros/AddTaskV0QA.C"); AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(bUseMCInfo); if(!taskv0QA) { Error("RunPerformanceTrain","AliAnalysisTaskV0QA not created!"); return; } } else { Printf("RunPerformanceTrain: AliAnalysisTaskV0QA - EXCLUDED!"); } // // Disable debug printouts // mgr->SetDebugLevel(0); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); //mgr->StartAnalysis("local",chain, nEvents, firstEvent); mgr->StartAnalysis("local",chain); }
//______________________________________________________________________________ void AODtrainsim(Int_t merge=0) { // Main analysis train macro. // merge = 0: production // merge = 1: intermediate merging // merge = 2: final merging + terminate // merge = 3: terminate only if (merge) { TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("AODtrainsim.C", "No grid connection"); return; } } // Set temporary merging directory to current one gSystem->Setenv("TMPDIR", gSystem->pwd()); // Set temporary compilation directory to current one gSystem->SetBuildDir(gSystem->pwd(), kTRUE); printf("==================================================================\n"); printf("=========== RUNNING FILTERING TRAIN ==========\n"); printf("==================================================================\n"); printf("= Configuring analysis train for: =\n"); if (usePhysicsSelection) printf("= Physics selection =\n"); if (iESDfilter) printf("= ESD filter =\n"); if (iMUONcopyAOD) printf("= MUON copy AOD =\n"); // Load common libraries and set include path gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_PHYSICS/include"); // Make the analysis manager and connect event handlers AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train"); if (useSysInfo) mgr->SetNSysInfo(100); // Load ParFiles if (!LoadAnalysisLibraries()) { ::Error("AODtrainsim.C", "Could not load analysis libraries"); return; } // Create input handler (input container created automatically) // ESD input handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); // Monte Carlo handler if (useMC) { AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetReadTR(useTR); } // AOD output container, created automatically when setting an AOD handler if (iAODhandler) { // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); mgr->SetOutputEventHandler(aodHandler); } // Debugging if needed if (useDBG) mgr->SetDebugLevel(3); AddAnalysisTasks(merge); if (merge) { if (merge < 3) AODmerge(); if (merge > 1) { mgr->InitAnalysis(); mgr->SetGridHandler(new AliAnalysisAlien()); mgr->StartAnalysis("grid terminate",0); } return; } // Run the analysis // TChain *chain = CreateChain(); if (!chain) return; TStopwatch timer; timer.Start(); mgr->SetSkipTerminate(kTRUE); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } timer.Print(); }
void 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 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 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 Embedding(const char* dataset="collection.xml") { gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libPhysics"); //load analysis framework gSystem->Load("libSTEERBase"); gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_ROOT/PHOS"); // A task can be compiled dynamically with AClic gROOT->LoadMacro("AliPHOSEmbedding.cxx+g"); // Connect to alien TString token = gSystem->Getenv("GRID_TOKEN") ; if (1) // token == "OK" ) TGrid::Connect("alien://"); else AliInfo("You are not connected to the GRID") ; cout << "Pi0Analysis: processing collection " << dataset << endl; // Create the chain TChain* chain = new TChain("esdTree"); TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset)); TAlienResult* result = collection->GetGridResult("",0 ,0); TList* rawFileList = result->GetFileInfoList(); for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) { TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(counter)) ; const char * rawFile = fi->GetCurrentUrl()->GetUrl() ; printf("Processing %s\n", rawFile) ; chain->Add(rawFile); printf("Chain: %d entries.\n",chain->GetEntries()); } TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(0)); const char * fn = fi->GetCurrentUrl()->GetUrl() ; char runNum[7]; for(Int_t i=0;i<6;i++)runNum[i]=fn[35+i] ; runNum[6]=0 ; Int_t iRunNum=atoi(runNum) ; printf("Run number=%d \n",iRunNum) ; //Run AOD simulation int nrun = atoi(runNum); int nevent = 0; int seed = 0; char sseed[1024]; char sevent[1024]; char sprocess[1024]; char sfield[1024]; char senergy[1024]; sprintf(sevent,""); sprintf(sprocess,""); sprintf(sfield,""); sprintf(senergy,""); seed = 0; sprintf(sseed,"%d",seed); if (seed==0) { fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); fprintf(stderr,"!!!! WARNING! Seeding variable for MC is 0 !!!!\n"); fprintf(stderr,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); } else { fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); fprintf(stdout,"!!! MC Seed is %d \n",seed); fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); } // set the seed environment variable gSystem->Setenv("CONFIG_SEED",sseed); gSystem->Setenv("CONFIG_RUN_TYPE","kPythia6"); // kPythia6 or kPhojet^M gSystem->Setenv("CONFIG_FIELD","k5kG"); // kNoField or k5kG^M gSystem->Setenv("CONFIG_ENERGY","2760"); // 900 or 10000 (GeV) gSystem->Setenv("DC_RUN",runNum); //run number char nSimEvents[55] ; sprintf(nSimEvents,"%d",chain->GetEntries()); gSystem->Setenv("SIM_EVENTS",nSimEvents); gSystem->Exec("mv geometry.root geometry_PHOS.root") ; gSystem->Exec("aliroot -b -q simrun.C > simrun.log 2>&1"); gSystem->Exec("mv geometry_PHOS.root geometry.root") ; // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("Pi0EmbeddingManager"); // ESD input handler AliESDInputHandler* esdH = new AliESDInputHandler(); esdH->SetReadFriends(kFALSE); mgr->SetInputEventHandler(esdH); // Output AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAODout.root"); mgr->SetOutputEventHandler(aodHandler); // Debug level mgr->SetDebugLevel(0); // Add physics selection gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE); gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentrality = AddTaskCentrality() ; gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C"); AliEPSelectionTask *taskEP = AddTaskEventplane() ; // Add my task AliPHOSEmbedding *task1 = new AliPHOSEmbedding("Embedding"); TChain* chainAOD = new TChain("aodTree"); chainAOD->AddFile("AliAOD.root") ; task1->SetSignalChain(chainAOD) ; task1->SelectCollisionCandidates(); TFile *fOldCalib = TFile::Open("OldCalibration.root"); if(fOldCalib->IsOpen()){ printf("\n\n...Adding PHOS calibration used in ESD production \n") ; char key[55] ; TH2F * hCalib[5] ; for(Int_t mod=0;mod<5; mod++){ sprintf(key,"calibrationMod%d",mod) ; hCalib[mod] = (TH2F*)fOldCalib->Get(key) ; } task1->SetOldCalibration(hCalib) ; fOldCalib->Close() ; } mgr->AddTask(task1); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("output0", TTree::Class(), AliAnalysisManager::kOutputContainer); // Connect input/output mgr->ConnectInput(task1 , 0, cinput); mgr->ConnectOutput(task1, 0,coutput1); AliLog::SetClassDebugLevel("AliGeomManager", 10) ; AliCDBManager::Instance()->SetRun(iRunNum) ; // AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB") ; // AliCDBManager::Instance()->SetDefaultStorage("raw://") ; AliCDBManager::Instance()->SetDefaultStorage("alien://folder=/alice/data/2010/OCDB") ; AliCDBManager::Instance()->SetSpecificStorage("PHOS/*/*", "local://OCDB"); printf("RunNunm===%d \n",iRunNum) ; if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } if(iRunNum<=137848){ //period 1 gSystem->Exec("mv BadMap_LHC10h_period1.root BadMap_LHC10h.root") ; } else{ gSystem->Exec("mv BadMap_LHC10h_period234.root BadMap_LHC10h.root") ; } gSystem->Exec("aliroot -b -q AnalyzeDiff.C> analyze3.log 2>&1"); }
void AnalysisTrainMuonCAF(char* fileout = "AliAOD.root", char *datasetname = "myDataSet", Int_t nev=1234567890) { // Macro to produce a generic AOD starting from an ESD file. // The AOD is filled with two tasks: // 1- with the first one (AliAnalysisTaskESDfilter), // all the branches of the AOD are filled apart from the muons. // 2- with the second task (AliAnalysisTaskESDMuonFilter) // muons tracks are added to the tracks branch // This macro works on the CAF // R. Arnaldi 4/5/08 gSystem->Load("libTree"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); gSystem->Load("libPhysics"); // Reset user processes if CAF if not responding anymore // TProof::Reset("lxb6046"); // Connect to proof TProof::Open("lxb6046"); // may be username@lxb6046 if user not the same as on local // Clear packages if changing ROOT version on CAF or local // gProof->ClearPackages(); // Enable proof debugging if needed // gProof->SetLogLevel(5); // Common packages gProof->UploadPackage("STEERBase.par"); gProof->EnablePackage("STEERBase"); gProof->UploadPackage("ESD.par"); gProof->EnablePackage("ESD"); gProof->UploadPackage("AOD.par"); gProof->EnablePackage("AOD"); gProof->UploadPackage("ANALYSIS.par"); gProof->EnablePackage("ANALYSIS"); gProof->UploadPackage("ANALYSISalice.par"); gProof->EnablePackage("ANALYSISalice"); // Analysis-specific // --- Enable the PWG3base Package gProof->UploadPackage("PWG3muon.par"); gProof->EnablePackage("PWG3muon"); // Chain from files staged on CAF // gROOT->LoadMacro("CreateESDChain.C"); // TChain* chain = CreateESDChain("ESD1503X_v1.txt",3); // TChain* chain = CreateESDChain("ESD82XX_30Kshort.txt", 10); // Chain from datasets gROOT->LoadMacro("CreateChainFromDataSet.C"); ds = gProof->GetDataSet(datasetname)->GetStagedSubset(); chain = CreateChainFromDataSet(ds, "esdTree"); // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Analysis train"); // ESD input handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); esdHandler->SetInactiveBranches("FMD CaloCluster"); // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName(fileout); //aodHandler->SetOutputFileName("AOD.root"); mgr->SetInputEventHandler(esdHandler); mgr->SetOutputEventHandler(aodHandler); // Set of cuts plugged into the ESD filter // // standard AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose"); esdTrackCutsL->SetMinNClustersTPC(50); esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5); esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2); esdTrackCutsL->SetRequireTPCRefit(kTRUE); esdTrackCutsL->SetMinNsigmaToVertex(3); esdTrackCutsL->SetRequireSigmaToVertex(kTRUE); esdTrackCutsL->SetAcceptKingDaughters(kFALSE); // // hard cuts AliESDtrackCuts* esdTrackCutsH = new AliESDtrackCuts("AliESDtrackCuts", "Hard"); esdTrackCutsH->SetMinNClustersTPC(100); esdTrackCutsH->SetMaxChi2PerClusterTPC(2.0); esdTrackCutsH->SetMaxCovDiagonalElements(2,2,0.5,0.5,2); esdTrackCutsH->SetRequireTPCRefit(kTRUE); esdTrackCutsH->SetMinNsigmaToVertex(2); esdTrackCutsH->SetRequireSigmaToVertex(kTRUE); esdTrackCutsH->SetAcceptKingDaughters(kFALSE); esdTrackCutsH->SetPRange(0.,2.); // // muon cuts AliESDMuonTrackCuts* esdMuonTrackCuts = new AliESDMuonTrackCuts("AliESDMuonTrackCuts", "test"); esdMuonTrackCuts->SetPRange(0.,20.); //esdMuonTrackCuts->SetPtRange(0.,0.5); // example of kinematic cuts that can be applied // track filter (to reject tracks not surviving the cuts - refers to all particles apart from muons) AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter"); trackFilter->AddCuts(esdTrackCutsH); // muon track filter (to reject muon tracks not surviving the cuts) AliAnalysisFilter* trackMuonFilter = new AliAnalysisFilter("trackMuonFilter"); trackMuonFilter->AddCuts(esdMuonTrackCuts); // ESD filter task putting standard info to output generic AOD AliAnalysisTaskESDfilter *esdfilter = new AliAnalysisTaskESDfilter("ESD Filter"); //esdfilter->SetTrackFilter(trackFilter); esdfilter->SetDebugLevel(10); mgr->AddTask(esdfilter); // ESD filter task putting muon info to output generic AOD AliAnalysisTaskESDMuonFilter *esdmuonfilter = new AliAnalysisTaskESDMuonFilter("ESD Muon Filter"); esdmuonfilter->SetTrackFilter(trackMuonFilter); mgr->AddTask(esdmuonfilter); // Containers for input/output AliAnalysisDataContainer *cin_esd = mgr->GetCommonInputContainer(); // Output AOD container. AliAnalysisDataContainer *cout_aod = mgr->GetCommonOutputContainer(); // Connect containers to tasks slots mgr->ConnectInput (esdfilter, 0, cin_esd ); mgr->ConnectOutput (esdfilter, 0, cout_aod ); mgr->ConnectInput (esdmuonfilter, 0, cin_esd); mgr->ConnectOutput (esdmuonfilter, 0, cout_aod ); // // Run the analysis // if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("proof",chain,nev); } }
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 RunMacro(){ // check the function for asymmetric TPC cut in ConfigHFEemcalMod....the rest is still necessary???? // Firstly, set some variables const char* launch = "grid"; // grid, local (if your data is on your local machine, doesn't connect at all) const char* mode = "test"; //test, full, terminate (test= connect to grid but run locally, full= run on grid, terminate= merge output on grid) Bool_t pre_final_stage = kTRUE; //TRUE = merging done on grid, FALSE = merge happens locally Int_t cyclenumber = 1; Bool_t debug = kTRUE; char* work_dir = "PhiCorrelations_LHC16q_0_20_noveto"; char* output_dir = "output_2018_10_22_FAST"; Int_t ttl = 50000; Int_t noffiles = 40; Int_t runcycle[]={0,1,31}; //Int_t runcycle[]={0,16,31}; Bool_t UseParfiles = kFALSE; // load libraries LoadLibraries(); // create and customize the alien handler AliAnalysisAlien *alienHandler = new AliAnalysisAlien(); alienHandler->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/EMCAL -I$ALICE_ROOT/PYTHIA6 -I$ALICE_ROOT/ANALYSIS -I$ALICE_PHYSICS/PWGGA -I$ALICE_PHYSICS/PWGHF -I$ALICE_PHYSICS/PWGHF/hfe -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_PHYSICS/OADB -I$ALICE_PHYSICS/PWGHF/base -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_PHYSICS/OADB/macros -I$ALICE_PHYSICS/PWGCF/Correlations -I$ALICE_PHYSICS/PWGCF -I$ALICE_PHYSICS/PWGCF/Correlations/Base -I$ALICE_PHYSICS/include -g"); alienHandler->SetAdditionalLibs("AliAnalysisTaskHadronPhiCorr_current.cxx AliAnalysisTaskHadronPhiCorr_current.h AddTaskHadronPhiCorr_current.C libpythia6.so libEGPythia6.so libAliPythia6.so libPWGHFhfe.so libCDB.so libSTEER.so libCORRFW.so libPWGflowBase.so libPWGflowTasks.so libGui.so libProof.so libMinuit.so libXMLParser.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEERBase.so libSTEER.so libTPCbase.so libTOFbase.so libTOFrec.so libTRDbase.so libVZERObase.so libVZEROrec.so libT0base.so libT0rec.so libPWGTools.so libPWGCFCorrelationsBase.so"); alienHandler->SetAnalysisSource("AliAnalysisTaskHadronPhiCorr_current.cxx"); //alienHandler->SetOverwriteMode(); alienHandler->SetRunMode(mode); alienHandler->SetNtestFiles(2); //alienHandler->SetAPIVersion("V1.1x"); alienHandler->SetAliPhysicsVersion("vAN-20170731-1"); //alienHandler->SetFileForTestMode("File_LHC12dPass1.txt"); //txt file that tells where to look for local files if launch=local //alienHandler->SetGridDataDir("/alice/sim/LHC10d4/"); //alienHandler->SetDataPattern("*ESDs.root"); alienHandler->SetGridDataDir("//alice/data/2016/LHC16q/"); alienHandler->SetDataPattern("*/pass1_FAST/AOD/*/*AOD.root"); //alienHandler->SetDataPattern("*/pass4/AOD/*AOD.root"); alienHandler->SetRunPrefix("000"); // IMPORTANT! Only need for real data, comment this line out for MC data //LHC12d //Int_t runArray[] = {186320, 186319, 186318, 186229, 186208, 186205, 186200, 186167, 186165, 186164, 186163, 185912, 185909, 185784, 185778, 185776, 185775, 185768, 185765, 185764, 185757, 185756, 185738, 185735, 185734, 185701, 185699, 185698, 185697, 185695, 185687, 185680, 185589, 185588, 185583, 185582, 185581, 185580, 185578}; //Int_t runArray[] = {186320, 186319, 186318, 186229, 186208, 186205, 186200, 186167, 186165, 186164, 186163, 185912, 185909, 185784, 185778, 185776, 185775, 185768, 185765, 185764, 185757, 185756, 185738, 185735, 185734, 185701, 185699, 185698, 185697, 185695, 185687, 185680, 185589, 185588, 185583, 185582, 185581, 185580, 185578, 185575, 185574, 185565, 185563, 185474, 185465, 185461, 185457, 185375, 185371, 185363, 185362, 185361, 185360, 185359, 185356, 185351, 185350, 185349, 185303, 185302, 185300, 185299, 185296, 185293, 185292, 185291, 185289, 185288, 185284, 185282, 185221, 185217, 185208, 185206, 185203, 185198, 185196, 185189}; //LHC13b //Int_t runArray[] = {195483, 195482, 195481, 195480, 195479, 195478, 195391, 195389, 195351, 195346, 195344}; //LHC13c //Int_t runArray[] = {195529, 195531, 195566, 195567, 195568, 195592, 195593, 195596, 195633, 195635, 195644, 195673, 195675, 195677}; //LHC10d4 - MC Data //Int_t runArray[] = {119159, 119161, 119163, 119841, 119842, 119844, 119845, 119846, 119849, 119853, 119856, 119859, 119862, 120067, 120069, 120072, 120073, 120076, 120079, 120244, 120503, 120504, 120505, 120616, 120617, 120671, 120741, 120750, 120758, 120820, 120821, 120822, 120823, 120824, 120825, 120829}; // Int_t runArray[] = {120073}; //for testing why files were being opened but not closed //LHC16r - 8 TeV pPb data //Int_t runArray[] = {266318, 266317, 266316, 266305, 266304, 266300, 266299, 266296, 266208, 266197, 266196, 266193, 266190, 266189, 266187, 266117, 266086, 266085, 266084, 266083, 266081, 266076, 266074, 266034, 265797, 265795, 265789, 265788, 265756, 265754, 265746, 265744, 265742, 265741, 265714, 265713,265709, 265705, 265701, 265700, 265698, 265697, 265696, 265607, 265596, 265594}; //Int_t runArray[] = {266318, 266317, 266316, 266208, 266197, 266196, 266187, 265754, 265744, 265607, 265596, 265594}; //LHC16q - 5 TeV pPb data Int_t runArray[] = {265525, 265521, 265501, 265500, 265499, 265435, 265427, 265426, 265425, 265424, 265422, 265421, 265420, 265419, 265388, 265387, 265385, 265384, 265383, 265381, 265378, 265377, 265344, 265343, 265342, 265339, 265338, 265336, 265334, 265332, 265309}; for (Int_t i = runcycle[cyclenumber - 1]; i < runcycle[cyclenumber] ; i++) { if (i == sizeof(runArray) / sizeof(runArray[1])) break; alienHandler->AddRunNumber(runArray[i]); } printf("\n\nSetting Up alienHandler.\n\n"); alienHandler->SetGridWorkingDir(work_dir); alienHandler->SetGridOutputDir(output_dir); alienHandler->SetDefaultOutputs(kTRUE); alienHandler->SetAnalysisMacro("PhiInvMass.C"); alienHandler->SetSplitMaxInputFileNumber(noffiles); alienHandler->SetExecutable("PhiInvMass.sh"); alienHandler->SetExecutableCommand("aliroot -b -q"); alienHandler->SetTTL(ttl); //10000 alienHandler->SetInputFormat("xml-single"); alienHandler->SetJDLName("PhiInvMass.jdl"); alienHandler->SetPrice(1); alienHandler->SetSplitMode("se"); alienHandler->SetMasterResubmitThreshold(10); alienHandler->SetMergeExcludes("EventStat_temp.root"); alienHandler->SetOutputToRunNo(kTRUE); alienHandler->SetKeepLogs(kTRUE); alienHandler->SetMaxMergeFiles(15); alienHandler->SetMaxMergeStages(7); alienHandler->SetMergeViaJDL(pre_final_stage); // alienHandler->SetOneStageMerging(kFALSE); //???????????????????????????????------------------- if (!alienHandler) return; // load the necessary macros //gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); //gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); // Use AliRoot includes to compile our task gROOT->ProcessLine(".include $ALICE_ROOT/include"); gROOT->ProcessLine(".include $ALICE_ROOT/EMCAL"); gROOT->ProcessLine(".include $ALICE_PHYSICS/include"); gROOT->ProcessLine(".include $ALICE_ROOT/ANALYSIS/"); gROOT->ProcessLine(".include $PWD/."); gSystem->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/EMCAL -I$ALICE_ROOT/PYTHIA6 -I$ALICE_ROOT/ANALYSIS -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_PHYSICS/OADB -I$ALICE_PHYSICS/PWGHF/base -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -I$ALICE_PHYSICS/OADB -I$ALICE_ROOT/PWG/FLOW/Base -I$ALICE_PHYSICS/PWGCF/Correlations/Base -I$ALICE_PHYSICS/PWGCF/Correlations -g "); // gSystem->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/macros -I$ALICE_PHYSICS/include -g"); //printf("\n!!!!!!!!!!!!!!!!!!!!!!\n AliAnalysis Manager \n\n"); AliAnalysisManager *mgr = new AliAnalysisManager("PhiAnalysis"); mgr->SetGridHandler(alienHandler); AliAODInputHandler* aodH = new AliAODInputHandler(); mgr->SetInputEventHandler(aodH); // AliESDInputHandler* esdH = new AliESDInputHandler(); // mgr->SetInputEventHandler(esdH); // AliMCEventHandler* mcH = new AliMCEventHandler(); // mgr->SetMCtruthEventHandler(mcH); // mcH->SetReadTR(kFALSE); //gROOT->LoadMacro("AddTaskPhiCorr.C"); gROOT->LoadMacro("./AliAnalysisTaskHadronPhiCorr.cxx++g"); //gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); //gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"); //gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); //switch on aliphysicsselection gInterpreter->ProcessLine(Form(".x %s", gSystem->ExpandPathName("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"))); AliPhysicsSelectionTask* physSelTask = reinterpret_cast<AliPhysicsSelectionTask*>(gInterpreter->ProcessLine(Form(".x %s(kFALSE, kTRUE)", gSystem->ExpandPathName("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C")))); //Only set true for MC Bool_t isMC = kFALSE; gInterpreter->ProcessLine(Form(".x %s(kFALSE)", gSystem->ExpandPathName("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"))); //create a task AliAnalysisTaskHadronPhiCorr_current *task1 = reinterpret_cast<AliAnalysisTaskHadronPhiCorr_current*>(gInterpreter->ProcessLine(Form(".x %s(kFALSE, 0.0, 20.0)", gSystem->ExpandPathName("AddTaskHadronPhiCorr_current.C")))); //AliAnalysisTaskHadronPhiCorr_current *task2 = reinterpret_cast<AliAnalysisTaskHadronPhiCorr_current*>(gInterpreter->ProcessLine(Form(".x %s(true, 10.0, 20.0)", gSystem->ExpandPathName("AddTaskHadronPhiCorr_current.C")))); //AliAnalysisTaskHadronPhiCorr_current *task3 = reinterpret_cast<AliAnalysisTaskHadronPhiCorr_current*>(gInterpreter->ProcessLine(Form(".x %s(kFALSE, 20.0, 40.0)", gSystem->ExpandPathName("AddTaskHadronPhiCorr_current.C")))); //AliAnalysisTaskHadronPhiCorr_current *task4 = reinterpret_cast<AliAnalysisTaskHadronPhiCorr_current*>(gInterpreter->ProcessLine(Form(".x %s(kTRUE, 40.0, 90.0)", gSystem->ExpandPathName("AddTaskHadronPhiCorr_current.C")))); task1->SetKaonEtaCut(0.8); task1->SetKaonTPCCut(3.0); task1->SetKaonTOFCut(3.0); task1->SetTOFVeto(kFALSE); task1->SetKaonTrkBit(1024); task1->SetAssocTrkBit(1024); task1->SetTrigTrkBit(AliAODTrack::kIsHybridGCG); task1->SetZVertexMin(-10.0); task1->SetZVertexMax(10.0); task1->SetZVertexNbins(10); task1->SetCentEstimator("V0A"); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); //fprintf(stdout, "\n!!!!!!!!!!!!!\nAbout to launch analysis... \n"); // Start analysis in grid. mgr->StartAnalysis(launch); //printf("\n!!!!!!!!!!!!!\nDone with StartAnalysis(launch)\n"); fflush(stdout); }
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(); }