[u/mrichter/AliRoot.git] / PWG0 / dNdEta / AlidNdEtaCorrection.cxx

/* $Id$ */

#include "AlidNdEtaCorrection.h"

#include <AliLog.h>
#include <TCanvas.h>
#include <TH3F.h>
#include <TH1D.h>
#include <AliCorrection.h>
#include <AliCorrectionMatrix2D.h>
#include <AliCorrectionMatrix3D.h>

//____________________________________________________________________
ClassImp(AlidNdEtaCorrection)

//____________________________________________________________________
AlidNdEtaCorrection::AlidNdEtaCorrection()
  : TNamed(),
  fTrack2ParticleCorrection(0),
  fVertexRecoCorrection(0),
  fTriggerBiasCorrectionMBToINEL(0),
  fTriggerBiasCorrectionMBToNSD(0),
  fTriggerBiasCorrectionMBToND(0)
{
  // default constructor
}

//____________________________________________________________________
AlidNdEtaCorrection::AlidNdEtaCorrection(const Char_t* name, const Char_t* title)
  : TNamed(name, title),
  fTrack2ParticleCorrection(0),
  fVertexRecoCorrection(0),
  fTriggerBiasCorrectionMBToINEL(0),
  fTriggerBiasCorrectionMBToNSD(0),
  fTriggerBiasCorrectionMBToND(0)
{
  //
  // constructor
  //

  fTrack2ParticleCorrection = new AliCorrection("Track2Particle", "Track2Particle");
  fVertexRecoCorrection     = new AliCorrection("VertexReconstruction", "VertexReconstruction");

  fTriggerBiasCorrectionMBToINEL = new AliCorrection("TriggerBias_MBToINEL", "TriggerBias_MBToINEL");
  fTriggerBiasCorrectionMBToNSD  = new AliCorrection("TriggerBias_MBToNSD", "TriggerBias_MBToNSD");
  fTriggerBiasCorrectionMBToND   = new AliCorrection("TriggerBias_MBToND", "TriggerBias_MBToND");
}

//____________________________________________________________________
AlidNdEtaCorrection::~AlidNdEtaCorrection()
{
  // destructor

  if (fTrack2ParticleCorrection) {
    delete fTrack2ParticleCorrection;
    fTrack2ParticleCorrection = 0;
  }

  if (fVertexRecoCorrection) {
    delete fVertexRecoCorrection;
    fVertexRecoCorrection = 0;
  }

  if (fTriggerBiasCorrectionMBToINEL) {
    delete fTriggerBiasCorrectionMBToINEL;
    fTriggerBiasCorrectionMBToINEL = 0;
  }

  if (fTriggerBiasCorrectionMBToNSD) {
    delete fTriggerBiasCorrectionMBToNSD;
    fTriggerBiasCorrectionMBToNSD = 0;
  }

  if (fTriggerBiasCorrectionMBToND) {
    delete fTriggerBiasCorrectionMBToND;
    fTriggerBiasCorrectionMBToND = 0;
  }
}

//____________________________________________________________________
void
AlidNdEtaCorrection::Finish() {
  //
  // finish method
  //
  // divide the histograms in the AliCorrectionMatrix2D objects to get the corrections

  fTrack2ParticleCorrection->Divide();
  fVertexRecoCorrection->Divide();
  fTriggerBiasCorrectionMBToINEL->Divide();
  fTriggerBiasCorrectionMBToNSD->Divide();
  fTriggerBiasCorrectionMBToND->Divide();
}

