[u/mrichter/AliRoot.git] / PWG0 / dNdEta / run.C

void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE, Bool_t mc = kTRUE, const char* option = "")
{
  if (aProof)
  {
    TProof::Open("lxb6046");

    // Enable the needed package
    gProof->UploadPackage("STEERBase");
    gProof->EnablePackage("STEERBase");
    gProof->UploadPackage("ESD");
    gProof->EnablePackage("ESD");
    gProof->UploadPackage("AOD");
    gProof->EnablePackage("AOD");
    gProof->UploadPackage("ANALYSIS");
    gProof->EnablePackage("ANALYSIS");
    gProof->UploadPackage("PWG0base");
    gProof->EnablePackage("PWG0base");
  }
  else
  {
    gSystem->Load("libVMC");
    gSystem->Load("libTree");
    gSystem->Load("libSTEERBase");
    gSystem->Load("libESD");
    gSystem->Load("libANALYSIS");
    gSystem->Load("libPWG0base");
  }

  // Create chain of input files
  gROOT->LoadMacro("../CreateESDChain.C");
  chain = CreateESDChain(data, nRuns, offset);

  // Create the analysis manager
  mgr = new AliAnalysisManager;

  TString taskName("AlidNdEtaTask.cxx+");
  if (aDebug)
    taskName += "+g";

  // Create, add task
  if (aProof) {
    gProof->Load(taskName);
  } else
    gROOT->Macro(taskName);

  task = new AlidNdEtaTask(option);

  AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC;
  task->SetAnalysisMode(analysisMode);

  if (analysisMode != AliPWG0Helper::kSPD)
  {
    // selection of esd tracks
    gROOT->ProcessLine(".L ../CreateStandardCuts.C");
    AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
    if (!esdTrackCuts)
    {
      printf("ERROR: esdTrackCuts could not be created\n");
      return;
    }

    task->SetTrackCuts(esdTrackCuts);
  }

  if (mc)
    task->SetReadMC();

  //task->SetUseMCVertex();

  mgr->AddTask(task);

  if (mc) {
    // Enable MC event handler
    AliMCEventHandler* handler = new AliMCEventHandler;
    handler->SetReadTR(kFALSE);
    mgr->SetMCtruthEventHandler(handler);
  }

  // Add ESD handler
  AliESDInputHandler* esdH = new AliESDInputHandler;
  mgr->SetInputEventHandler(esdH);

  // Attach input
  cInput  = mgr->CreateContainer("cInput", TChain::Class(), AliAnalysisManager::kInputContainer);
  mgr->ConnectInput(task, 0, cInput);

  // Attach output
  cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer);
  mgr->ConnectOutput(task, 0, cOutput);

  // Enable debug printouts
  if (aDebug)
    mgr->SetDebugLevel(2);

  // Run analysis
  mgr->InitAnalysis();
  mgr->PrintStatus();

  mgr->StartAnalysis((aProof) ? "proof" : "local", chain);
}

void loadlibs()
{
  gSystem->Load("libTree");
  gSystem->Load("libVMC");

  gSystem->Load("libSTEERBase");
  gSystem->Load("libANALYSIS");
  gSystem->Load("libPWG0base");
}

void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const char* dataOutput = "analysis_esd.root", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction")
{
  loadlibs();

  AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(correctionMapFolder, correctionMapFolder);
  TFile::Open(correctionMapFile);
  dNdEtaCorrection->LoadHistograms();

  TFile* file = TFile::Open(dataInput);

  if (!file)
  {
    cout << "Error. File not found" << endl;
    return;
  }

  dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
  fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL, 1);
  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
  TFile* file2 = TFile::Open(dataOutput, "RECREATE");
  fdNdEtaAnalysis->SaveHistograms();

  file->cd();
  fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
  fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco, 1);
  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
  file2->cd();
  fdNdEtaAnalysis->SaveHistograms();

  file->cd();
  fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
  fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle, 1);
  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
  file2->cd();
  fdNdEtaAnalysis->SaveHistograms();

  file->cd();
  fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
  fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
  file2->cd();
  fdNdEtaAnalysis->SaveHistograms();

  file2->Write();
  file2->Close();
}

