[u/mrichter/AliRoot.git] / PWG / muon / runMuMu.C

///
/// Example macro to run the AliAnalysisTaskMuMu task
///
/// \author L. Aphecetche
///

//______________________________________________________________________________
void LoadLocalLibs(Bool_t localAnalysis=kTRUE)
{
  gSystem->Load("libVMC");
  gSystem->Load("libMinuit");
  gSystem->Load("libTree");
  gSystem->Load("libProofPlayer");
  gSystem->Load("libXMLParser");
  gSystem->Load("libSTEERBase");
  gSystem->Load("libESD");
  gSystem->Load("libAOD");
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");

  if (!localAnalysis)
  {
    gSystem->Load("libCORRFW");
  }
  else
  {
  	gROOT->LoadMacro("AliOADBMuonTrackCutsParam.cxx+g");
  	gROOT->LoadMacro("AliAnalysisMuonUtility.cxx+g");
  	gROOT->LoadMacro("AliMuonTrackCuts.cxx+g");
  	gROOT->LoadMacro("AliMergeableCollection.cxx+g");
  	gROOT->LoadMacro("AliAnalysisMuMuBinning.cxx+g");
  	gROOT->LoadMacro("AliMuonEventCuts.cxx+g");
    
    gROOT->LoadMacro("AliAnalysisMuMuCutElement.cxx+g");
    gROOT->LoadMacro("AliAnalysisMuMuCutCombination.cxx+g");
    gROOT->LoadMacro("AliAnalysisMuMuCutRegistry.cxx+g");
    gROOT->LoadMacro("AliAnalysisMuMuEventCutter.cxx+g");
    gROOT->LoadMacro("AliAnalysisMuMuBase.cxx+g");

    gROOT->LoadMacro("AliAnalysisTaskMuMu.cxx+g");

    gROOT->LoadMacro("AliAnalysisMuMuGlobal.cxx+g");

    gROOT->LoadMacro("AliAnalysisMuMuMinv.cxx+g");
    gROOT->LoadMacro("AliAnalysisMuMuSingle.cxx+g");
    gROOT->LoadMacro("AliAnalysisMuMuNch.cxx+g");

  }
}

//______________________________________________________________________________
TChain* CreateLocalChain(const char* filelist)
{
	TChain* c = new TChain("aodTree");
	
	char line[1024];
	
	ifstream in(filelist);
	while ( in.getline(line,1024,'\n') )
	{
		c->Add(line);
	}
	return c;
}

//______________________________________________________________________________
TString GetInputType(const TString& sds, TProof* p)
{
   if (sds.Length()==0 ) return "AOD";

   if (sds.Contains("SIM_JPSI")) return "AOD";
   
   if (sds.Contains("AOD")) return "AOD";
   if (sds.Contains("ESD")) return "ESD";
   
   if ( gSystem->AccessPathName(gSystem->ExpandPathName(sds.Data())) )
   {
   	// dataset is not a local file so it must be a dataset name
   	if (!p) return "NOPROOF";
   	
   	TFileCollection* fc = p->GetDataSet(sds.Data());
    if (!fc) return "NODATASET";
    
    TIter next(fc->GetList());
    TFileInfo* fi;
    while ( ( fi = static_cast<TFileInfo*>(next()) ) )
    {
      TUrl url(*(fi->GetFirstUrl()));
	  TString surl(url.GetUrl());
	  
	  if (surl.Contains("AOD")) return "AOD";
	  if (surl.Contains("AliESD")) return "ESD";      
    }      

   }
   else
   {
   std::cout << "Will use datasets from file " << sds.Data() << std::endl;
   
   // dataset is a local text file containing a list of dataset names
   	std::ifstream in(sds.Data());
   	char line[1014];
   
   	while (in.getline(line,1023,'\n'))
   	{
    	  TString sline(line);
      	sline.ToUpper();
    	if ( sline.Contains("SIM_JPSI") ) return "AOD";
      	if ( sline.Contains("AOD") ) return "AOD";
      	if ( sline.Contains("ESD") ) return "ESD";
   	}
   }
   
   return "BUG";   
}