//____________________________________________________________________
Long64_t AlidNdEtaCorrection::Merge(TCollection* list)
{
  // Merge a list of dNdEtaCorrection objects with this (needed for
  // PROOF).
  // Returns the number of merged objects (including this).

  if (!list)
    return 0;

  if (list->IsEmpty())
    return 1;

  TIterator* iter = list->MakeIterator();
  TObject* obj;

  // collections of measured and generated histograms
  TList* collectionNtrackToNparticle    = new TList;
  TList* collectionVertexReco           = new TList;
  TList* collectionTriggerBiasMBToINEL  = new TList;
  TList* collectionTriggerBiasMBToNSD   = new TList;
  TList* collectionTriggerBiasMBToND    = new TList;

  Int_t count = 0;
  while ((obj = iter->Next())) {

    AlidNdEtaCorrection* entry = dynamic_cast<AlidNdEtaCorrection*> (obj);
    if (entry == 0)
      continue;

    collectionNtrackToNparticle  ->Add(entry->fTrack2ParticleCorrection);
    collectionVertexReco         ->Add(entry->fVertexRecoCorrection);
    collectionTriggerBiasMBToINEL->Add(entry->fTriggerBiasCorrectionMBToINEL);
    collectionTriggerBiasMBToNSD ->Add(entry->fTriggerBiasCorrectionMBToNSD);
    collectionTriggerBiasMBToND  ->Add(entry->fTriggerBiasCorrectionMBToND);

    count++;
  }
  fTrack2ParticleCorrection      ->Merge(collectionNtrackToNparticle);
  fVertexRecoCorrection          ->Merge(collectionVertexReco);
  fTriggerBiasCorrectionMBToINEL ->Merge(collectionTriggerBiasMBToINEL);
  fTriggerBiasCorrectionMBToNSD  ->Merge(collectionTriggerBiasMBToNSD);
  fTriggerBiasCorrectionMBToND   ->Merge(collectionTriggerBiasMBToND);

  delete collectionNtrackToNparticle;
  delete collectionVertexReco;
  delete collectionTriggerBiasMBToINEL;
  delete collectionTriggerBiasMBToNSD;
  delete collectionTriggerBiasMBToND;

  return count+1;
}

//____________________________________________________________________
void AlidNdEtaCorrection::Add(AlidNdEtaCorrection* aCorrectionsToAdd, Float_t c) {
  //
  // adds the measured and generated of aCorrectionsToAdd to measured and generated
  // of all corrections in this

  fTrack2ParticleCorrection      ->Add(aCorrectionsToAdd->GetTrack2ParticleCorrection() ,c);
  fVertexRecoCorrection          ->Add(aCorrectionsToAdd->GetVertexRecoCorrection()     ,c);
  fTriggerBiasCorrectionMBToINEL ->Add(aCorrectionsToAdd->GetTriggerBiasCorrectionINEL(),c);
  fTriggerBiasCorrectionMBToNSD  ->Add(aCorrectionsToAdd->GetTriggerBiasCorrectionNSD() ,c);
  fTriggerBiasCorrectionMBToND   ->Add(aCorrectionsToAdd->GetTriggerBiasCorrectionND()  ,c);
    
}

//____________________________________________________________________
void AlidNdEtaCorrection::Reset(void) {
  //
  // reset all corrections
  // 

  fTrack2ParticleCorrection      ->Reset();
  fVertexRecoCorrection          ->Reset();
  fTriggerBiasCorrectionMBToINEL ->Reset();
  fTriggerBiasCorrectionMBToNSD  ->Reset();
  fTriggerBiasCorrectionMBToND   ->Reset();
    
}


//____________________________________________________________________
Bool_t AlidNdEtaCorrection::LoadHistograms(const Char_t* dir)
{
  //
  // loads the histograms
  // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
  //

  if (!dir)
    dir = GetName();

  if (!gDirectory->cd(dir))
    return kFALSE;

  fTrack2ParticleCorrection      ->LoadHistograms();
  fVertexRecoCorrection          ->LoadHistograms();
  fTriggerBiasCorrectionMBToINEL ->LoadHistograms();
  fTriggerBiasCorrectionMBToNSD  ->LoadHistograms();
  fTriggerBiasCorrectionMBToND   ->LoadHistograms();

  gDirectory->cd("..");

  return kTRUE;
}

//____________________________________________________________________
void AlidNdEtaCorrection::SaveHistograms()
{
  //
  // save the histograms
  //

  gDirectory->mkdir(fName.Data());
  gDirectory->cd(fName.Data());

  fTrack2ParticleCorrection     ->SaveHistograms();
  fVertexRecoCorrection         ->SaveHistograms();
  fTriggerBiasCorrectionMBToINEL->SaveHistograms();
  fTriggerBiasCorrectionMBToNSD ->SaveHistograms();
  fTriggerBiasCorrectionMBToND  ->SaveHistograms();

  gDirectory->cd("..");
}

//____________________________________________________________________
void AlidNdEtaCorrection::DrawHistograms()
{
  //
  // call the draw histogram method of the correction
  //

  fTrack2ParticleCorrection     ->DrawHistograms();
  fVertexRecoCorrection         ->DrawHistograms();
  fTriggerBiasCorrectionMBToINEL->DrawHistograms();
  fTriggerBiasCorrectionMBToNSD ->DrawHistograms();
  fTriggerBiasCorrectionMBToND  ->DrawHistograms();
}