void* FinishAnalysis(const char* analysisFile = "analysis_esd_raw.root", const char* analysisDir = "fdNdEtaAnalysisESD", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction", Bool_t useUncorrected = kFALSE, Bool_t simple = kFALSE)
{
  loadlibs();

  TFile* file = TFile::Open(analysisFile);

  dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis(analysisDir, analysisDir);
  fdNdEtaAnalysis->LoadHistograms();

  if (correctionMapFile)
  {
    AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(correctionMapFolder, correctionMapFolder);
    TFile::Open(correctionMapFile);
    dNdEtaCorrection->LoadHistograms();

    fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL);
    //fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0, AlidNdEtaCorrection::kINEL);
    //fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0, AlidNdEtaCorrection::kTrack2Particle);
  }
  else
    fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);

  fdNdEtaAnalysis->DrawHistograms(simple);

  TH1* hist = fdNdEtaAnalysis->GetdNdEtaHistogram(1);
  Int_t binLeft = hist->GetXaxis()->FindBin(-0.5);
  Int_t binRight = hist->GetXaxis()->FindBin(0.5);
  Float_t value1 = hist->Integral(binLeft, binRight);

  hist = fdNdEtaAnalysis->GetdNdEtaHistogram(2);
  Float_t value2 = hist->Integral(binLeft, binRight);

  if (value2 > 0)
    printf("Ratio is %f, values are %f %f\n", value1 / value2, value1, value2);

  return fdNdEtaAnalysis;
}
Commit	Line	Data
0f67a57c	1	void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE, Bool_t mc = kTRUE, const char* option = "")
	2	{
	3	if (aProof)
	4	{
	5	TProof::Open("lxb6046");
	6
	7	// Enable the needed package
	8	gProof->UploadPackage("STEERBase");
	9	gProof->EnablePackage("STEERBase");
	10	gProof->UploadPackage("ESD");
	11	gProof->EnablePackage("ESD");
144ff489	12	gProof->UploadPackage("AOD");
144ff489	13	gProof->EnablePackage("AOD");
0f67a57c	14	gProof->UploadPackage("ANALYSIS");
	15	gProof->EnablePackage("ANALYSIS");
	16	gProof->UploadPackage("PWG0base");
	17	gProof->EnablePackage("PWG0base");
	18	}
	19	else
	20	{
	21	gSystem->Load("libVMC");
	22	gSystem->Load("libTree");
	23	gSystem->Load("libSTEERBase");
	24	gSystem->Load("libESD");
	25	gSystem->Load("libANALYSIS");
	26	gSystem->Load("libPWG0base");
	27	}
	28
	29	// Create chain of input files
	30	gROOT->LoadMacro("../CreateESDChain.C");
	31	chain = CreateESDChain(data, nRuns, offset);
	32
	33	// Create the analysis manager
	34	mgr = new AliAnalysisManager;
	35
0f67a57c	36	TString taskName("AlidNdEtaTask.cxx+");
	37	if (aDebug)
	38	taskName += "+g";
	39
	40	// Create, add task
	41	if (aProof) {
	42	gProof->Load(taskName);
	43	} else
	44	gROOT->Macro(taskName);
	45
	46	task = new AlidNdEtaTask(option);
770a1f1d	47
	48	AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC;
	49	task->SetAnalysisMode(analysisMode);
	50
	51	if (analysisMode != AliPWG0Helper::kSPD)
	52	{
	53	// selection of esd tracks
	54	gROOT->ProcessLine(".L ../CreateStandardCuts.C");
	55	AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
	56	if (!esdTrackCuts)
	57	{
	58	printf("ERROR: esdTrackCuts could not be created\n");
	59	return;
	60	}
	61
	62	task->SetTrackCuts(esdTrackCuts);
	63	}
0f67a57c	64
	65	if (mc)
	66	task->SetReadMC();
	67
7307d52c	68	//task->SetUseMCVertex();
7307d52c	69
0f67a57c	70	mgr->AddTask(task);
	71
	72	if (mc) {
	73	// Enable MC event handler
	74	AliMCEventHandler* handler = new AliMCEventHandler;
	75	handler->SetReadTR(kFALSE);
	76	mgr->SetMCtruthEventHandler(handler);
	77	}
	78
	79	// Add ESD handler
	80	AliESDInputHandler* esdH = new AliESDInputHandler;
	81	mgr->SetInputEventHandler(esdH);
	82
	83	// Attach input
	84	cInput = mgr->CreateContainer("cInput", TChain::Class(), AliAnalysisManager::kInputContainer);
	85	mgr->ConnectInput(task, 0, cInput);
	86
	87	// Attach output
	88	cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer);
	89	mgr->ConnectOutput(task, 0, cOutput);
	90
	91	// Enable debug printouts
	92	if (aDebug)
	93	mgr->SetDebugLevel(2);
	94
	95	// Run analysis
	96	mgr->InitAnalysis();
	97	mgr->PrintStatus();
	98
	99	mgr->StartAnalysis((aProof) ? "proof" : "local", chain);
	100	}
