/**
* 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;
}