//____________________________________________________________________
void AlidNdEtaCorrection::FillMCParticle(Float_t vtx, Float_t eta, Float_t pt, Bool_t trigger, Bool_t vertex, Int_t processType)
{
  // fills a particle in the corrections
  // it is filled in generated or measured depending of the flags

  fTriggerBiasCorrectionMBToINEL->GetTrackCorrection()->FillGene(vtx, eta, pt);

  if (processType != 92 && processType != 93)
    fTriggerBiasCorrectionMBToNSD->GetTrackCorrection()->FillGene(vtx, eta, pt);

  if (processType!=92 && processType!=93 && processType!=94)
    fTriggerBiasCorrectionMBToND->GetTrackCorrection()->FillGene(vtx, eta, pt);

  if (!trigger)
    return;

  fTriggerBiasCorrectionMBToINEL->GetTrackCorrection()->FillMeas(vtx, eta, pt);
  fTriggerBiasCorrectionMBToNSD->GetTrackCorrection()->FillMeas(vtx, eta, pt);
  fTriggerBiasCorrectionMBToND->GetTrackCorrection()->FillMeas(vtx, eta, pt);
  fVertexRecoCorrection->GetTrackCorrection()->FillGene(vtx, eta, pt);

  if (!vertex)
    return;

  fVertexRecoCorrection->GetTrackCorrection()->FillMeas(vtx, eta, pt);
  fTrack2ParticleCorrection->GetTrackCorrection()->FillGene(vtx, eta, pt);
}

//____________________________________________________________________
void AlidNdEtaCorrection::FillTrackedParticle(Float_t vtx, Float_t eta, Float_t pt)
{
  // fills a tracked particle in the corrections

  fTrack2ParticleCorrection->GetTrackCorrection()->FillMeas(vtx, eta, pt);
}

//____________________________________________________________________
void AlidNdEtaCorrection::FillEvent(Float_t vtx, Float_t n, Bool_t trigger, Bool_t vertex, Int_t processType)
{
  // fills an event int he correction
  // it is filled in generated or measured depending of the flags

  fTriggerBiasCorrectionMBToINEL->GetEventCorrection()->FillGene(vtx, n);

  if (processType != 92 && processType != 93)
    fTriggerBiasCorrectionMBToNSD->GetEventCorrection()->FillGene(vtx, n);

  if (processType!=92 && processType!=93 && processType!=94)
    fTriggerBiasCorrectionMBToND->GetEventCorrection()->FillGene(vtx, n);

  if (!trigger)
    return;

  fTriggerBiasCorrectionMBToINEL->GetEventCorrection()->FillMeas(vtx, n);
  fTriggerBiasCorrectionMBToNSD->GetEventCorrection()->FillMeas(vtx, n);
  fTriggerBiasCorrectionMBToND->GetEventCorrection()->FillMeas(vtx, n);
  fVertexRecoCorrection->GetEventCorrection()->FillGene(vtx, n);

  if (!vertex)
    return;

  fVertexRecoCorrection->GetEventCorrection()->FillMeas(vtx, n);
}

