/** * Register special putput storage * * @param url Url (root://host/full_path) * * @return true on success */ static Bool_t RegisterStorage(const TString& url) { if (url.IsNull()) { Error("OutputUtilities::RegisterStorage", "No storage URI specified"); return false; } // Get the manager AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager(); // Get the container AliAnalysisDataContainer* cont = mgr->GetCommonOutputContainer(); if (!cont) { Warning("OutputUtilities::RegisterStorage", "No common output container defined"); return false; } TString u(url); if (u.EqualTo("auto")) { if (!StartXrootd(u)) { Warning("OutputUtilities::RegisterStorage", "Couldn't start the XRootD server"); return false; } } cont->SetSpecialOutput(); mgr->SetSpecialOutputLocation(u); return true; }
/** * Get the name of the registered data set * * * @return Name of the registered data set */ static TString RegisteredDataset() { TString ret; AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager(); AliVEventHandler* oh = mgr->GetOutputEventHandler(); if (!oh) { Warning("OutputUtilities::GetOutputDataSet", "No outout event handler defined"); return ret; } AliAnalysisDataContainer* co = mgr->GetCommonOutputContainer(); if (!co) { Warning("OutputUtilities::GetOutputDataSet", "No common output container defined"); return ret; } if (!co->IsRegisterDataset()) { Info("OutputUtilities::GetOutputDataSet", "Common output is not registered as dataset"); return ret; } ret = oh->GetOutputFileName(); // ret.ReplaceAll("TTree", ""); ret.ReplaceAll(".root", ""); // ret.Append(co->GetTitle()); return ret; }
AliAnalysisTaskSEF01710fromAODtracks *AddTaskF01710fromAODtracks( Int_t antype = 0, Bool_t theMCon=kFALSE, Bool_t writeVariableTree=kFALSE, Int_t nTour=0 ) { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskLc2V0YW", "No analysis manager to connect to."); return NULL; } //CREATE THE TASK printf("CREATE TASK\n"); AliAnalysisTaskSEF01710fromAODtracks *task = new AliAnalysisTaskSEF01710fromAODtracks("AliAnalysisTaskSEF01710fromAODtracks",writeVariableTree); task->SetMC(theMCon); task->SetDebugLevel(1); task->SetAnalysisType(antype); if(antype==2 || antype == 3){ task->SetProdV0DaughterDcaToPrimVertex(0.1); task->SetProdRfidMinV0(5.); } task->SetEventMixingWithPools(); //task->SetEventMixingOff(); Double_t pvzbinlimits[] = {-12,-10,-8,-6,-4,-2,0,2,4,6,8,10,12}; Int_t pvzbinnumb = sizeof(pvzbinlimits)/sizeof(Double_t) - 1; task->SetPoolPVzBinLimits(pvzbinnumb,pvzbinlimits); Double_t cent_mult_binlimitspp[] = { 0,100}; Int_t cent_mult_bin_numbpp = sizeof(cent_mult_binlimitspp)/sizeof(Double_t) - 1; task->SetPoolCentBinLimits(cent_mult_bin_numbpp,cent_mult_binlimitspp); task->SetNumberOfEventsForMixing(10);//pp mgr->AddTask(task); // Create and connect containers for input/output TString outputfile = AliAnalysisManager::GetCommonFileName(); outputfile += ":PWGLF_RES_F01710_"; outputfile += nTour; mgr->ConnectInput(task,0,mgr->GetCommonInputContainer()); // ----- output data ----- AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(Form("f0hist%1d",nTour),TList::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data()); // general histos mgr->ConnectOutput(task,1,coutput1); AliAnalysisDataContainer *coutputL2 = mgr->CreateContainer(Form("F0variables%1d",nTour),TTree::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data()); mgr->ConnectOutput(task,2,coutputL2); AliAnalysisDataContainer *coutputL3 = mgr->CreateContainer(Form("F0All%1d",nTour),TList::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data()); // general histos mgr->ConnectOutput(task,3,coutputL3); return task; }
AliAnalysisTaskMuonAODCreation *AddTaskMuonAODCreation() { // Creates a filter task to copy muon tracks from the Standard AOD to the Muon AOD // R. Arnaldi - 6/10/09 // Get the pointer to the existing analysis manager via the static access method. //============================================================================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskMuonAODCreation", "No analysis manager to connect to."); return NULL; } // Get input handler TString type = mgr->GetInputEventHandler()->GetDataType(); // Define output AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist0",TList::Class(),AliAnalysisManager::kOutputContainer,"MuonPlots.root"); // Create the task, add it to the manager and configure it. //=========================================================================== AliAnalysisTaskMuonAODCreation *muonAODtask = new AliAnalysisTaskMuonAODCreation("Muon AOD creation"); mgr->AddTask(muonAODtask); // Create ONLY the output containers for the data produced by the task. // Get and connect other common input/output containers via the manager as below //============================================================================== mgr->ConnectInput (muonAODtask, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput (muonAODtask, 0, mgr->GetCommonOutputContainer()); mgr->ConnectOutput (muonAODtask, 1, coutput1); return muonAODtask; }
void AddClusterSelectionTask(TString name = "ClusterSelectionTask") { gSystem->AddIncludePath("-I$ALICE_ROOT/include"); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskPHOSPi0Flow", "No analysis manager to connect to"); return NULL; } if (!mgr->GetInputEventHandler()) { ::Error("AddTaskPHOSPi0Flow", "This task requires an input event handler"); return NULL; } gROOT->LoadMacro("ClusterSelectionTask.cxx+g"); ClusterSelectionTask * task = new ClusterSelectionTask(name); mgr->AddTask(task); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer() ); TString cname(Form("HistList", name)); TString pname(Form("%s:%s", AliAnalysisManager::GetCommonFileName(), name)); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(cname.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, pname.Data()); mgr->ConnectOutput(task, 1, coutput1); cname = Form("SelectedPhotons", name); AliAnalysisDataContainer *cexchange2 = mgr->CreateContainer(cname.Data(), TList::Class(), AliAnalysisManager::kExchangeContainer, pname.Data()); mgr->ConnectOutput(task, 2, cexchange2); return task; }
void MSFT_AddSPmethod(char *name, TString myFolder, char *thecuts, int harmonic, AliAnalysisDataContainer *flowEvent, AliFlowTrackSimpleCuts *cutsPOI=NULL, char *Qvector) { TString fileName = AliAnalysisManager::GetCommonFileName(); myFolder.Append( Form("v%d",harmonic) ); TString myNameSP = Form("%sv%d%s_%s", name, harmonic, Qvector, thecuts); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myNameSP.Data()), AliFlowEventSimple::Class(), AliAnalysisManager::kExchangeContainer ); AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myNameSP.Data()), NULL, cutsPOI); tskFilter->SetSubeventEtaRange( -5.0, -1.0, 1.0, +5.0 ); mgr->AddTask(tskFilter); mgr->ConnectInput( tskFilter, 0, flowEvent); mgr->ConnectOutput(tskFilter, 1, flowEvent2); AliAnalysisDataContainer *outSP = mgr->CreateContainer( myNameSP.Data(),TList::Class(),AliAnalysisManager::kOutputContainer, Form("%s:FlowCascade_SP_%s",fileName.Data(),myFolder.Data()) ); AliAnalysisTaskScalarProduct *tskSP = new AliAnalysisTaskScalarProduct( Form("TaskScalarProduct_%s",myNameSP.Data()),kFALSE); tskSP->SetApplyCorrectionForNUA(kTRUE); tskSP->SetHarmonic(harmonic); tskSP->SetTotalQvector(Qvector); tskSP->SetBookOnlyBasicCCH(kTRUE); mgr->AddTask(tskSP); mgr->ConnectInput( tskSP,0,flowEvent2); mgr->ConnectOutput(tskSP,1,outSP); }
void MSFT_AddQCmethod(char *name, TString myFolder, char *thecuts, int harmonic, AliAnalysisDataContainer *flowEvent, AliFlowTrackSimpleCuts *cutsPOI=NULL) { TString fileName = AliAnalysisManager::GetCommonFileName(); myFolder.Append( Form("v%d",harmonic) ); TString myName = Form("%sv%d_%s", name, harmonic, thecuts); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myName.Data()), AliFlowEventSimple::Class(), AliAnalysisManager::kExchangeContainer ); AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myName.Data()), NULL, cutsPOI); mgr->AddTask(tskFilter); mgr->ConnectInput( tskFilter, 0, flowEvent); mgr->ConnectOutput(tskFilter, 1, flowEvent2); AliAnalysisDataContainer *outQC = mgr->CreateContainer( myName.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:FlowCascade_QC_%s", fileName.Data(), myFolder.Data()) ); AliAnalysisTaskQCumulants *tskQC = new AliAnalysisTaskQCumulants( Form("TaskQCumulants_%s",myName.Data()),kFALSE ); tskQC->SetApplyCorrectionForNUA(kTRUE); tskQC->SetHarmonic(harmonic); tskQC->SetBookOnlyBasicCCH(kTRUE); mgr->AddTask(tskQC); mgr->ConnectInput( tskQC, 0, flowEvent2); mgr->ConnectOutput(tskQC, 1, outQC); }
Bool_t InputHandlerSetup(TString format = "esd", Bool_t useRP=kFALSE, Bool_t useKine = kFALSE) { format.ToLower(); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliAnalysisDataContainer *cin = mgr->GetCommonInputContainer(); if (cin) return; if (!format.CompareTo("esd")) { AliESDInputHandler *esdInputHandler = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); if (!esdInputHandler) { Info("CustomAnalysisTaskInputSetup", "Creating esdInputHandler ..."); if (useRP) esdInputHandler = new AliESDInputHandlerRP(); else esdInputHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdInputHandler); } if (useKine) { AliMCEventHandler* mcInputHandler = dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); if (!mcInputHandler) { Info("CustomAnalysisTaskInputSetup", "Creating mcInputHandler ..."); AliMCEventHandler* mcInputHandler = new AliMCEventHandler(); mgr->SetMCtruthEventHandler(mcInputHandler); } } } else if (!format.CompareTo("aod")) { AliAODInputHandler *aodInputHandler = dynamic_cast<AliAODInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); if (!aodInputHandler) { Info("CustomAnalysisTaskInputSetup", "Creating aodInputHandler ..."); aodInputHandler = new AliAODInputHandler(); mgr->SetInputEventHandler(aodInputHandler); } } else { Info("Wrong input format!!! Only ESD and AOD are supported. Skipping Task ..."); return kFALSE; } return kTRUE; }
AliAnalysisTaskPsEfficiency* AddTaskPsEfficiency(bool isMC=true,TString suffix = ""){ // Creates, configures and attaches to the train the task for pi, K , p spectra // with ITS standalone tracks // Get the pointer to the existing analysis manager via the static access method. //============================================================================== ::Info("AddTaskPsEfficiency","Adding a new task with this settings isMC = %i",isMC); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskPsEfficiency", "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("AddTaskPsEfficiency", "This task requires an input event handler"); return NULL; } TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" if(type.Contains("ESD")){ ::Error("AddTaskPsEfficiency", "This task requires to run on AOD"); return NULL; } // Add MC handler (for kinematics) if(isMC){ AliMCEventHandler* handler = new AliMCEventHandler; handler->SetReadTR(kFALSE); mgr->SetMCtruthEventHandler(handler); } // Create and configure the task TString tskname = "Pentaquark"; tskname.Append(Form("%s",suffix.Data())); AliAnalysisTaskPsEfficiency *taskPs = new AliAnalysisTaskPsEfficiency(tskname); //taskPs->SetMC(isMC); mgr->AddTask(taskPs); // Create ONLY the output containers for the data produced by the task. // Get and connect other common input/output containers via the manager as below //============================================================================== TString outputFileName = AliAnalysisManager::GetCommonFileName(); outputFileName += ":AODpentaquark"; AliAnalysisDataContainer *coutput =0x0; coutput = mgr->CreateContainer(Form("lbariogl_%s",tskname.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, AliAnalysisManager::GetCommonFileName()); mgr->ConnectInput(taskPs, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(taskPs, 1, coutput); return taskPs; }
/** * Path of output * * @return Path to output - possibly a data set */ virtual TString OutputPath() const { AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) return ""; AliVEventHandler* outH = mgr->GetOutputEventHandler(); if (!outH) return ""; TString ret = gSystem->ConcatFileName(gSystem->WorkingDirectory(), outH->GetOutputFileName()); return ret; }
Bool_t AddAMEventMixingTest(TString analysisSource = "proof", TString analysisMode = "test",TString input="aod",TString inputMC="", TString postfix = "",TString idStr="0") { Bool_t useEventMixingPar = 1; Int_t usePhysSel = 1; Bool_t useMC = !inputMC.CompareTo("mc"); input.ToLower(); // ALICE stuff AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Printf("Error[AddAMEventMixingTest] mgr is null !!!"); return kFALSE; } AliAnalysisGrid *analysisPlugin = mgr->GetGridHandler(); if (!analysisPlugin) { Printf("Error[AddAMEventMixingTest] : analysisPlugin is null !!!"); return kFALSE; } TString myAdditionalLibs; if (useEventMixingPar) { AliAnalysisAlien::SetupPar("EventMixing"); myAdditionalLibs += " EventMixing.par"; } else { gSystem->Load("libEventMixing.so"); myAdditionalLibs += " libEventMixing.so"; } gROOT->LoadMacro("AliAnalysisTaskEx02.cxx++g"); analysisPlugin->SetAnalysisSource("AliAnalysisTaskEx02.cxx+"); myAdditionalLibs+=" AliAnalysisTaskEx02.h AliAnalysisTaskEx02.cxx"; analysisPlugin->SetAdditionalLibs(myAdditionalLibs.Data()); AliMultiInputEventHandler *multiInputHandler = mgr->GetInputEventHandler(); if (usePhysSel && !input.CompareTo("esd")) { gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); AddTaskPhysicsSelection(useMC); // maybe we can put it in $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C AliMultiInputEventHandler *multiIH = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler()); if (multiIH){ AliESDInputHandler *esdIH = dynamic_cast<AliESDInputHandler *>(multiIH->GetFirstInputEventHandler()); if (esdIH) esdIH->SetEventSelection(multiIH->GetEventSelection()); AliAODInputHandler *aodIH = dynamic_cast<AliAODInputHandler *>(multiIH->GetFirstInputEventHandler()); if (aodIH) aodIH->SetEventSelection(multiIH->GetEventSelection()); } } // add mixing handler (uncomment to turn on Mixnig) gROOT->LoadMacro("AddMixingHandler.C"); AddMixingHandler(multiInputHandler, input, useMC,postfix); // load and run AddTask macro gROOT->LoadMacro("AddEventMixingTestTask.C"); AddEventMixingTestTask(input, useMC, postfix); return kTRUE; }
AliAnalysisTaskEMCALTriggerQA * AddTaskEMCALTriggerQA(Bool_t kSimulation = kFALSE, TString outputFile = "") { // Get the pointer to the existing analysis manager via the static access method. //============================================================================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskEMCALTriggerQA", "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("AddTaskEMCALTriggerQA", "This task requires an input event handler"); return NULL; } TString taskName = "QAEMCALTrigger"; AliAnalysisTaskEMCALTriggerQA * qatrigger = new AliAnalysisTaskEMCALTriggerQA(taskName); // Configuration Bool_t kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE; if(kUseKinematics) kSimulation = kTRUE; if(kSimulation) qatrigger->SwitchOnMCData(); else qatrigger->SwitchOffMCData(); TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" if(inputDataType.Contains("AOD")) qatrigger->SwitchOffV0SignalHistograms(); else qatrigger->SwitchOnV0SignalHistograms(); // Define the input/output containers qatrigger->GetRecoUtils()->SwitchOnBadChannelsRemoval (); AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); if(outputFile.Length()==0) outputFile = AliAnalysisManager::GetCommonFileName(); printf("*** Task Name %s; Output file name: %s ***\n",taskName.Data(),outputFile.Data()); AliAnalysisDataContainer *coutput = mgr->CreateContainer(Form("%s",taskName.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s",outputFile.Data())); mgr->AddTask(qatrigger); mgr->ConnectInput (qatrigger, 0, cinput1); mgr->ConnectOutput (qatrigger, 1, coutput); return qatrigger; }
Bool_t RsnConfigTest ( AliRsnAnalysisTask *task, Bool_t isMC ) { // cutBPIDKaonSet // find the index of the corresponding list in the RsnInputHandler const char *listNameQuality = "qualityTPC"; const char *listNamePID = "kaonTPC"; Int_t qualityID = -1; Int_t pidID = -1; AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliMultiInputEventHandler *multi = dynamic_cast<AliMultiInputEventHandler*>(mgr->GetInputEventHandler()); if (multi) { TObjArray *array = multi->InputEventHandlers(); TObjArrayIter next(array); TObject *obj; while ( (obj = next()) ) { if (obj->InheritsFrom(AliRsnInputHandler::Class())) { AliRsnInputHandler *rsn = (AliRsnInputHandler*)obj; AliRsnDaughterSelector *sel = rsn->GetSelector(); qualityID = sel->GetID(listNameQuality, kTRUE); pidID = sel->GetID(listNamePID, kTRUE); } } } // if (qualityID < 0) { // ::Error("RsnConfigTest", "Selector does not contain list for quality only"); // return kFALSE; // } // if (pidID < 0) { // ::Error("RsnConfigTest", "Selector does not contain list for quality+PID"); // return kFALSE; // } ::Info("RsnConfigTest", "ID for cut set named '%10s' = %d", listNameQuality, qualityID); // ::Info("RsnConfigTest", "ID for cut set named '%10s' = %d", listNamePID, pidID); // add pair computation AddPairLoop(task, isMC, 0, 0, "test"); // add monitor computation AddMonitorLoop(task, isMC, 0, "test"); // // add pair computation // AddPairLoop(task, isMC, qualityID, qualityID, "test"); // // add monitor computation // AddMonitorLoop(task, isMC, qualityID, "test"); // AddMonitorLoop(task, isMC, pidID, "test"); return kTRUE; }
void AddAnalysisManagerMixRsn(TString analysisSource = "proof", TString analysisMode = "test", TString opts = "") { Bool_t useMC = kFALSE; TString format = "esd"; // ALICE stuff AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) mgr = new AliAnalysisManager("Martin Vala's AM"); gROOT->LoadMacro("SetupAnalysisPlugin.C"); AliAnalysisGrid *analysisPlugin = SetupAnalysisPlugin(analysisMode.Data()); if (!analysisPlugin) return; gSystem->Load("libXMLParser.so"); gSystem->Load("libANALYSIS.so"); gSystem->Load("libANALYSISalice.so"); gSystem->Load("libCORRFW.so"); gSystem->Load("libEventMixing.so"); gSystem->Load("libPWG2resonances.so"); analysisPlugin->SetAliRootMode("ALIROOT"); // Loads AF libs by default // sets additional settings to plubin analysisPlugin->SetAdditionalLibs("libXMLParser.so libCORRFW.so libEventMixing.so libPWG2resonances.so"); // analysisPlugin->SetAdditionalLibs("libXMLParser.so libCORRFW.so libEventMixing.so PWG2resonances.par RESONANCESMV.par"); // analysisPlugin->SetAdditionalLibs("libXMLParser.so libCORRFW.so libEventMixing.so libPWG2resonances.so"); // sets plugin to manager mgr->SetGridHandler(analysisPlugin); Info("AddAnalysisManagerMixRsn.C", "Creating AliMultiInputEventHandler ..."); AliMultiInputEventHandler *mainInputHandler = new AliMultiInputEventHandler(); Info("AddAnalysisManagerMixRsn.C", "Creating esdInputHandler ..."); AliESDInputHandler *esdInputHandler = new AliESDInputHandler(); mainInputHandler->AddInputEventHandler(esdInputHandler); if (useMC) { Info("AddAnalysisManagerMixRsn.C", "Creating mcInputHandler ..."); AliMCEventHandler* mcInputHandler = new AliMCEventHandler(); mainInputHandler->AddInputEventHandler(mcInputHandler); } // add main input handler (with mixing handler) mgr->SetInputEventHandler(mainInputHandler); // add mixing handler (uncomment to turn on Mixnig) gROOT->LoadMacro("MixingSetting.C"); mainInputHandler->AddInputEventHandler(MixingSetting()); // adds all tasks gROOT->LoadMacro("AddAnalysisTaskAllRsn.C"); AddAnalysisTaskAllRsn(format, useMC, opts); }
//___________________________________________________________ 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); } }
AliAnalysisTaskFemto *AddTaskFemto(const char *configMacroName="ConfigFemtoAnalysis.C", const char *configMacroParameters="" ) { // Creates a proton analysis task and adds it to the analysis manager. // A. Get the pointer to the existing analysis manager via the static access method. //============================================================================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error("AddTaskFemto", "No analysis manager to connect to."); return NULL; } // B. Check the analysis type using the event handlers connected to the analysis // manager. The availability of MC handler cann also be checked here. //============================================================================== if (!mgr->GetInputEventHandler()) { ::Error("AddTaskFemto", "This task requires an input event handler"); return NULL; } TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" cout << "Found " <<type << " event handler" << endl; // C. Create the task, add it to manager. //=========================================================================== // gSystem->SetIncludePath("-I$ROOTSYS/include -I./PWG2AOD/AOD -I./PWG2femtoscopy/FEMTOSCOPY/AliFemto -I./PWG2femtoscopyUser/FEMTOSCOPY/AliFemtoUser -I$ALICE_PHYSICS/include"); if (TProofMgr::GetListOfManagers()->GetEntries()) { // if (dynamic_cast<TProofLite *> gProof) { // char *macrocommand[10000]; // sprintf(macrocommand, ".L %s", configMacroName); // gProof->Exec(macrocommand); // } // else gProof->Load(configMacroName); } // gROOT->LoadMacro("ConfigFemtoAnalysis.C++"); AliAnalysisTaskFemto *taskfemto = new AliAnalysisTaskFemto("TaskFemto",configMacroName,configMacroParameters); mgr->AddTask(taskfemto); // D. Configure the analysis task. Extra parameters can be used via optional // arguments of the AddTaskXXX() function. //=========================================================================== // E. Create ONLY the output containers for the data produced by the task. // Get and connect other common input/output containers via the manager as below //============================================================================== TString outputfile = AliAnalysisManager::GetCommonFileName(); outputfile += ":PWGCFEMTO_PLam"; AliAnalysisDataContainer *cout_femto = mgr->CreateContainer("femtolist_PLam", TList::Class(), AliAnalysisManager::kOutputContainer,outputfile); mgr->ConnectInput(taskfemto, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(taskfemto, 0, cout_femto); // Return task pointer at the end return taskfemto; }
//_____________________________________________________________________________ AliAnalysisTask *AddTaskT0Analysis() { // // add calibration task // gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libT0calib"); cout<<"@@@ AddTaskT0Analysis "<<endl; gSystem->Load("libANALYSIS"); gSystem->Load("libANALYSISalice"); gSystem->Load("libT0calib"); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskT0Analysis", "No analysis manager to connect to."); return NULL; } // check the input handler if (!mgr->GetInputEventHandler()) { ::Error("AddTaskT0Analysis", "This task requires an input event handler"); return NULL; } // Check the analysis type using the event handlers connected to the analysis manager. //============================================================================== if (!mgr->GetInputEventHandler()) { ::Error("AddTaskT0Analysis", "This task requires an input event handler"); return NULL; } TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" // setup task AliT0CalibAnalysisTask *task1 = new AliT0CalibAnalysisTask("ObjectsTrain"); mgr->AddTask(task1); AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); if (!cinput1) cinput1 = mgr->CreateContainer("cchain",TChain::Class(), AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("T0tree",TList::Class(), AliAnalysisManager::kOutputContainer,"T0AnalysisTree.root"); mgr->ConnectInput(task1,0,cinput1); mgr->ConnectOutput(task1,1,coutput1); return task1; }
AliAnalysisTaskLRC *AddTaskLRC(Bool_t RunKine=kFALSE, TString OutputRootFolder=":PWGCFLRC") { // This macro adds AliAnalysisTaskLRC to existing AnalysisManager // RunKine paramiter switch task to kinematics analysis // Author : Andrey Ivanov , St.Peterburg State University // Email: [email protected] // Version line : 3.6 // Version 3.6.7 gROOT->LoadMacro("configLRCAnalysis.C"); //gROOT->LoadMacro("AliAnalysisTaskIA.cxx+g"); // A. Get the pointer to the existing analysis manager via the static access method. //============================================================================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error("AddTaskLRC", "No analysis manager to connect to."); return NULL; } // B. Check the analysis type using the event handlers connected to the analysis // manager. The availability of MC handler cann also be checked here. //============================================================================== if (!mgr->GetInputEventHandler()) { Error("AddTaskLRC", "This task requires an input event handler"); return NULL; } TString type = mgr->GetInputEventHandler()->GetDataType(); cout<<" # TaskLRC - input :"<<type<<"\n"; // MB - Global2 taskLRC = createLRCtaskSkeleton("Task_LRC_MB_Global2",RunKine); taskLRC->SetTrackCuts(createAliLRCcuts("Global2")); addAliLRCProcessors(taskLRC,kTRUE); taskLRC->SetVtxDiamond(0.4,0.4,7.0); taskLRC->SetMaxPtLimit(1.5); taskLRC->SetMinPtLimit(0.3); mgr->AddTask(taskLRC); configureLRCtaskOutput(taskLRC,":PWGCFLRC"); return taskLRC; }
//________________________________________________________________ Bool_t InputHandlerSetup(TString esdFName) { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliAnalysisDataContainer *cin = mgr->GetCommonInputContainer(); if (cin) return; AliESDInputHandler *esdInputHandler = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); if (!esdInputHandler) { Info("CustomAnalysisTaskInputSetup", "Creating esdInputHandler ..."); esdInputHandler = new AliESDInputHandler(); mgr->SetInputEventHandler(esdInputHandler); } esdInputHandler->SetFriendFileName(esdFName.Data()); // esdInputHandler->SetActiveBranches("ESDfriend*"); esdInputHandler->SetReadFriends(kTRUE); return kTRUE; }
AliAnalysisTaskPrepareInputForEmbedding *AddTaskPrepareInputForEmbedding( TString njet = "Jet_AKTChargedR040_PicoTracks_pT0150_E_scheme", /*TString njetClosest = "Jet_AKTChargedR040_MCParticlesSelected_pT0150_E_scheme",*/ Double_t R = 0.4, Double_t jetptcut = 1, Double_t jetareacut = 0.6, TString ntrack = "PicoTracks", TString accType = "TPC", Bool_t useLeadingJet = kFALSE, Bool_t usedHCtagging = kFALSE){ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr){ Error("AddTaskPrepareInputForEmbedding","No analysis manager found."); return 0; } if (!mgr->GetInputEventHandler()) { ::Error("AddTaskPrepareInputForEmbedding", "This task requires an input event handler"); return NULL; } TString wagonName = Form("PrepareInputForEmbedding%s%s", useLeadingJet ? "L" : "", usedHCtagging ? "HC" : ""); AliAnalysisTaskPrepareInputForEmbedding *task = new AliAnalysisTaskPrepareInputForEmbedding(wagonName); task->SetLeadingJetOnly(useLeadingJet); task->SetDetHardCoreTagging(usedHCtagging); AliParticleContainer *partCont = task->AddParticleContainer(ntrack); AliJetContainer *jetCont = task->AddJetContainer(njet, accType, R); if(jetCont){ //jetCont->SetRhoName(rhoname); //jetCont->SetRhoMassName(rhoMname); jetCont->ConnectParticleContainer(partCont); jetCont->SetJetPtCut(jetptcut); jetCont->SetPercAreaCut(jetareacut); } //AliJetContainer *jetContClosest = task->AddJetContainer(njetClosest, accType, R); mgr->AddTask(task); //Connnect input mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer()); //Connect output TString contName(wagonName); TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName()); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile); contName.Append("Tree"); AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(contName.Data(), TTree::Class(),AliAnalysisManager::kOutputContainer,outputfile); mgr->ConnectOutput(task,1,coutput1); mgr->ConnectOutput(task,2,coutput2); return task; }
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"); }
AliAnalysisTaskFilterFriend *AddTaskFilterFriend() { // pointer to the analysis manager AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error("AddTaskTOFCalib", "No analysis manager to connect to."); return NULL; } // check the input handler if (!mgr->GetInputEventHandler()) { ::Error("AddTask", "This task requires an input event handler"); return NULL; } TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD" // create the task AliAnalysisTaskFilterFriend* filter = new AliAnalysisTaskFilterFriend("filter_1"); mgr->AddTask(filter); // connecting the input/output containers AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput0 = mgr->GetCommonOutputContainer(); mgr->ConnectInput (filter, 0, cinput0 ); //mgr->ConnectOutput(filter, 0, coutput0); return filter; }
AliAnalysisTaskEpRatio* AddTaskPHOSEpRatio (Bool_t kMC = kFALSE, const char* name = "PHOSEpRatio", const char* options = "", UInt_t offlineTriggerMask = AliVEvent::kINT7 ) { //Add a task AliAnalysisTaskEpRatio to the analysis train. //Author: Boris Polishchuk. AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskPHOSEpRatio", "No analysis manager to connect to"); return NULL; } if (!mgr->GetInputEventHandler()) { ::Error("AddTaskPHOSEpRatio", "This task requires an input event handler"); return NULL; } AliAnalysisTaskEpRatio* task = new AliAnalysisTaskEpRatio(Form("%sTask", name)); if(!kMC) task->SelectCollisionCandidates(offlineTriggerMask); mgr->AddTask(task); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer() ); TString cname(Form("%sCoutput1", name)); TString pname(Form("%s:%s", AliAnalysisManager::GetCommonFileName(), name)); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(cname.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, pname.Data()); mgr->ConnectOutput(task, 1, coutput1); return task; }
AliAnalysisTaskADQA *AddTaskADQA(){ //--- get the current analysis manager ---// AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error("AddTask_ADQA", "No analysis manager found."); return 0; } // Check the analysis type using the event handlers connected to the analysis manager. //============================================================================== if (!mgr->GetInputEventHandler()) { Error("AddTask_ADQA", "This task requires an input event handler"); return 0; } // Create tasks AliAnalysisTaskADQA *task = new AliAnalysisTaskADQA("ESD"); mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput = mgr->CreateContainer("ADQAListHist", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:ADQA", AliAnalysisManager::GetCommonFileName())); // Connect input/output mgr->ConnectInput(task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); return task; }
AliAnalysisTaskADCalib* AddTaskADCalib(Int_t bcExtrapolationMin=9, Int_t bcExtrapolationMax=15) { AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { Error("AddTask_ADCalib", "No analysis manager found."); return NULL; } if (!mgr->GetInputEventHandler()) { Error("AddTask_ADCalib", "This task requires an input event handler"); return 0; } AliAnalysisTaskADCalib *task = new AliAnalysisTaskADCalib(); task->SetBCRangeExtrapolation(bcExtrapolationMin, bcExtrapolationMax); mgr->AddTask(task); // Create containers for input/output AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisDataContainer *coutput = mgr->CreateContainer("ADCalibListHist", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:ADCalib", AliAnalysisManager::GetCommonFileName())); // Connect input/output mgr->ConnectInput (task, 0, cinput); mgr->ConnectOutput(task, 1, coutput); return task; }
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 runAliTask() { TStopwatch timer; timer.Start(); // gSystem->Load("libTree.so"); // gSystem->Load("libGeom.so"); // gSystem->Load("libVMC.so"); // gSystem->Load("libPhysics.so"); // //____________________________________________________// // //_____________Setting up required packages___________// // //____________________________________________________// // gSystem->Load("libSTEERBase.so"); // gSystem->Load("libESD.so"); // gSystem->Load("libAOD.so"); // gSystem->Load("libANALYSIS.so"); // gSystem->Load("libANALYSISalice.so"); // gROOT->ProcessLine(".include $ALICE_ROOT/include"); // // //___________Compile analysis task using AClic____________// // gROOT->LoadMacro("../task/AliAnalysisTaskPt.cxx+g"); // // // gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); TChain* chain = CreateESDChain("files.txt", 2); //____________________________________________// // Make the analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("TestManager"); AliESDInputHandler* esdH = new AliESDInputHandler(); mgr->SetInputEventHandler(esdH); //____________________________________________// // 1st Pt task AliAnalysisTaskPt *task1 = new AliAnalysisTaskPt("TaskPt"); mgr->AddTask(task1); // Create containers for input/output AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer); AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", TH1::Class(),AliAnalysisManager::kOutputContainer,"Pt.ESD.root"); //____________________________________________// mgr->ConnectInput(task1,0,cinput1); mgr->ConnectOutput(task1,0,coutput1); if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); //mgr->StartAnalysis("local",chain); timer.Stop(); timer.Print(); }
//______________________________________________________________________________ void CreateAnalysisTrain() { /// create the analysis train and configure it // analysis manager AliAnalysisManager *mgr = new AliAnalysisManager("MuonPhysicsAnalysis"); // Debug mode //mgr->SetDebugLevel(3); // AOD handler AliInputEventHandler* aodH = new AliAODInputHandler; mgr->SetInputEventHandler(aodH); // Fill the trigger list with desired trigger combinations (See on ALICE log book for denomination) //============================================================================== TList* triggers = new TList; // Create pointer for trigger list triggers->SetOwner(kTRUE); // Give rights to trigger liser if (!isMC) { // PbPb trigger triggers->Add(new TObjString("CINT7-B-NOPF-MUFAST"));//MB &0MUL triggers->Add(new TObjString("CINT7-B-NOPF-MUFAST&0MSL"));//MB &0MUL triggers->Add(new TObjString("CINT7-B-NOPF-MUFAST&0MUL"));//MB &0MUL triggers->Add(new TObjString("CMUL7-B-NOPF-MUFAST"));// MUL triggers->Add(new TObjString("CMSL7-B-NOPF-MUFAST"));// MSL triggers->Add(new TObjString("CMSL7-B-NOPF-MUFAST&0MUL"));// MSL &0MUL } // Load centrality task //============================================================================== gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"); AddTaskMultSelection(kFALSE); // user // Load task //============================================================================== TString outputname = AliAnalysisManager::GetAnalysisManager()->GetCommonFileName(); // Create output name in case of no dataset selected gROOT->LoadMacro("AddTaskMuMu.C"); AddTaskMuMu(outputname.Data(),triggers,"PbPb2015",isMC); cout <<"add task mumu done"<< endl; }
AliEmcalPicoTrackFromJetMaker* AddTaskEmcalPicoTrackFromJetMaker( const char *name = "PicoTracks", const char *inname = "jets", const char *taskName = "AliEmcalPicoTrackFromJetMaker" ) { // Get the pointer to the existing analysis manager via the static access method. //============================================================================== AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskEmcalPicoTrackFromJetMaker", "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("AddTaskEmcalPicoTrackFromJetMaker", "This task requires an input event handler"); return NULL; } //------------------------------------------------------- // Init the task and do settings //------------------------------------------------------- AliEmcalPicoTrackFromJetMaker *eTask = new AliEmcalPicoTrackFromJetMaker(taskName); eTask->SetTracksOutName(name); eTask->SetJetsInName(inname); //------------------------------------------------------- // Final settings, pass to manager and set the containers //------------------------------------------------------- mgr->AddTask(eTask); // Create containers for input/output AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer(); mgr->ConnectInput(eTask, 0, cinput1 ); return eTask; }
AliAnalysisTask *RegisterTaskPID2(Bool_t useMC, Bool_t isAOD, Int_t tpcCls=120, Int_t tpcClsPID = 80, Int_t itsCls=4, Double_t dcaxy=1.0, Double_t dcaz=2.0, Double_t tpcs=-0.0113, Double_t tpcu=3.09, Double_t tofs=3., Int_t tofm=0, Int_t itshitpixel = AliHFEextraCuts::kBoth, Bool_t withetacorrection = kTRUE, Int_t TRDtrigger=0){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/pPb/ConfigHFEmbpPb.C"); AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); AliAnalysisTaskHFE *task = ConfigHFEmbpPb(useMC, isAOD, tpcCls, tpcClsPID, itsCls, dcaxy, dcaz, tpcs,tpcu,tofs,tofm,3.,kFALSE,kTRUE,kFALSE,itshitpixel,withetacorrection,0,TRDtrigger); if(isAOD) task->SetAODAnalysis(); else task->SetESDAnalysis(); if (useMC) task->SetHasMCData(kTRUE); else{ task->SetHasMCData(kFALSE); } if(TRDtrigger<2) task->SelectCollisionCandidates(AliVEvent::kINT7); else task->SelectCollisionCandidates(AliVEvent::kTRD); Int_t idcaxy = (Int_t)(dcaxy*10.); Int_t idcaz = (Int_t)(dcaz*10.); Int_t itpcs = (Int_t)(tpcs*1000.); Int_t itofs = (Int_t)(tofs*10.); Int_t ipixelany = itshitpixel; Int_t ietacorr = 0; if(withetacorrection) ietacorr = 1; TString appendix(TString::Format("mbTPCc%dTPCp%dITS%dDCAr%dz%dTPCs%dTOFs%dm%ipa%dtrdt%d",tpcCls, tpcClsPID,itsCls,idcaxy,idcaz,itpcs,itofs,tofm,ipixelany,TRDtrigger)); printf("Add macro appendix %s\n", appendix.Data()); TString containerName = mgr->GetCommonFileName(); containerName += ":HFEtask"; containerName += appendix.Data(); printf("container name: %s\n", containerName.Data()); //create data containers task->ConnectOutput(1, mgr->CreateContainer(Form("HFE_Results_%s", appendix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, containerName.Data())); task->ConnectOutput(2, mgr->CreateContainer(Form("HFE_QA_%s", appendix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, containerName.Data())); mgr->ConnectInput(task, 0, cinput ); mgr->AddTask(task); return NULL; }