//______________________________________________________________________________
AliAnalysisTask* runMuMu(const char* dataset="SIM_JPSI_LHC13f_CynthiaTuneWithRejectList_000197388",
                         Bool_t simulations=kTRUE,
                         Bool_t baseline=kFALSE,
                         const char* where="laphecet@nansafmaster.in2p3.fr/?N")
{
  // Create the analysis manager
  
  Bool_t prooflite = (strlen(where)==0) || TString(where).Contains("workers");

  TString sds(dataset);
  
//  if (!prooflite && sds.Length()>0) TProof::Mgr(where)->SetROOTVersion("VO_ALICE@ROOT::v5-34-05");
  
  TProof* p(0x0);
  TString alirootMode("");
  TString workers("workers=8x");

  if (TString(where).Contains("alice-caf"))
  {
    workers="workers=1x";
  }
  if (TString(where).Contains("localhost:2093"))
  {
    workers="workers=8x";
  }
  
  if (prooflite)
  {
    cout << "Will work in LITE mode" << endl;
  }
  
  if ( sds.Length()>0 )
  {
    p = TProof::Open(where,workers.Data());
    
    if (!p)
    {
      cout << "Cannot connect to Proof : " << where << endl;
      return 0;
    }
    
    alirootMode.ToUpper();
    
    if ( alirootMode == "PAR" ) 
    {
      cout << "Will work with PAR files" << endl;
      
      std::vector<std::string> pars;
      
      pars.push_back("STEERBase");
      pars.push_back("ESD");
      pars.push_back("AOD");
      pars.push_back("ANALYSIS");
      pars.push_back("OADB");
      pars.push_back("ANALYSISalice");
      //       pars.push_back("CORRFW");
      //       pars.push_back("PWGmuon");
      
      Bool_t ok(kTRUE);
      
      for ( std::vector<std::string>::size_type i = 0; i < pars.size(); ++i )
      {
        std::string package = pars[i];
        
        if ( gProof->UploadPackage(package.c_str()) ) 
        {
          ok = kFALSE;
        }
        
        if ( gProof->EnablePackage(package.c_str(),"",kTRUE) ) 
        {
          ok = kFALSE;
        }
        
        if (!ok) 
        {
          cout << "Problem with PAR " << package.c_str() << endl;
          return 0;           
        }
      }
    }
    else 
    {
      TList* list = new TList();
      
      //       list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "PWG3base"));
      //       list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES", "PWG3"));
      //       list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "PWG3base"));//:CORRFW:PWG3muon"));
      //       list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES", "PWG3/base"));//:PWG3/muon"));
      
      //    list->Add(new TNamed("ALIROOT_ENABLE_ALIEN", "1"));
      
      if (!alirootMode.IsNull())
      {
        list->Add(new TNamed("ALIROOT_MODE", alirootMode.Data()));  
      }
      else
      {
        list->Add(new TNamed("ALIROOT_MODE",""));
      }
      
      if (!prooflite)
      {
//        p->SetParameter("PROOF_UseTreeCache", 0);
        p->EnablePackage("VO_ALICE@AliRoot::v5-04-65-AN", list, kTRUE);
      }
      else
      {
        //      list->Add(new TNamed("ALIROOT_LOCAL_PATH",gSystem->Getenv("ALICE_ROOT")));       
        p->UploadPackage("$ALICE_ROOT/ANALYSIS/macros/AliRootProofLite.par");
        if (p->EnablePackage("AliRootProofLite",list)) return 0;
      }
    }
    
    // compile task on workers
    if ( alirootMode != "PAR" )
    {
      p->Load("AliOADBMuonTrackCutsParam.cxx+");
      p->Load("AliAnalysisMuonUtility.cxx+");
      p->Load("AliMuonTrackCuts.cxx+");
      p->Load("AliMergeableCollection.cxx+");
      p->Load("AliAnalysisMuMuBinning.cxx+");
      p->Load("AliMuonEventCuts.cxx+");
       p->Load("AliAnalysisMuMuCutElement.cxx+");
       p->Load("AliAnalysisMuMuCutCombination.cxx+");       
       p->Load("AliAnalysisMuMuCutRegistry.cxx+");
      p->Load("AliAnalysisMuMuBase.cxx+");      
      p->Load("AliAnalysisTaskMuMu.cxx+");
       p->Load("AliAnalysisMuMuEventCutter.cxx+");       
     p->Load("AliAnalysisMuMuGlobal.cxx+");
     p->Load("AliAnalysisMuMuNch.cxx+");
     p->Load("AliAnalysisMuMuSingle.cxx+");
     p->Load("AliAnalysisMuMuMinv.cxx+");
	}
  }
  
  LoadLocalLibs(kTRUE);
  
  AliAnalysisManager *mgr = new AliAnalysisManager("MuMu");
  
  AliInputEventHandler* input(0x0);

  TString inputType = GetInputType(sds,p);
  
  if ( inputType == "AOD" ) 
  {
    input = new AliAODInputHandler;
  }
  else if ( inputType == "ESD" ) 
  {
    input = new AliESDInputHandler;
  }
  else
  {
  	std::cout << "Cannot get input type !" << std::endl;
  	return 0;
  }

  mgr->SetInputEventHandler(input);
  
  TList* triggers = new TList;
  triggers->SetOwner(kTRUE);

  if (!simulations)
  {
    triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD"));

//   triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MUL"));
//   triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MSL"));
//   triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MSH"));
//   triggers->Add(new TObjString("CMSL7-B-NOPF-MUON & 0MUL"));
//   triggers->Add(new TObjString("CMSL7-B-NOPF-MUON & 0MSH"));
// 
//   triggers->Add(new TObjString("CMSL7-B-NOPF-MUON"));
//   triggers->Add(new TObjString("CMSH7-B-NOPF-MUON"));
//    triggers->Add(new TObjString("CMUL7-B-NOPF-MUON"));
 
  // below for MB periods only
//  triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD"));
//   triggers->Add(new TObjString("CMSH7-B-NOPF-ALLNOTRD"));
  triggers->Add(new TObjString("CMUL7-B-NOPF-ALLNOTRD"));
  triggers->Add(new TObjString("CMUL7-B-NOPF-MUON"));
//   triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD & 0MUL"));
//   triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD & 0MSH"));
  }

  TString outputname("test.MuMu.AOD.1.root");
  
  if ( sds.Length()>0 ) 
  {
  	TString af("local");
  	
  	if ( gProof )
  	{
  	  af="unknown";
  	  TString master(gProof->GetSessionTag());
      if (master.Contains("lx")) af = "caf";
      if (master.Contains("nansaf")) af = "saf";
      if (master.Contains("skaf")) af = "skaf";
      if (master.Contains("localhost:2093")) af="laf";
  	}
  	outputname = Form("%s.%s.root",gSystem->BaseName(sds.Data()),af.Data());
    outputname.ReplaceAll("|","-");
  	cout << outputname << endl;
  }

  AliAnalysisTask* task(0x0);

  if (!baseline)
  {  
  	gROOT->LoadMacro("AddTaskMuMu.C");

  	task = AddTaskMuMu(outputname.Data(),triggers,"pA",simulations);
  }
  else
  {
  	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddTaskBaseLine.C");
  	task = AddTaskBaseLine();
  }
  
  if (!mgr->InitAnalysis()) 
  {
  	cout << "Could not InitAnalysis" << endl;
    return 0;
  }
  
  if ( sds.Length()>0 )
  {
    TStopwatch timer;
    
    mgr->StartAnalysis("proof",sds.Data());
    
    timer.Print();
  }
  else
  {
    mgr->PrintStatus();
  
   	task->Print();
	
//	return task;
	
    TChain* c = CreateLocalChain("list.aod.txt");
//   	mgr->SetNSysInfo(10);
    TStopwatch timer;
//    mgr->SetDebugLevel(10);
    mgr->StartAnalysis("local",c);
    timer.Print();
//    mgr->ProfileTask("AliAnalysisTaskMuMu");
//    if (baseline) mgr->ProfileTask("baseline");
  }
  
  AliCodeTimer::Instance()->Print();
  
  if (alirootMode=="PAR")
  {
    TProofLog *pl = TProof::Mgr(where)->GetSessionLogs(); pl->Save("*","aod.log");
  }
  
  delete triggers;
  
  return task;
}
Commit	Line	Data
5376e016 CP	1	///
	2	/// Example macro to run the AliAnalysisTaskMuMu task
	3	///
	4	/// \author L. Aphecetche
	5	///
	6
	7	//______________________________________________________________________________
	8	void LoadLocalLibs(Bool_t localAnalysis=kTRUE)
	9	{
	10	gSystem->Load("libVMC");
	11	gSystem->Load("libMinuit");
	12	gSystem->Load("libTree");
	13	gSystem->Load("libProofPlayer");
	14	gSystem->Load("libXMLParser");
	15	gSystem->Load("libSTEERBase");
	16	gSystem->Load("libESD");
	17	gSystem->Load("libAOD");
	18	gSystem->Load("libANALYSIS");
	19	gSystem->Load("libANALYSISalice");
	20
	21	if (!localAnalysis)
	22	{
	23	gSystem->Load("libCORRFW");
	24	}
	25	else
	26	{
	27	gROOT->LoadMacro("AliOADBMuonTrackCutsParam.cxx+g");
	28	gROOT->LoadMacro("AliAnalysisMuonUtility.cxx+g");
	29	gROOT->LoadMacro("AliMuonTrackCuts.cxx+g");
	30	gROOT->LoadMacro("AliMergeableCollection.cxx+g");
	31	gROOT->LoadMacro("AliAnalysisMuMuBinning.cxx+g");
	32	gROOT->LoadMacro("AliMuonEventCuts.cxx+g");
	33
	34	gROOT->LoadMacro("AliAnalysisMuMuCutElement.cxx+g");
	35	gROOT->LoadMacro("AliAnalysisMuMuCutCombination.cxx+g");
	36	gROOT->LoadMacro("AliAnalysisMuMuCutRegistry.cxx+g");
	37	gROOT->LoadMacro("AliAnalysisMuMuEventCutter.cxx+g");
	38	gROOT->LoadMacro("AliAnalysisMuMuBase.cxx+g");
	39
	40	gROOT->LoadMacro("AliAnalysisTaskMuMu.cxx+g");
	41
	42	gROOT->LoadMacro("AliAnalysisMuMuGlobal.cxx+g");
	43
	44	gROOT->LoadMacro("AliAnalysisMuMuMinv.cxx+g");
	45	gROOT->LoadMacro("AliAnalysisMuMuSingle.cxx+g");
	46	gROOT->LoadMacro("AliAnalysisMuMuNch.cxx+g");
	47
	48	}
	49	}
	50
	51	//______________________________________________________________________________
	52	TChain* CreateLocalChain(const char* filelist)
	53	{
	54	TChain* c = new TChain("aodTree");
	55
	56	char line[1024];
	57
	58	ifstream in(filelist);
	59	while ( in.getline(line,1024,'\n') )
	60	{
	61	c->Add(line);
	62	}
	63	return c;
	64	}