//____________________________________________________________________
Float_t AlidNdEtaCorrection::GetMeasuredFraction(CorrectionType correctionType, Float_t ptCutOff, Float_t eta, Bool_t debug)
{
  // calculates the fraction of particles measured (some are missed due to the pt cut off)
  //
  // uses the generated particle histogram from the correction passed, e.g. pass GetTrack2ParticleCorrection()

  if (!GetCorrection(correctionType))
    return -1;

  const TH3F* generated = GetCorrection(correctionType)->GetTrackCorrection()->GetGeneratedHistogram();

  // find eta borders, if eta is negative assume -0.8 ... 0.8
  Int_t etaBegin = 0;
  Int_t etaEnd = 0;
  if (eta < -99)
  {
    etaBegin = generated->GetYaxis()->FindBin(-0.8);
    etaEnd = generated->GetYaxis()->FindBin(0.8);
  }
  else
  {
    etaBegin = generated->GetYaxis()->FindBin(eta);
    etaEnd = etaBegin;
  }

  Int_t vertexBegin = generated->GetXaxis()->FindBin(-9.99);
  Int_t vertexEnd = generated->GetXaxis()->FindBin(9.99);

  TH1D* ptProj = dynamic_cast<TH1D*> (generated->ProjectionZ(Form("%s_pt", generated->GetName()), vertexBegin, vertexEnd, etaBegin, etaEnd));
  //printf("GetMeasuredFraction: bin range %d %d %d %d\n", vertexBegin, vertexEnd, etaBegin, etaEnd);
  ptProj->GetXaxis()->SetTitle(generated->GetZaxis()->GetTitle());

  Int_t ptBin = ptProj->FindBin(ptCutOff);
  //printf("GetMeasuredFraction: bin range %d %d\n", ptBin, ptProj->GetNbinsX());
  Float_t abovePtCut = ptProj->Integral(ptBin, ptProj->GetNbinsX());
  Float_t all = ptProj->Integral();

  if (all == 0)
    return -1;

  Float_t fraction = abovePtCut / all;

  //printf("GetMeasuredFraction: all %f above %f fraction %f\n", all, abovePtCut, fraction);

  if (debug)
  {
    new TCanvas;
    ptProj->Draw();
  }
  else
    delete ptProj;

  if (debug)
    printf("AlidNdEtaCorrection::GetMeasuredFraction: pt cut off = %f, eta = %f, => fraction = %f\n", ptCutOff, eta, fraction);

  return fraction;
}

//____________________________________________________________________
void AlidNdEtaCorrection::ReduceInformation()
{
  // this function deletes the measured and generated histograms from the corrections to reduce the amount of data
  // in memory

  // these are needed for GetMeasuredFraction(): fTrack2ParticleCorrection->ReduceInformation();
  fVertexRecoCorrection          ->ReduceInformation();
  fTriggerBiasCorrectionMBToINEL ->ReduceInformation();
  fTriggerBiasCorrectionMBToNSD  ->ReduceInformation();
  fTriggerBiasCorrectionMBToND   ->ReduceInformation();
}

//____________________________________________________________________
AliCorrection* AlidNdEtaCorrection::GetCorrection(CorrectionType correctionType)
{
  // returns the given correction

  switch (correctionType)
  {
    case kNone : return 0;
    case kTrack2Particle : return fTrack2ParticleCorrection;
    case kVertexReco :     return fVertexRecoCorrection;
    case kINEL :           return fTriggerBiasCorrectionMBToINEL;
    case kNSD :            return fTriggerBiasCorrectionMBToNSD;
    case kND :             return fTriggerBiasCorrectionMBToND;
  }

  return 0;
}
Commit	Line	Data
55e05544	1	/* $Id$ */
	2
	3	#include "AlidNdEtaCorrection.h"
	4
74fd10b3	5	#include <AliLog.h>
55e05544	6	#include <TCanvas.h>
847489f7	7	#include <TH3F.h>
847489f7	8	#include <TH1D.h>
74fd10b3	9	#include <AliCorrection.h>
	10	#include <AliCorrectionMatrix2D.h>
	11	#include <AliCorrectionMatrix3D.h>
55e05544	12
	13	//____________________________________________________________________
	14	ClassImp(AlidNdEtaCorrection)
	15
	16	//____________________________________________________________________
8b3563f4	17	AlidNdEtaCorrection::AlidNdEtaCorrection()
	18	: TNamed(),
	19	fTrack2ParticleCorrection(0),
	20	fVertexRecoCorrection(0),
7584d357	21	fTriggerBiasCorrectionMBToINEL(0),
	22	fTriggerBiasCorrectionMBToNSD(0),
	23	fTriggerBiasCorrectionMBToND(0)
8b3563f4	24	{
	25	// default constructor
	26	}
	27
	28	//____________________________________________________________________
	29	AlidNdEtaCorrection::AlidNdEtaCorrection(const Char_t* name, const Char_t* title)
	30	: TNamed(name, title),
38233af1	31	fTrack2ParticleCorrection(0),
38233af1	32	fVertexRecoCorrection(0),
7584d357	33	fTriggerBiasCorrectionMBToINEL(0),
	34	fTriggerBiasCorrectionMBToNSD(0),
	35	fTriggerBiasCorrectionMBToND(0)
