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); } }
AliAnalysisTask* AddTaskAOD2AODMuonOnly(const char* triggerinputs,Bool_t withSPDtracklets, Int_t mcMode) { AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskAOD2AODMuonOnly", "No analysis manager to connect to."); return 0x0; } AliInputEventHandler* input = mgr->GetInputEventHandler(); if (!input) { ::Error("AddTaskAOD2AODMuonOnly", "This task requires an input event handler"); return 0x0; } TString inputDataType = input->GetDataType(); // can be "ESD" or "AOD" if (inputDataType != "AOD") { ::Error("AddTaskAOD2AODMuonOnly", "This task requires an AOD input event handler"); return 0x0; } AliAODHandler* aodHandler = dynamic_cast<AliAODHandler*>(mgr->GetOutputEventHandler()); if (!aodHandler) { ::Error("AddTaskAOD2AODMuonOnly", "This task requires an AOD output event handler"); return 0x0; } aodHandler->SetCreateNonStandardAOD(); AliMuonEventCuts* eventCuts = new AliMuonEventCuts("L0cutter",""); eventCuts->SetTrigClassPatterns("0MSL|0MUL|0MSH|0MLL",triggerinputs); AliAnalysisTask* task = new AliAnalysisTaskAOD2MuonAOD(mcMode,withSPDtracklets,eventCuts); mgr->AddTask(task); // Connect input/output mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 0, mgr->GetCommonOutputContainer()); return task; }
Bool_t CreateInputHandlers(TString input,TString inputMC,Bool_t useAODOut=kFALSE,Bool_t useMultiHandler=kTRUE) { input.ToLower(); inputMC.ToLower(); Bool_t useMC = !inputMC.CompareTo("mc"); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Printf("Error [CreateInputHandlers] : mgr is null !!!"); return kFALSE; } if (useMultiHandler) { AliMultiInputEventHandler *inputHandler = new AliMultiInputEventHandler(); if (!input.CompareTo("esd")) { Printf("Adding ESD Input Handler ..."); inputHandler->AddInputEventHandler(new AliESDInputHandler()); if (useMC) inputHandler->AddInputEventHandler(new AliMCEventHandler()); } else if (!input.CompareTo("aod")) { inputHandler->AddInputEventHandler(new AliAODInputHandler()); } mgr->SetInputEventHandler(inputHandler); } else { if (!input.CompareTo("esd")) { mgr->SetInputEventHandler(new AliESDInputHandler()); if (useMC) mgr->SetMCtruthEventHandler(new AliMCEventHandler()); } else if (!input.CompareTo("aod")) { mgr->SetInputEventHandler(new AliAODInputHandler()); } } if (useAODOut) { AliAODHandler *aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); mgr->SetOutputEventHandler(aodHandler); } return kTRUE; }
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 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(); }
Bool_t AddTasksEmcalFjetSparseMaker() { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (bIsInfoAOD) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODHandler.C"); AliAODInputHandler *aodIH = AddAODHandler(); } else { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddESDHandler.C"); AliESDInputHandler *esdIH = AddESDHandler(); // esdIH->SetReadFriends(kFALSE); } if (bAnaInfoMC && (!bIsInfoAOD)) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddMCHandler.C"); AliMCEventHandler *mctEH = AddMCHandler(kTRUE); } if (bOutputAOD) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODOutputHandler.C"); AliAODHandler *aodH = AddAODOutputHandler(); aodH->SetOutputFileName("AliAOD.PicoJets.root"); aodH->SetFillAOD(kTRUE); aodH->SetCreateNonStandardAOD(); mgr->SetOutputEventHandler(aodH); } //============================================================================= if (bIsPhysSel) { gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalPhysicsSelection.C"); AliEmcalPhysicsSelectionTask *taksPhysSel = AddTaskEmcalPhysicsSelection(kTRUE, kTRUE, wTriggerMask, 5., 5., 10., kTRUE, -1, -1, -1, -1); if (bAnaInfoMC) { AliEmcalPhysicsSelection *pPhysSel = static_cast<AliEmcalPhysicsSelection*>(taksPhysSel->GetPhysicsSelection()); if (!pPhysSel) return kTRUE; pPhysSel->SetAnalyzeMC(); } } if (bIsCentSel) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentSel = AddTaskCentrality(kTRUE, bIsAOD); if (bAnaInfoMC) taskCentSel->SetMCInput(); } if (bIsEvPnSel) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C"); AliEPSelectionTask *taskEventPlane = AddTaskEventplane(); if (bAnaInfoMC) taskEventPlane->SetUseMCRP(); } if (bIsRespPID) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AliAnalysisTaskSE *taskRespPID = AddTaskPIDResponse(bAnaInfoMC); } //============================================================================= gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalSetup.C"); AliEmcalSetupTask *taskSetupEMCal = AddTaskEmcalSetup(); taskSetupEMCal->SetGeoPath("$ALICE_PHYSICS/OADB/EMCAL"); gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalPreparation.C"); AliAnalysisTaskSE *taskEmcMaker = AddTaskEmcalPreparation(sPeriodIn); gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskJetPreparation.C"); AliAnalysisTaskSE *taskHadCorr = AddTaskJetPreparation(sPeriodIn.Data(), sUsedTrksRD.Data(), (bAnaInfoMC ? sUsedTrksMC.Data() : ""), sInputClsRD.Data(), sUsedClusRD.Data(), 2., 0., 0.03, 0.015, 0.15, wTriggerMask, kTRUE, // do trk clus kTRUE, // histos kTRUE, // make pico trk kFALSE, // make trigger kFALSE, // is EMCal train 1., // track eff kTRUE, // do AOD track prop kTRUE, // modify match kFALSE, // use old bit kFALSE, // trigger QA 4); // cent bin //============================================================================= gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C"); /*AliEmcalJetTask *taskAkt = AddTaskEmcalJet(sUsedTrksRD.Data(), sUsedClusRD.Data(), 1, // anti-kT dJetRadius, nJetType, dTrkPtCut, dCluEnCut);*/ //============================================================================= AliAnalysisTaskEmcalFjetSparseMaker *taskEmcalSM = new AliAnalysisTaskEmcalFjetSparseMaker("AliAnalysisTaskEmcalFjetSM"); //taskEmcalSM->SetForceBeamType(0); //taskEmcalSM->SetIsPythia(kTRUE); /*taskEmcalSM->SetCaloTriggerPatchInfoName("EmcalTriggers"); taskEmcalSM->SetTriggerTypeSel(AliAnalysisTaskEmcal::kJ2); taskEmcalSM->SetMainPatchType(AliAnalysisTaskEmcal::kTriggerLevel1Jet);*/ AliParticleContainer *pContTrks = taskEmcalSM->AddParticleContainer(sUsedTrksRD.Data()); pContTrks->SetParticlePtCut(dTrkPtCut); AliClusterContainer *pContClus = taskEmcalSM->AddClusterContainer(sUsedClusRD.Data()); pContClus->SetClusPtCut(dCluEnCut); /*AliJetContainer *pContJets = taskEmcalSM->AddJetContainer(taskAkt->GetName(), sCutType.Data(), dJetRadius); pContJets->SetPercAreaCut(dJetAreaCut); pContJets->SetJetPtCut(dJetPtCut); //pContJets->SetRhoName(sUsedRho.Data()); //pContJets->SetLocalRhoName(); pContJets->SetLeadingHadronType(nLeading); pContJets->ConnectParticleContainer(taskEmcalSM->GetParticleContainer()); pContJets->ConnectClusterContainer(taskEmcalSM->GetClusterContainer()); pContJets->SetNameTitle(taskEmcalSM->GetNameJet().Data(), taskEmcalSM->GetNameJet().Data());*/ mgr->AddTask(taskEmcalSM); mgr->ConnectInput(taskEmcalSM, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(taskEmcalSM, 1, mgr->CreateContainer("listGeneralH", TList::Class(), AliAnalysisManager::kOutputContainer, AliAnalysisManager::GetCommonFileName())); mgr->ConnectOutput(taskEmcalSM, 2, mgr->CreateContainer("listEmcalEvH", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalEvH.root")); mgr->ConnectOutput(taskEmcalSM, 3, mgr->CreateContainer("listEmcalTrk", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalTrk.root")); mgr->ConnectOutput(taskEmcalSM, 4, mgr->CreateContainer("listEmcalClu", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalClu.root")); /*mgr->ConnectOutput(taskEmcalSM, 5, mgr->CreateContainer("listEmcalJet", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResults_EmcalJet.root"));*/ //============================================================================= TObjArray *aTasks = mgr->GetTasks(); for (Int_t i=0; i<aTasks->GetEntries(); i++) { AliAnalysisTaskEmcal *taskJE = dynamic_cast<AliAnalysisTaskEmcal*>(aTasks->At(i)); if (taskJE) if (taskJE->InheritsFrom("AliAnalysisTaskEmcal")) { taskJE->SetVzRange(-10., 10.); if (!sCentEsti.IsNull()) { taskJE->SetCentralityEstimator(sCentEsti.Data()); taskJE->SetCentRange(dCentMin, dCentMax); } } if (wTriggerMask) { AliAnalysisTaskSE *taskSE = dynamic_cast<AliAnalysisTaskSE*>(aTasks->At(i)); if (taskSE) if (!(taskSE->InheritsFrom("AliPhysicsSelectionTask"))) { taskSE->SelectCollisionCandidates(wTriggerMask); } } } //============================================================================= return kFALSE; }
void 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 runAODFilterMC() { // PROOF example gSystem->Load("libTree"); gSystem->Load("libPhysics"); gSystem->Load("libGeom"); gSystem->Load("libVMC"); bool bKineFilter = true; // TProof::Mgr("alicecaf")->SetROOTVersion("v5-21-01-alice_dbg"); TProof::Open("alicecaf"); // gProof->SetParallel(1); char *dataset = "/COMMON/COMMON/LHC08c11_10TeV_0.5T"; // char *dataset = "/PWG4/kleinb/LHC08q_jetjet100"; // gProof->ClearPackages(); gProof->UploadPackage("${ALICE_ROOT}/STEERBase.par"); gProof->EnablePackage("STEERBase"); gProof->UploadPackage("${ALICE_ROOT}/ESD.par"); gProof->EnablePackage("ESD"); gProof->UploadPackage("${ALICE_ROOT}/AOD.par"); gProof->EnablePackage("AOD"); gProof->UploadPackage("${ALICE_ROOT}/ANALYSIS.par"); gProof->EnablePackage("ANALYSIS"); gProof->UploadPackage("${ALICE_ROOT}/ANALYSISalice.par"); gProof->EnablePackage("ANALYSISalice"); // if (gApplication) gApplication->InitializeGraphics(); // Create the chain // /////////////////////////////////////////////////////////////////////////////////// // Create the analysis manager // // Input AliESDInputHandler* inpHandler = new AliESDInputHandler(); // Output AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("aod_ckb2.root"); // MC Truth AliMCEventHandler* mcHandler = new AliMCEventHandler(); AliAnalysisManager *mgr = new AliAnalysisManager("Filter Manager", "Filter Manager"); if(bKineFilter){ mgr->SetMCtruthEventHandler(mcHandler); } mgr->SetInputEventHandler (inpHandler); mgr->SetOutputEventHandler (aodHandler); aodHandler->Dump(); mgr->SetDebugLevel(10); // Filtering of MC particles (decays conversions etc) // this task is also needed to set the MCEventHandler // to the AODHandler, this will not be needed when // AODHandler goes to ANALYSISalice AliAnalysisTaskMCParticleFilter *kinefilter = new AliAnalysisTaskMCParticleFilter("Particle Filter"); if(bKineFilter)mgr->AddTask(kinefilter); // AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose"); esdTrackCutsL->SetMinNClustersTPC(50); esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5); esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2); esdTrackCutsL->SetRequireTPCRefit(kTRUE); esdTrackCutsL->SetDCAToVertexZ(3.0); esdTrackCutsL->SetDCAToVertexXY(3.0); esdTrackCutsL->SetDCAToVertex2D(kTRUE); esdTrackCutsL->SetRequireSigmaToVertex(kFALSE); esdTrackCutsL->SetAcceptKinkDaughters(kFALSE); AliESDtrackCuts* esdTrackCutsITSsa = new AliESDtrackCuts("AliESDtrackCuts", "ITS stand-alone"); esdTrackCutsITSsa->SetRequireITSStandAlone(kTRUE); AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter"); trackFilter->AddCuts(esdTrackCutsL); trackFilter->AddCuts(esdTrackCutsITSsa); AliAnalysisTaskESDfilter *esdfilter = new AliAnalysisTaskESDfilter("ESD Filter"); esdfilter->SetTrackFilter(trackFilter); mgr->AddTask(esdfilter); // // Create containers for input/output AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer(); coutput1->SetSpecialOutput(); if(bKineFilter){ mgr->ConnectInput (kinefilter, 0, cinput1 ); mgr->ConnectOutput (kinefilter, 0, coutput1 ); AliAnalysisDataContainer *coutputEx = mgr->CreateContainer("cFilterList", TList::Class(), AliAnalysisManager::kOutputContainer,"pyxsec_hists.root"); mgr->ConnectOutput (kinefilter, 1, coutputEx ); } mgr->ConnectInput (esdfilter, 0, cinput1 ); mgr->ConnectOutput (esdfilter, 0, coutput1 ); // // Run the analysis // mgr->InitAnalysis(); mgr->PrintStatus(); mgr->StartAnalysis("proof",dataset,10000); }
/// /// Main method calling all the configuration /// /// The parameters passed to the analysis are: /// \param bias : bias or not depending on EMCal signal. /// \param mc : simulation or data. /// \param minE : at least one cluster in EMCal with this energy. /// \param minN : at least one cluster in EMCal with this number of cells. /// \param vz : z vertex cut. /// \param opt : filter EMCal only, PHOS only or both. /// \param correct : calibrate the EMCal, remove bad cells ... /// \param fillTrack : Fill event with hybrid tracks /// \param fillAOD : Output AOD is filled, not used only for a secondary task analysis at the same time. /// AliAnalysisTaskCaloFilter * AddTaskCaloFilter ( const Bool_t bias = kTRUE , const Bool_t mc = kFALSE , const Float_t minE = 6. , const Int_t minN = 3 , const Float_t vz = 10. , const Int_t opt = 0 //AliAnalysisTaskCaloFilter::kBoth,kPHOS, kEMCAL or kBoth , const Bool_t correct = kFALSE , const Bool_t fillTrack = kFALSE , const Bool_t fillAOD = kTRUE) { // Get the pointer to the existing analysis manager via the static access method. //============================================================================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskCaloFilter", "No analysis manager to connect to."); return NULL; } // Check the analysis type using the event handlers connected to the analysis manager. //============================================================================== if (!mgr->GetInputEventHandler()) { ::Error("AddTaskCaloFilter", "This task requires an input event handler"); return NULL; } // Set the output AOD handler // printf("AddTaskCaloFilter --- Init output handler ---\n"); AliAODHandler* aodoutHandler = new AliAODHandler(); aodoutHandler->SetOutputFileName("AliAOD.EMCAL.root"); //aodoutHandler->SetCreateNonStandardAOD(); mgr->SetOutputEventHandler(aodoutHandler); // Configure the task // printf("AddTaskCaloFilter --- Init task ---\n"); AliAnalysisTaskCaloFilter * filter = new AliAnalysisTaskCaloFilter("CaloFilter"); //filter->SetDebugLevel(2); filter->SetCaloFilter(opt); //kPHOS, kEMCAL or kBoth filter->SetVzCut(vz); if(mc) { filter->SetEventSelection(1,0,0); // Select events depending on EMCAL, PHOS and tracks criteria filter->SwitchOnAcceptAllMBEvent(); filter->SwitchOnFillMCParticles(); filter->SetEMCALEnergyCut(minE); filter->SetEMCALNcellsCut(minN); filter->SetPHOSEnergyCut(minE); filter->SetPHOSNcellsCut(minN); filter->SetTrackPtCut(minE); printf("AddTaskCaloFilter --- Select MC events with bias in EMCal ---\n"); } else if(bias) // select events with significant signal in EMCAL or TPC or PHOS { filter->SetEventSelection(1,0,0); // Select events depending on EMCAL, PHOS and tracks criteria filter->SwitchOnAcceptAllMBEvent(); filter->SetEMCALEnergyCut(minE); filter->SetEMCALNcellsCut(minN); filter->SetPHOSEnergyCut(minE); filter->SetPHOSNcellsCut(minN); filter->SetTrackPtCut(minE); //filter->SetMBTriggerMask(AliVEvent::kAnyINT); filter->SetMBTriggerMask(AliVEvent::kINT7); // not working for all productions filter->SelectCollisionCandidates(AliVEvent::kAny) ; printf("AddTaskCaloFilter --- Select events with bias in EMCal ---\n"); } else // Do not bias the signal in EMCAL, select MB events { filter->SetEventSelection(0,0,0); filter->SwitchOnAcceptAllMBEvent(); filter->SetEMCALEnergyCut(-1); filter->SetEMCALNcellsCut(0); filter->SetPHOSEnergyCut(-1); filter->SetPHOSNcellsCut(0); filter->SetTrackPtCut(-1); filter->SelectCollisionCandidates(AliVEvent::kINT7);// | AliVEvent::kCentral | AliVEvent::kSemiCentral ) ; printf("AddTaskCaloFilter --- Select INT7 events ---\n"); } // Activate the cluster corrections (calibration, bad map...) // if(correct) filter->SwitchOnClusterCorrection(); else filter->SwitchOffClusterCorrection(); // Exoticity cut settings // AliEMCALRecoUtils * reco = filter->GetEMCALRecoUtils(); reco->SwitchOnRejectExoticCluster() ; reco->SetExoticCellFractionCut(0.97); reco->SetExoticCellMinAmplitudeCut(4.); // Track storing // if(fillTrack) { filter->SwitchOnFillTracks() ; filter->SwitchOnFillHybridTracks() ; } else { filter->SwitchOffFillTracks() ; filter->SwitchOffFillHybridTracks() ; } // Other options to store in event // filter->SwitchOffFillv0s() ; // Put ON if you know what you do. filter->SwitchOnFillVZERO(); // Be able to recalculate centrality and event plane // afterwards even it is stored in header // AOD output storing // if(fillAOD) filter->SwitchOnFillAODFile(); else filter->SwitchOffFillAODFile(); // Pass the task to the manager, print first set parameters filter->PrintInfo(); mgr->AddTask(filter); // Create containers for input/output // printf("AddTaskCaloFilter --- Created input/output containers ---\n"); AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer(); printf("AddTaskCaloFilter --- Created containers, add them ---\n"); mgr->ConnectInput (filter, 0, cinput1 ); mgr->ConnectOutput (filter, 0, coutput1 ); printf("AddTaskCaloFilter --- End ---\n"); return filter; }
//______________________________________________________________________________ void AODtrain(Int_t merge=0) { // Main analysis train macro. ProcessEnvironment(); UpdateFlags(); PrintSettings(); if (merge || doCDBconnect) { TGrid::Connect("alien://"); if (!gGrid || !gGrid->IsConnected()) { ::Error("AODtrain", "No grid connection"); return; } } // Set temporary merging directory to current one gSystem->Setenv("TMPDIR", gSystem->pwd()); // Set temporary compilation directory to current one gSystem->SetBuildDir(gSystem->pwd(), kTRUE); printf("==================================================================\n"); printf("=========== RUNNING FILTERING TRAIN ==========\n"); printf("=========== Collision System is %s ==========\n",CollisionSystem[iCollision]); printf("==================================================================\n"); printf("= Configuring analysis train for: =\n"); if (usePhysicsSelection) printf("= Physics selection =\n"); if (useTender) printf("= TENDER =\n"); if (iESDfilter) printf("= ESD filter =\n"); if (iMUONcopyAOD) printf("= MUON copy AOD =\n"); if (iJETAN) printf("= Jet analysis =\n"); if (iJETANdelta) printf("= Jet delta AODs =\n"); if (iPWGHFvertexing) printf("= PWGHF vertexing =\n"); if (iPWGDQJPSIfilter) printf("= PWGDQ j/psi filter =\n"); if (iPWGHFd2h) printf("= PWGHF D0->2 hadrons QA =\n"); // Make the analysis manager and connect event handlers AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train"); mgr->SetCacheSize(0); if (useSysInfo) { //mgr->SetNSysInfo(100); AliSysInfo::SetVerbose(kTRUE); } // Create input handler (input container created automatically) // ESD input handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); // Monte Carlo handler if (useMC) { AliMCEventHandler* mcHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcHandler); mcHandler->SetReadTR(useTR); } // AOD output container, created automatically when setting an AOD handler if (iAODhandler) { // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); mgr->SetOutputEventHandler(aodHandler); } // Debugging if needed if (useDBG) mgr->SetDebugLevel(3); AddAnalysisTasks(cdbPath); if (merge) { AODmerge(); mgr->InitAnalysis(); mgr->SetGridHandler(new AliAnalysisAlien); mgr->StartAnalysis("gridterminate",0); return; } // Run the analysis // TChain *chain = CreateChain(); if (!chain) return; TStopwatch timer; timer.Start(); mgr->SetSkipTerminate(kTRUE); if (mgr->InitAnalysis()) { mgr->PrintStatus(); mgr->StartAnalysis("local", chain); } timer.Print(); }
void anaCaloFilter(Int_t mode=mLocal) { // Main char cmd[200] ; sprintf(cmd, ".! rm -rf AliAOD.root") ; gROOT->ProcessLine(cmd) ; //-------------------------------------------------------------------- // Load analysis libraries // Look at the method below, // change whatever you need for your analysis case // ------------------------------------------------------------------ LoadLibraries(mode) ; //------------------------------------------------------------------------------------------------- //Create chain from ESD and from cross sections files, look below for options. //------------------------------------------------------------------------------------------------- if(kInputData == "ESD") kTreeName = "esdTree" ; else if(kInputData == "AOD") kTreeName = "aodTree" ; else { cout<<"Wrong data type "<<kInputData<<endl; break; } TChain *chain = new TChain(kTreeName) ; CreateChain(mode, chain); if(chain){ AliLog::SetGlobalLogLevel(AliLog::kError);//Minimum prints on screen //-------------------------------------- // Make the analysis manager //------------------------------------- AliAnalysisManager *mgr = new AliAnalysisManager("Manager", "Manager"); // AOD output handler AliAODHandler* aodoutHandler = new AliAODHandler(); aodoutHandler->SetOutputFileName("AliAOD.root"); ////aodoutHandler->SetCreateNonStandardAOD(); mgr->SetOutputEventHandler(aodoutHandler); //input if(kInputData == "ESD") { // ESD handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdHandler); esdHandler->SetReadFriends(kFALSE); cout<<"ESD handler "<<mgr->GetInputEventHandler()<<endl; } if(kInputData == "AOD") { // AOD handler AliAODInputHandler *aodHandler = new AliAODInputHandler(); mgr->SetInputEventHandler(aodHandler); cout<<"AOD handler "<<mgr->GetInputEventHandler()<<endl; } // mgr->SetDebugLevel(1); //------------------------------------------------------------------------- //Define task, put here any other task that you want to use. //------------------------------------------------------------------------- // ESD physics selection task if(kInputData == "ESD" && kUsePhysSel) { gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C"); AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(); } gROOT->LoadMacro("AddTaskCaloFilter.C"); AliAnalysisTaskCaloFilter* filter = AddTaskCaloFilter(); //AliAnalysisTaskCaloFilter * filter = new AliAnalysisTaskCaloFilter(); //filter->SetConfigFileName("ConfigCaloFilter.C"); //mgr->AddTask(filter); // Create containers for input/output AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer(); AliAnalysisDataContainer *coutntuple = mgr->CreateContainer("EventNtuple", TNtuple::Class(), AliAnalysisManager::kOutputContainer, "eventselection.root"); mgr->ConnectInput (filter, 0, cinput1); mgr->ConnectOutput (filter, 0, coutput1 ); mgr->ConnectOutput (filter, 1, coutntuple ); //----------------------- // Run the analysis //----------------------- TString smode = ""; if (mode==mLocal || mode == mLocalCAF) smode = "local"; else if (mode==mPROOF) smode = "proof"; else if (mode==mGRID) smode = "local"; mgr->InitAnalysis(); mgr->PrintStatus(); mgr->StartAnalysis(smode.Data(),chain); cout <<" Analysis ended sucessfully "<< endl ; } else cout << "Chain was not produced ! "<<endl; //sprintf(cmd, ".! rm -rf CorrectionFiles") ; }