65
66	//______________________________________________________________________________
67	TString GetInputType(const TString& sds, TProof* p)
68	{
69	if (sds.Length()==0 ) return "AOD";
70
71	if (sds.Contains("SIM_JPSI")) return "AOD";
72
73	if (sds.Contains("AOD")) return "AOD";
74	if (sds.Contains("ESD")) return "ESD";
75
76	if ( gSystem->AccessPathName(gSystem->ExpandPathName(sds.Data())) )
77	{
78	// dataset is not a local file so it must be a dataset name
79	if (!p) return "NOPROOF";
80
81	TFileCollection* fc = p->GetDataSet(sds.Data());
82	if (!fc) return "NODATASET";
83
84	TIter next(fc->GetList());
85	TFileInfo* fi;
86	while ( ( fi = static_cast<TFileInfo*>(next()) ) )
87	{
88	TUrl url(*(fi->GetFirstUrl()));
89	TString surl(url.GetUrl());
90
91	if (surl.Contains("AOD")) return "AOD";
92	if (surl.Contains("AliESD")) return "ESD";
93	}
94
95	}
96	else
97	{
98	std::cout << "Will use datasets from file " << sds.Data() << std::endl;
99
100	// dataset is a local text file containing a list of dataset names
101	std::ifstream in(sds.Data());
102	char line[1014];
103
104	while (in.getline(line,1023,'\n'))
105	{
106	TString sline(line);
107	sline.ToUpper();
108	if ( sline.Contains("SIM_JPSI") ) return "AOD";
109	if ( sline.Contains("AOD") ) return "AOD";
110	if ( sline.Contains("ESD") ) return "ESD";
111	}
112	}
113
114	return "BUG";
115	}
116
117	//______________________________________________________________________________
118	AliAnalysisTask* runMuMu(const char* dataset="SIM_JPSI_LHC13f_CynthiaTuneWithRejectList_000197388",
119	Bool_t simulations=kTRUE,
120	Bool_t baseline=kFALSE,
121	const char* where="laphecet@nansafmaster.in2p3.fr/?N")
122	{
123	// Create the analysis manager
124
125	Bool_t prooflite = (strlen(where)==0) \|\| TString(where).Contains("workers");
126
127	TString sds(dataset);
128
129	// if (!prooflite && sds.Length()>0) TProof::Mgr(where)->SetROOTVersion("VO_ALICE@ROOT::v5-34-05");
130
131	TProof* p(0x0);
132	TString alirootMode("");
133	TString workers("workers=8x");
134
135	if (TString(where).Contains("alice-caf"))
136	{
137	workers="workers=1x";
138	}
139	if (TString(where).Contains("localhost:2093"))
140	{
141	workers="workers=8x";
142	}
143
144	if (prooflite)
145	{
146	cout << "Will work in LITE mode" << endl;
147	}
148
149	if ( sds.Length()>0 )
150	{
151	p = TProof::Open(where,workers.Data());
152
153	if (!p)
154	{
155	cout << "Cannot connect to Proof : " << where << endl;
156	return 0;
157	}
158
159	alirootMode.ToUpper();
160
161	if ( alirootMode == "PAR" )
162	{
163	cout << "Will work with PAR files" << endl;
164
165	std::vector<std::string> pars;
166
167	pars.push_back("STEERBase");
168	pars.push_back("ESD");
169	pars.push_back("AOD");
170	pars.push_back("ANALYSIS");
171	pars.push_back("OADB");
172	pars.push_back("ANALYSISalice");
173	// pars.push_back("CORRFW");
174	// pars.push_back("PWGmuon");
175
176	Bool_t ok(kTRUE);
177
178	for ( std::vector<std::string>::size_type i = 0; i < pars.size(); ++i )
179	{
180	std::string package = pars[i];
181
182	if ( gProof->UploadPackage(package.c_str()) )
183	{
184	ok = kFALSE;
185	}
186
187	if ( gProof->EnablePackage(package.c_str(),"",kTRUE) )
188	{
189	ok = kFALSE;
190	}
191
192	if (!ok)
193	{
194	cout << "Problem with PAR " << package.c_str() << endl;
195	return 0;
196	}
197	}
198	}
199	else
200	{
201	TList* list = new TList();
202
203	// list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "PWG3base"));
204	// list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES", "PWG3"));
205	// list->Add(new TNamed("ALIROOT_EXTRA_LIBS", "PWG3base"));//:CORRFW:PWG3muon"));
206	// list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES", "PWG3/base"));//:PWG3/muon"));
207
208	// list->Add(new TNamed("ALIROOT_ENABLE_ALIEN", "1"));
209
210	if (!alirootMode.IsNull())
211	{
212	list->Add(new TNamed("ALIROOT_MODE", alirootMode.Data()));
213	}
214	else
215	{
216	list->Add(new TNamed("ALIROOT_MODE",""));
217	}
218
219	if (!prooflite)
220	{
221	// p->SetParameter("PROOF_UseTreeCache", 0);
222	p->EnablePackage("VO_ALICE@AliRoot::v5-04-65-AN", list, kTRUE);
223	}
224	else
225	{
226	// list->Add(new TNamed("ALIROOT_LOCAL_PATH",gSystem->Getenv("ALICE_ROOT")));
227	p->UploadPackage("$ALICE_ROOT/ANALYSIS/macros/AliRootProofLite.par");
228	if (p->EnablePackage("AliRootProofLite",list)) return 0;
229	}
230	}
231
232	// compile task on workers
233	if ( alirootMode != "PAR" )
234	{
235	p->Load("AliOADBMuonTrackCutsParam.cxx+");
236	p->Load("AliAnalysisMuonUtility.cxx+");
237	p->Load("AliMuonTrackCuts.cxx+");
238	p->Load("AliMergeableCollection.cxx+");
239	p->Load("AliAnalysisMuMuBinning.cxx+");
240	p->Load("AliMuonEventCuts.cxx+");
241	p->Load("AliAnalysisMuMuCutElement.cxx+");
242	p->Load("AliAnalysisMuMuCutCombination.cxx+");
243	p->Load("AliAnalysisMuMuCutRegistry.cxx+");
244	p->Load("AliAnalysisMuMuBase.cxx+");
245	p->Load("AliAnalysisTaskMuMu.cxx+");
246	p->Load("AliAnalysisMuMuEventCutter.cxx+");
247	p->Load("AliAnalysisMuMuGlobal.cxx+");
248	p->Load("AliAnalysisMuMuNch.cxx+");
249	p->Load("AliAnalysisMuMuSingle.cxx+");
250	p->Load("AliAnalysisMuMuMinv.cxx+");
251	}
252	}
253
254	LoadLocalLibs(kTRUE);
255
256	AliAnalysisManager *mgr = new AliAnalysisManager("MuMu");
257
258	AliInputEventHandler* input(0x0);
259
260	TString inputType = GetInputType(sds,p);
261
262	if ( inputType == "AOD" )
263	{
264	input = new AliAODInputHandler;
265	}
266	else if ( inputType == "ESD" )
267	{
268	input = new AliESDInputHandler;
269	}
270	else
271	{
272	std::cout << "Cannot get input type !" << std::endl;
273	return 0;
274	}
275
276	mgr->SetInputEventHandler(input);
277
278	TList* triggers = new TList;
279	triggers->SetOwner(kTRUE);
280
281	if (!simulations)
282	{
283	triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD"));
284
285	// triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MUL"));
286	// triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MSL"));
287	// triggers->Add(new TObjString("CINT7-B-NOPF-ALLNOTRD & 0MSH"));
288	// triggers->Add(new TObjString("CMSL7-B-NOPF-MUON & 0MUL"));
289	// triggers->Add(new TObjString("CMSL7-B-NOPF-MUON & 0MSH"));
290	//
291	// triggers->Add(new TObjString("CMSL7-B-NOPF-MUON"));
292	// triggers->Add(new TObjString("CMSH7-B-NOPF-MUON"));
293	// triggers->Add(new TObjString("CMUL7-B-NOPF-MUON"));
294
295	// below for MB periods only
296	// triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD"));
297	// triggers->Add(new TObjString("CMSH7-B-NOPF-ALLNOTRD"));
298	triggers->Add(new TObjString("CMUL7-B-NOPF-ALLNOTRD"));
299	triggers->Add(new TObjString("CMUL7-B-NOPF-MUON"));
300	// triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD & 0MUL"));
301	// triggers->Add(new TObjString("CMSL7-B-NOPF-ALLNOTRD & 0MSH"));
302	}
303
304	TString outputname("test.MuMu.AOD.1.root");
305
306	if ( sds.Length()>0 )
307	{
308	TString af("local");
309
310	if ( gProof )
311	{
312	af="unknown";
313	TString master(gProof->GetSessionTag());
314	if (master.Contains("lx")) af = "caf";
315	if (master.Contains("nansaf")) af = "saf";
316	if (master.Contains("skaf")) af = "skaf";
317	if (master.Contains("localhost:2093")) af="laf";
318	}
319	outputname = Form("%s.%s.root",gSystem->BaseName(sds.Data()),af.Data());
320	outputname.ReplaceAll("\|","-");
321	cout << outputname << endl;
322	}
323
324	AliAnalysisTask* task(0x0);
325
326	if (!baseline)
327	{
328	gROOT->LoadMacro("AddTaskMuMu.C");
329
330	task = AddTaskMuMu(outputname.Data(),triggers,"pA",simulations);
331	}
332	else
333	{
334	gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/train/AddTaskBaseLine.C");
335	task = AddTaskBaseLine();
336	}
337
338	if (!mgr->InitAnalysis())
339	{
340	cout << "Could not InitAnalysis" << endl;
341	return 0;
342	}
343
344	if ( sds.Length()>0 )
345	{
346	TStopwatch timer;
347
348	mgr->StartAnalysis("proof",sds.Data());
349
350	timer.Print();
351	}
352	else
353	{
354	mgr->PrintStatus();
355
356	task->Print();
357
358	// return task;
359
360	TChain* c = CreateLocalChain("list.aod.txt");
361	// mgr->SetNSysInfo(10);
362	TStopwatch timer;
363	// mgr->SetDebugLevel(10);
364	mgr->StartAnalysis("local",c);
365	timer.Print();
366	// mgr->ProfileTask("AliAnalysisTaskMuMu");
367	// if (baseline) mgr->ProfileTask("baseline");
368	}
369
370	AliCodeTimer::Instance()->Print();
371
372	if (alirootMode=="PAR")
373	{
374	TProofLog pl = TProof::Mgr(where)->GetSessionLogs(); pl->Save("","aod.log");
375	}
376
377	delete triggers;
378
379	return task;
380	}
381