8b3563f4	36	{
74fd10b3	37	//
55e05544	38	// constructor
	39	//
	40
74fd10b3	41	fTrack2ParticleCorrection = new AliCorrection("Track2Particle", "Track2Particle");
74fd10b3	42	fVertexRecoCorrection = new AliCorrection("VertexReconstruction", "VertexReconstruction");
1afae8ff	43
74fd10b3	44	fTriggerBiasCorrectionMBToINEL = new AliCorrection("TriggerBias_MBToINEL", "TriggerBias_MBToINEL");
	45	fTriggerBiasCorrectionMBToNSD = new AliCorrection("TriggerBias_MBToNSD", "TriggerBias_MBToNSD");
	46	fTriggerBiasCorrectionMBToND = new AliCorrection("TriggerBias_MBToND", "TriggerBias_MBToND");
55e05544	47	}
55e05544	48
38233af1	49	//____________________________________________________________________
	50	AlidNdEtaCorrection::~AlidNdEtaCorrection()
	51	{
	52	// destructor
	53
7584d357	54	if (fTrack2ParticleCorrection) {
38233af1	55	delete fTrack2ParticleCorrection;
	56	fTrack2ParticleCorrection = 0;
	57	}
	58
7584d357	59	if (fVertexRecoCorrection) {
38233af1	60	delete fVertexRecoCorrection;
	61	fVertexRecoCorrection = 0;
	62	}
	63
7584d357	64	if (fTriggerBiasCorrectionMBToINEL) {
	65	delete fTriggerBiasCorrectionMBToINEL;
	66	fTriggerBiasCorrectionMBToINEL = 0;
38233af1	67	}
38233af1	68
7584d357	69	if (fTriggerBiasCorrectionMBToNSD) {
	70	delete fTriggerBiasCorrectionMBToNSD;
	71	fTriggerBiasCorrectionMBToNSD = 0;
	72	}
	73
	74	if (fTriggerBiasCorrectionMBToND) {
	75	delete fTriggerBiasCorrectionMBToND;
	76	fTriggerBiasCorrectionMBToND = 0;
38233af1	77	}
	78	}
	79
55e05544	80	//____________________________________________________________________
55e05544	81	void
45e97e28	82	AlidNdEtaCorrection::Finish() {
55e05544	83	//
	84	// finish method
	85	//
45e97e28	86	// divide the histograms in the AliCorrectionMatrix2D objects to get the corrections
55e05544	87
45e97e28	88	fTrack2ParticleCorrection->Divide();
55e05544	89	fVertexRecoCorrection->Divide();
7584d357	90	fTriggerBiasCorrectionMBToINEL->Divide();
	91	fTriggerBiasCorrectionMBToNSD->Divide();
	92	fTriggerBiasCorrectionMBToND->Divide();
55e05544	93	}
	94
	95	//____________________________________________________________________
74fd10b3	96	Long64_t AlidNdEtaCorrection::Merge(TCollection* list)
74fd10b3	97	{
55e05544	98	// Merge a list of dNdEtaCorrection objects with this (needed for
7af955da	99	// PROOF).
55e05544	100	// Returns the number of merged objects (including this).
	101
	102	if (!list)
	103	return 0;
7af955da	104
55e05544	105	if (list->IsEmpty())
	106	return 1;
	107
	108	TIterator* iter = list->MakeIterator();
	109	TObject* obj;
	110
	111	// collections of measured and generated histograms
7584d357	112	TList* collectionNtrackToNparticle = new TList;
	113	TList* collectionVertexReco = new TList;
	114	TList* collectionTriggerBiasMBToINEL = new TList;
	115	TList* collectionTriggerBiasMBToNSD = new TList;
	116	TList* collectionTriggerBiasMBToND = new TList;
55e05544	117
	118	Int_t count = 0;
	119	while ((obj = iter->Next())) {
7af955da	120
55e05544	121	AlidNdEtaCorrection* entry = dynamic_cast<AlidNdEtaCorrection*> (obj);
7af955da	122	if (entry == 0)
55e05544	123	continue;
55e05544	124
74fd10b3	125	collectionNtrackToNparticle ->Add(entry->fTrack2ParticleCorrection);
	126	collectionVertexReco ->Add(entry->fVertexRecoCorrection);
	127	collectionTriggerBiasMBToINEL->Add(entry->fTriggerBiasCorrectionMBToINEL);
	128	collectionTriggerBiasMBToNSD ->Add(entry->fTriggerBiasCorrectionMBToNSD);
	129	collectionTriggerBiasMBToND ->Add(entry->fTriggerBiasCorrectionMBToND);
55e05544	130
	131	count++;
	132	}
7584d357	133	fTrack2ParticleCorrection ->Merge(collectionNtrackToNparticle);
	134	fVertexRecoCorrection ->Merge(collectionVertexReco);
	135	fTriggerBiasCorrectionMBToINEL ->Merge(collectionTriggerBiasMBToINEL);
	136	fTriggerBiasCorrectionMBToNSD ->Merge(collectionTriggerBiasMBToNSD);
	137	fTriggerBiasCorrectionMBToND ->Merge(collectionTriggerBiasMBToND);
10ebe68d	138
55e05544	139	delete collectionNtrackToNparticle;
55e05544	140	delete collectionVertexReco;
7584d357	141	delete collectionTriggerBiasMBToINEL;
	142	delete collectionTriggerBiasMBToNSD;
	143	delete collectionTriggerBiasMBToND;
10ebe68d	144
55e05544	145	return count+1;
	146	}
	147