dd367a14	101
	102	void loadlibs()
	103	{
	104	gSystem->Load("libTree");
	105	gSystem->Load("libVMC");
	106
	107	gSystem->Load("libSTEERBase");
	108	gSystem->Load("libANALYSIS");
	109	gSystem->Load("libPWG0base");
	110	}
	111
	112	void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const char* dataOutput = "analysis_esd.root", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction")
	113	{
	114	loadlibs();
	115
	116	AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(correctionMapFolder, correctionMapFolder);
	117	TFile::Open(correctionMapFile);
	118	dNdEtaCorrection->LoadHistograms();
	119
	120	TFile* file = TFile::Open(dataInput);
	121
	122	if (!file)
	123	{
	124	cout << "Error. File not found" << endl;
	125	return;
	126	}
	127
	128	dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
	129	fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
3dfa46a4	130	fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL, 1);
770a1f1d	131	//fdNdEtaAnalysis->DrawHistograms(kTRUE);
dd367a14	132	TFile* file2 = TFile::Open(dataOutput, "RECREATE");
	133	fdNdEtaAnalysis->SaveHistograms();
	134
	135	file->cd();
	136	fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
	137	fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
3dfa46a4	138	fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco, 1);
770a1f1d	139	//fdNdEtaAnalysis->DrawHistograms(kTRUE);
dd367a14	140	file2->cd();
	141	fdNdEtaAnalysis->SaveHistograms();
	142
	143	file->cd();
	144	fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
	145	fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
3dfa46a4	146	fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle, 1);
770a1f1d	147	//fdNdEtaAnalysis->DrawHistograms(kTRUE);
dd367a14	148	file2->cd();
	149	fdNdEtaAnalysis->SaveHistograms();
	150
	151	file->cd();
	152	fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
	153	fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
3dfa46a4	154	fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
770a1f1d	155	//fdNdEtaAnalysis->DrawHistograms(kTRUE);
dd367a14	156	file2->cd();
dd367a14	157	fdNdEtaAnalysis->SaveHistograms();
9c4cc5e7	158
	159	file2->Write();
	160	file2->Close();
dd367a14	161	}
	162
	163	void* FinishAnalysis(const char* analysisFile = "analysis_esd_raw.root", const char* analysisDir = "fdNdEtaAnalysisESD", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction", Bool_t useUncorrected = kFALSE, Bool_t simple = kFALSE)
	164	{
	165	loadlibs();
	166
	167	TFile* file = TFile::Open(analysisFile);
	168
	169	dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis(analysisDir, analysisDir);
	170	fdNdEtaAnalysis->LoadHistograms();
	171
	172	if (correctionMapFile)
	173	{
	174	AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(correctionMapFolder, correctionMapFolder);
	175	TFile::Open(correctionMapFile);
	176	dNdEtaCorrection->LoadHistograms();
	177
	178	fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL);
	179	//fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0, AlidNdEtaCorrection::kINEL);
	180	//fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0, AlidNdEtaCorrection::kTrack2Particle);
	181	}
	182	else
3dfa46a4	183	fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
dd367a14	184
	185	fdNdEtaAnalysis->DrawHistograms(simple);
	186
	187	TH1* hist = fdNdEtaAnalysis->GetdNdEtaHistogram(1);
	188	Int_t binLeft = hist->GetXaxis()->FindBin(-0.5);
	189	Int_t binRight = hist->GetXaxis()->FindBin(0.5);
	190	Float_t value1 = hist->Integral(binLeft, binRight);
	191
	192	hist = fdNdEtaAnalysis->GetdNdEtaHistogram(2);
	193	Float_t value2 = hist->Integral(binLeft, binRight);
	194
	195	if (value2 > 0)
	196	printf("Ratio is %f, values are %f %f\n", value1 / value2, value1, value2);
	197
	198	return fdNdEtaAnalysis;
	199	}