2e88424e	148	//____________________________________________________________________
	149	void AlidNdEtaCorrection::Add(AlidNdEtaCorrection* aCorrectionsToAdd, Float_t c) {
	150	//
	151	// adds the measured and generated of aCorrectionsToAdd to measured and generated
	152	// of all corrections in this
	153
	154	fTrack2ParticleCorrection ->Add(aCorrectionsToAdd->GetTrack2ParticleCorrection() ,c);
	155	fVertexRecoCorrection ->Add(aCorrectionsToAdd->GetVertexRecoCorrection() ,c);
	156	fTriggerBiasCorrectionMBToINEL ->Add(aCorrectionsToAdd->GetTriggerBiasCorrectionINEL(),c);
	157	fTriggerBiasCorrectionMBToNSD ->Add(aCorrectionsToAdd->GetTriggerBiasCorrectionNSD() ,c);
	158	fTriggerBiasCorrectionMBToND ->Add(aCorrectionsToAdd->GetTriggerBiasCorrectionND() ,c);
	159
	160	}
	161
	162	//____________________________________________________________________
	163	void AlidNdEtaCorrection::Reset(void) {
	164	//
	165	// reset all corrections
	166	//
	167
	168	fTrack2ParticleCorrection ->Reset();
	169	fVertexRecoCorrection ->Reset();
	170	fTriggerBiasCorrectionMBToINEL ->Reset();
	171	fTriggerBiasCorrectionMBToNSD ->Reset();
	172	fTriggerBiasCorrectionMBToND ->Reset();
	173
	174	}
	175
	176
	177
55e05544	178	//____________________________________________________________________
74fd10b3	179	Bool_t AlidNdEtaCorrection::LoadHistograms(const Char_t* dir)
74fd10b3	180	{
55e05544	181	//
55e05544	182	// loads the histograms
74fd10b3	183	// if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
55e05544	184	//
55e05544	185
74fd10b3	186	if (!dir)
74fd10b3	187	dir = GetName();
7584d357	188
74fd10b3	189	if (!gDirectory->cd(dir))
	190	return kFALSE;
	191
	192	fTrack2ParticleCorrection ->LoadHistograms();
	193	fVertexRecoCorrection ->LoadHistograms();
	194	fTriggerBiasCorrectionMBToINEL ->LoadHistograms();
	195	fTriggerBiasCorrectionMBToNSD ->LoadHistograms();
	196	fTriggerBiasCorrectionMBToND ->LoadHistograms();
	197
	198	gDirectory->cd("..");
1afae8ff	199
55e05544	200	return kTRUE;
	201	}
	202
55e05544	203	//____________________________________________________________________
74fd10b3	204	void AlidNdEtaCorrection::SaveHistograms()
74fd10b3	205	{
55e05544	206	//
	207	// save the histograms
	208	//
	209
	210	gDirectory->mkdir(fName.Data());
	211	gDirectory->cd(fName.Data());
	212
7584d357	213	fTrack2ParticleCorrection ->SaveHistograms();
	214	fVertexRecoCorrection ->SaveHistograms();
	215	fTriggerBiasCorrectionMBToINEL->SaveHistograms();
	216	fTriggerBiasCorrectionMBToNSD ->SaveHistograms();
	217	fTriggerBiasCorrectionMBToND ->SaveHistograms();
55e05544	218
74fd10b3	219	gDirectory->cd("..");
55e05544	220	}
	221
	222	//____________________________________________________________________
	223	void AlidNdEtaCorrection::DrawHistograms()
	224	{
	225	//
74fd10b3	226	// call the draw histogram method of the correction
74fd10b3	227	//
55e05544	228
7584d357	229	fTrack2ParticleCorrection ->DrawHistograms();
	230	fVertexRecoCorrection ->DrawHistograms();
	231	fTriggerBiasCorrectionMBToINEL->DrawHistograms();
	232	fTriggerBiasCorrectionMBToNSD ->DrawHistograms();
	233	fTriggerBiasCorrectionMBToND ->DrawHistograms();
7584d357	234	}
	235
	236	//____________________________________________________________________
74fd10b3	237	void AlidNdEtaCorrection::FillMCParticle(Float_t vtx, Float_t eta, Float_t pt, Bool_t trigger, Bool_t vertex, Int_t processType)
7584d357	238	{
74fd10b3	239	// fills a particle in the corrections
74fd10b3	240	// it is filled in generated or measured depending of the flags
7584d357	241
74fd10b3	242	fTriggerBiasCorrectionMBToINEL->GetTrackCorrection()->FillGene(vtx, eta, pt);
7584d357	243
74fd10b3	244	if (processType != 92 && processType != 93)
	245	fTriggerBiasCorrectionMBToNSD->GetTrackCorrection()->FillGene(vtx, eta, pt);
	246
	247	if (processType!=92 && processType!=93 && processType!=94)
	248	fTriggerBiasCorrectionMBToND->GetTrackCorrection()->FillGene(vtx, eta, pt);
	249
	250	if (!trigger)
	251	return;
	252
	253	fTriggerBiasCorrectionMBToINEL->GetTrackCorrection()->FillMeas(vtx, eta, pt);
	254	fTriggerBiasCorrectionMBToNSD->GetTrackCorrection()->FillMeas(vtx, eta, pt);
	255	fTriggerBiasCorrectionMBToND->GetTrackCorrection()->FillMeas(vtx, eta, pt);
	256	fVertexRecoCorrection->GetTrackCorrection()->FillGene(vtx, eta, pt);
	257
	258	if (!vertex)
	259	return;
	260
	261	fVertexRecoCorrection->GetTrackCorrection()->FillMeas(vtx, eta, pt);
	262	fTrack2ParticleCorrection->GetTrackCorrection()->FillGene(vtx, eta, pt);
7584d357	263	}
55e05544	264
7584d357	265	//____________________________________________________________________
74fd10b3	266	void AlidNdEtaCorrection::FillTrackedParticle(Float_t vtx, Float_t eta, Float_t pt)
7584d357	267	{
74fd10b3	268	// fills a tracked particle in the corrections
	269
	270	fTrack2ParticleCorrection->GetTrackCorrection()->FillMeas(vtx, eta, pt);
55e05544	271	}
847489f7	272
7584d357	273	//____________________________________________________________________
74fd10b3	274	void AlidNdEtaCorrection::FillEvent(Float_t vtx, Float_t n, Bool_t trigger, Bool_t vertex, Int_t processType)
7584d357	275	{
74fd10b3	276	// fills an event int he correction
	277	// it is filled in generated or measured depending of the flags
	278
	279	fTriggerBiasCorrectionMBToINEL->GetEventCorrection()->FillGene(vtx, n);
	280
	281	if (processType != 92 && processType != 93)
	282	fTriggerBiasCorrectionMBToNSD->GetEventCorrection()->FillGene(vtx, n);
7584d357	283
74fd10b3	284	if (processType!=92 && processType!=93 && processType!=94)
	285	fTriggerBiasCorrectionMBToND->GetEventCorrection()->FillGene(vtx, n);
	286
	287	if (!trigger)
	288	return;
	289
	290	fTriggerBiasCorrectionMBToINEL->GetEventCorrection()->FillMeas(vtx, n);
	291	fTriggerBiasCorrectionMBToNSD->GetEventCorrection()->FillMeas(vtx, n);
	292	fTriggerBiasCorrectionMBToND->GetEventCorrection()->FillMeas(vtx, n);
	293	fVertexRecoCorrection->GetEventCorrection()->FillGene(vtx, n);
	294
	295	if (!vertex)
	296	return;
	297
	298	fVertexRecoCorrection->GetEventCorrection()->FillMeas(vtx, n);
	299	}
7584d357	300
847489f7	301	//____________________________________________________________________
74fd10b3	302	Float_t AlidNdEtaCorrection::GetMeasuredFraction(CorrectionType correctionType, Float_t ptCutOff, Float_t eta, Bool_t debug)
847489f7	303	{
847489f7	304	// calculates the fraction of particles measured (some are missed due to the pt cut off)
74fd10b3	305	//
74fd10b3	306	// uses the generated particle histogram from the correction passed, e.g. pass GetTrack2ParticleCorrection()
847489f7	307
0448e811	308	if (!GetCorrection(correctionType))
	309	return -1;
	310
	311	const TH3F* generated = GetCorrection(correctionType)->GetTrackCorrection()->GetGeneratedHistogram();
847489f7	312
	313	// find eta borders, if eta is negative assume -0.8 ... 0.8
	314	Int_t etaBegin = 0;
	315	Int_t etaEnd = 0;
72e597d7	316	if (eta < -99)
847489f7	317	{
	318	etaBegin = generated->GetYaxis()->FindBin(-0.8);
	319	etaEnd = generated->GetYaxis()->FindBin(0.8);
	320	}
	321	else
	322	{
	323	etaBegin = generated->GetYaxis()->FindBin(eta);
	324	etaEnd = etaBegin;
	325	}
	326
0448e811	327	Int_t vertexBegin = generated->GetXaxis()->FindBin(-9.99);
0448e811	328	Int_t vertexEnd = generated->GetXaxis()->FindBin(9.99);
847489f7	329
92d2d8ad	330	TH1D* ptProj = dynamic_cast<TH1D*> (generated->ProjectionZ(Form("%s_pt", generated->GetName()), vertexBegin, vertexEnd, etaBegin, etaEnd));
b4b9cacc	331	//printf("GetMeasuredFraction: bin range %d %d %d %d\n", vertexBegin, vertexEnd, etaBegin, etaEnd);
1afae8ff	332	ptProj->GetXaxis()->SetTitle(generated->GetZaxis()->GetTitle());
847489f7	333
847489f7	334	Int_t ptBin = ptProj->FindBin(ptCutOff);
b4b9cacc	335	//printf("GetMeasuredFraction: bin range %d %d\n", ptBin, ptProj->GetNbinsX());
847489f7	336	Float_t abovePtCut = ptProj->Integral(ptBin, ptProj->GetNbinsX());
	337	Float_t all = ptProj->Integral();
	338
	339	if (all == 0)
	340	return -1;
	341
	342	Float_t fraction = abovePtCut / all;
	343
b4b9cacc	344	//printf("GetMeasuredFraction: all %f above %f fraction %f\n", all, abovePtCut, fraction);
74fd10b3	345
847489f7	346	if (debug)
	347	{
	348	new TCanvas;
	349	ptProj->Draw();
	350	}
92d2d8ad	351	else
92d2d8ad	352	delete ptProj;
847489f7	353
72e597d7	354	if (debug)
	355	printf("AlidNdEtaCorrection::GetMeasuredFraction: pt cut off = %f, eta = %f, => fraction = %f\n", ptCutOff, eta, fraction);
	356
847489f7	357	return fraction;
	358	}
	359
74fd10b3	360	//____________________________________________________________________
0ab29cfa	361	void AlidNdEtaCorrection::ReduceInformation()
	362	{
	363	// this function deletes the measured and generated histograms from the corrections to reduce the amount of data
	364	// in memory
	365
	366	// these are needed for GetMeasuredFraction(): fTrack2ParticleCorrection->ReduceInformation();
7584d357	367	fVertexRecoCorrection ->ReduceInformation();
	368	fTriggerBiasCorrectionMBToINEL ->ReduceInformation();
	369	fTriggerBiasCorrectionMBToNSD ->ReduceInformation();
	370	fTriggerBiasCorrectionMBToND ->ReduceInformation();
0ab29cfa	371	}
7af955da	372
0448e811	373	//____________________________________________________________________
	374	AliCorrection* AlidNdEtaCorrection::GetCorrection(CorrectionType correctionType)
	375	{
	376	// returns the given correction
	377
	378	switch (correctionType)
	379	{
	380	case kNone : return 0;
	381	case kTrack2Particle : return fTrack2ParticleCorrection;
	382	case kVertexReco : return fVertexRecoCorrection;
	383	case kINEL : return fTriggerBiasCorrectionMBToINEL;
	384	case kNSD : return fTriggerBiasCorrectionMBToNSD;
	385	case kND : return fTriggerBiasCorrectionMBToND;
	386	}
	387
	388	return 0;
	389	}