[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliUEHistograms.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id: AliUEHistograms.cxx 20164 2007-08-14 15:31:50Z morsch $ */

//
//
// encapsulates several AliUEHist objects for a full UE analysis plus additional control histograms
//
//
// Author: Jan Fiete Grosse-Oetringhaus, Sara Vallero

#include "AliUEHistograms.h"

#include "AliCFContainer.h"
#include "AliVParticle.h"

#include "TList.h"
#include "TH2F.h"
#include "TH1F.h"
#include "TH3F.h"
#include "TMath.h"

ClassImp(AliUEHistograms)

AliUEHistograms::AliUEHistograms() : 
  TObject(),
  fNumberDensitypT(0),
  fSumpT(0),
  fNumberDensityPhi(0),
  fCorrelationpT(0),
  fCorrelationEta(0),
  fCorrelationPhi(0),
  fCorrelationR(0),
  fCorrelationLeading2Phi(0),
  fCorrelationMultiplicity(0),
  fEventCount(0),
  fEventCountDifferential(0),
  fVertexContributors(0)
{
  // Constructor
  
  fNumberDensitypT = new AliUEHist("NumberDensitypT");
  fSumpT = new AliUEHist("SumpT");
  fNumberDensityPhi = new AliUEHist("NumberDensityPhi");
  
  // do not add this hists to the directory
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  
  fCorrelationpT  = new TH2F("fCorrelationpT", ";p_{T,lead} (MC);p_{T,lead} (RECO)", 200, 0, 50, 200, 0, 50);
  fCorrelationEta = new TH2F("fCorrelationEta", ";#eta_{T,lead} (MC);#eta_{T,lead} (RECO)", 200, -1, 1, 200, -1, 1);
  fCorrelationPhi = new TH2F("fCorrelationPhi", ";#phi_{T,lead} (MC);#phi_{T,lead} (RECO)", 200, 0, TMath::TwoPi(), 200, 0, TMath::TwoPi());
  fCorrelationR =   new TH2F("fCorrelationR", ";R;p_{T,lead} (MC)", 200, 0, 2, 200, 0, 50);
  fCorrelationLeading2Phi = new TH2F("fCorrelationLeading2Phi", ";#Delta #phi;p_{T,lead} (MC)", 200, -TMath::Pi(), TMath::Pi(), 200, 0, 50);
  fCorrelationMultiplicity = new TH2F("fCorrelationMultiplicity", ";MC tracks;Reco tracks", 100, -0.5, 99.5, 100, -0.5, 99.5);
  
  fEventCount = new TH2F("fEventCount", ";step;event type;count", AliUEHist::fgkCFSteps+1, -1.5, -0.5 + AliUEHist::fgkCFSteps, 3, -0.5, 2.5);
  fEventCount->GetYaxis()->SetBinLabel(1, "ND");
  fEventCount->GetYaxis()->SetBinLabel(2, "SD");
  fEventCount->GetYaxis()->SetBinLabel(3, "DD");
  
  fEventCountDifferential = new TH3F("fEventCountDifferential", ";p_{T,lead};step;event type", 100, 0, 50, AliUEHist::fgkCFSteps, -0.5, -0.5 + AliUEHist::fgkCFSteps, 3, -0.5, 2.5);
  fEventCountDifferential->GetZaxis()->SetBinLabel(1, "ND");
  fEventCountDifferential->GetZaxis()->SetBinLabel(2, "SD");
  fEventCountDifferential->GetZaxis()->SetBinLabel(3, "DD");
  
  fVertexContributors = new TH1F("fVertexContributors", ";contributors;count", 100, -0.5, 99.5);
  
  TH1::AddDirectory(oldStatus);
}

//_____________________________________________________________________________
AliUEHistograms::AliUEHistograms(const AliUEHistograms &c) :
  TObject(),
  fNumberDensitypT(0),
  fSumpT(0),
  fNumberDensityPhi(0),
  fCorrelationpT(0),
  fCorrelationEta(0),
  fCorrelationPhi(0),
  fCorrelationR(0),
  fCorrelationLeading2Phi(0),
  fCorrelationMultiplicity(0),
  fEventCount(0),
  fEventCountDifferential(0),
  fVertexContributors(0)
{
  //
  // AliUEHistograms copy constructor
  //

  ((AliUEHistograms &) c).Copy(*this);
}

//____________________________________________________________________
AliUEHistograms::~AliUEHistograms()
{
  // Destructor
  
  if (fNumberDensitypT)
  {
    delete fNumberDensitypT;
    fNumberDensitypT = 0;
  }
  
  if (fSumpT)
  {
    delete fSumpT;
    fSumpT = 0;
  }
  
  if (fNumberDensityPhi)
  {
    delete fNumberDensityPhi;
    fNumberDensityPhi = 0;
  }
  
  if (fCorrelationpT)
  {
    delete fCorrelationpT;
    fCorrelationpT = 0;
  }
  
  if (fCorrelationEta)
  {
    delete fCorrelationEta;
    fCorrelationEta = 0;
  }
  
  if (fCorrelationPhi)
  {
    delete fCorrelationPhi;
    fCorrelationPhi = 0;
  }
  
  if (fCorrelationR)
  {
    delete fCorrelationR;
    fCorrelationR = 0;
  }

  if (fCorrelationLeading2Phi)
  {
    delete fCorrelationLeading2Phi;
    fCorrelationLeading2Phi = 0;
  }
  
  if (fCorrelationMultiplicity)
  {
    delete fCorrelationMultiplicity;
    fCorrelationMultiplicity = 0;
  }
  
  if (fEventCount)
  {
    delete fEventCount;
    fEventCount = 0;
  }

  if (fEventCountDifferential)
  {
    delete fEventCountDifferential;
    fEventCountDifferential = 0;
  }
  
  if (fVertexContributors)
  {
    delete fVertexContributors;
    fVertexContributors = 0;
  }
}

//____________________________________________________________________
Int_t AliUEHistograms::CountParticles(TList* list, Float_t ptMin)
{
  // counts the number of particles in the list with a pT above ptMin
  // TODO eta cut needed here?
  
  Int_t count = 0;
  for (Int_t j=0; j<list->GetEntries(); j++)
    if (((AliVParticle*) list->At(j))->Pt() > ptMin)
      count++;
      
  return count;
}
  
//____________________________________________________________________
void AliUEHistograms::Fill(Int_t eventType, AliUEHist::CFStep step, AliVParticle* leading, TList* toward, TList* away, TList* min, TList* max)
{
  // fills the UE event histograms
  //
  // this function needs the leading (track or jet or ...) and four lists of AliVParticles which contain the particles/tracks to be filled in the four regions
  
  // if leading is not set, just fill event statistics
  if (leading)
  {
    Int_t multiplicity = 0;
    
    // TODO configurable?
    Float_t ptMin = 0.15;
    if (leading->Pt() > ptMin)
      multiplicity++;
    
    multiplicity += CountParticles(toward, ptMin);
    multiplicity += CountParticles(away, ptMin);
    multiplicity += CountParticles(min, ptMin);
    multiplicity += CountParticles(max, ptMin);
     
    FillRegion(AliUEHist::kToward, step, leading, toward, multiplicity);
    FillRegion(AliUEHist::kAway,   step, leading, away, multiplicity);
    FillRegion(AliUEHist::kMin,    step, leading, min, multiplicity);
    FillRegion(AliUEHist::kMax,    step, leading, max, multiplicity);
  
    Double_t vars[2];
    vars[0] = leading->Pt();
    vars[1] = multiplicity;
    fNumberDensitypT->GetEventHist()->Fill(vars, step);
    fSumpT->GetEventHist()->Fill(vars, step);
    fNumberDensityPhi->GetEventHist()->Fill(vars, step);
  
    fEventCountDifferential->Fill(leading->Pt(), step, eventType);
  }
  
  FillEvent(eventType, step);
}
  
//____________________________________________________________________
void AliUEHistograms::FillRegion(AliUEHist::Region region, AliUEHist::CFStep step, AliVParticle* leading, TList* list, Int_t multiplicity)
{
  // loops over AliVParticles in list and fills the given region at the given step
  //
  // See also Fill(...)

  for (Int_t i=0; i<list->GetEntries(); i++)
  {
    AliVParticle* particle = (AliVParticle*) list->At(i);
    
    Double_t vars[5];
    vars[0] = particle->Eta();
    vars[1] = particle->Pt();
    vars[2] = leading->Pt();
    vars[3] = multiplicity;
    vars[4] = leading->Phi() - particle->Phi();
    if (vars[4]>TMath::Pi()/2.)vars[4]-=TMath::TwoPi();
    if (vars[4]< - 3.*TMath::Pi()/2.)vars[4]+=TMath::TwoPi();

    fNumberDensitypT->GetTrackHist(region)->Fill(vars, step);
    fSumpT->GetTrackHist(region)->Fill(vars, step, particle->Pt());
    
    // fill all in toward region (is anyway as function of delta phi!)
    fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->Fill(vars, step);
  }
}

//____________________________________________________________________
void AliUEHistograms::Fill(AliVParticle* leadingMC, AliVParticle* leadingReco)
{
  // fills the correlation histograms
  
  if (leadingMC)
  {
    fCorrelationpT->Fill(leadingMC->Pt(), leadingReco->Pt());
    if (leadingMC->Pt() > 0.5)
    {
      fCorrelationEta->Fill(leadingMC->Eta(), leadingReco->Eta());
      fCorrelationPhi->Fill(leadingMC->Phi(), leadingReco->Phi());
    }
    
    Float_t phiDiff = leadingMC->Phi() - leadingReco->Phi();
    if (phiDiff > TMath::Pi())
      phiDiff -= TMath::TwoPi();
    if (phiDiff < -TMath::Pi())
      phiDiff += TMath::TwoPi();
      
    Float_t etaDiff = leadingMC->Eta() - leadingReco->Eta();
    
    fCorrelationR->Fill(TMath::Sqrt(phiDiff * phiDiff + etaDiff * etaDiff), leadingMC->Pt());
    fCorrelationLeading2Phi->Fill(phiDiff, leadingMC->Pt());
  }
  else
  {
    fCorrelationpT->Fill(1.0, leadingReco->Pt());
    if (leadingReco->Pt() > 0.5)
    {
      fCorrelationEta->Fill(0.0, leadingReco->Eta());
      fCorrelationPhi->Fill(0.0, leadingReco->Phi());
    }
  }
}
  
//____________________________________________________________________
void AliUEHistograms::FillEvent(Int_t eventType, Int_t step)
{
  // fills the number of events at the given step and the given enty type
  //
  // WARNING: This function is called from Fill, so only call it for steps where Fill is not called
  
  fEventCount->Fill(step, eventType);
}

//____________________________________________________________________
void AliUEHistograms::SetEtaRange(Float_t etaMin, Float_t etaMax)
{
  // sets eta min and max for all contained AliUEHist classes
  
  fNumberDensitypT->SetEtaRange(etaMin, etaMax);
  fSumpT->SetEtaRange(etaMin, etaMax);
  fNumberDensityPhi->SetEtaRange(etaMin, etaMax);
}

//____________________________________________________________________
void AliUEHistograms::SetPtRange(Float_t ptMin, Float_t ptMax)
{
  // sets pT min and max for all contained AliUEHist classes
  
  fNumberDensitypT->SetPtRange(ptMin, ptMax);
  fSumpT->SetPtRange(ptMin, ptMax);
  fNumberDensityPhi->SetPtRange(ptMin, ptMax);
}

//____________________________________________________________________
void AliUEHistograms::SetCombineMinMax(Bool_t flag)
{
  // sets pT min and max for all contained AliUEHist classes
  
  fNumberDensitypT->SetCombineMinMax(flag);
  fSumpT->SetCombineMinMax(flag);
  fNumberDensityPhi->SetCombineMinMax(flag);
}

//____________________________________________________________________
void AliUEHistograms::Correct(AliUEHistograms* corrections)
{
  // corrects the contained histograms by calling AliUEHist::Correct
  
  fNumberDensitypT->Correct(corrections->fNumberDensitypT);
  fSumpT->Correct(corrections->fSumpT);
  fNumberDensityPhi->Correct(corrections->fNumberDensityPhi);
}

//____________________________________________________________________
AliUEHistograms &AliUEHistograms::operator=(const AliUEHistograms &c)
{
  // assigment operator

  if (this != &c)
    ((AliUEHistograms &) c).Copy(*this);

  return *this;
}

//____________________________________________________________________
void AliUEHistograms::Copy(TObject& c) const
{
  // copy function

  AliUEHistograms& target = (AliUEHistograms &) c;

  if (fNumberDensitypT)
    target.fNumberDensitypT = dynamic_cast<AliUEHist*> (fNumberDensitypT->Clone());

  if (fSumpT)
    target.fSumpT = dynamic_cast<AliUEHist*> (fSumpT->Clone());

  if (fNumberDensityPhi)
    target.fNumberDensityPhi = dynamic_cast<AliUEHist*> (fNumberDensityPhi->Clone());

  if (fCorrelationpT)
    target.fCorrelationpT = dynamic_cast<TH2F*> (fCorrelationpT->Clone());

  if (fCorrelationEta)
    target.fCorrelationEta = dynamic_cast<TH2F*> (fCorrelationEta->Clone());

  if (fCorrelationPhi)
    target.fCorrelationPhi = dynamic_cast<TH2F*> (fCorrelationPhi->Clone());

  if (fCorrelationR)
    target.fCorrelationR = dynamic_cast<TH2F*> (fCorrelationR->Clone());

  if (fCorrelationLeading2Phi)
    target.fCorrelationLeading2Phi = dynamic_cast<TH2F*> (fCorrelationLeading2Phi->Clone());

  if (fCorrelationMultiplicity)
    target.fCorrelationMultiplicity = dynamic_cast<TH2F*> (fCorrelationMultiplicity->Clone());
  
  if (fEventCount)
    target.fEventCount = dynamic_cast<TH2F*> (fEventCount->Clone());

  if (fEventCountDifferential)
    target.fEventCountDifferential = dynamic_cast<TH3F*> (fEventCountDifferential->Clone());
    
  if (fVertexContributors)
    target.fVertexContributors = dynamic_cast<TH1F*> (fVertexContributors->Clone());
}

//____________________________________________________________________
Long64_t AliUEHistograms::Merge(TCollection* list)
{
  // Merge a list of AliUEHistograms 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 objects
  const Int_t kMaxLists = 12;
  TList* lists[kMaxLists];
  
  for (Int_t i=0; i<kMaxLists; i++)
    lists[i] = new TList;
  
  Int_t count = 0;
  while ((obj = iter->Next())) {
    
    AliUEHistograms* entry = dynamic_cast<AliUEHistograms*> (obj);
    if (entry == 0) 
      continue;

    lists[0]->Add(entry->fNumberDensitypT);
    lists[1]->Add(entry->fSumpT);
    lists[2]->Add(entry->fNumberDensityPhi);
    lists[3]->Add(entry->fCorrelationpT);
    lists[4]->Add(entry->fCorrelationEta);
    lists[5]->Add(entry->fCorrelationPhi);
    lists[6]->Add(entry->fCorrelationR);
    lists[7]->Add(entry->fCorrelationLeading2Phi);
    lists[8]->Add(entry->fCorrelationMultiplicity);
    lists[9]->Add(entry->fEventCount);
    lists[10]->Add(entry->fEventCountDifferential);
    lists[11]->Add(entry->fVertexContributors);

    count++;
  }
    
  fNumberDensitypT->Merge(lists[0]);
  fSumpT->Merge(lists[1]);
  fNumberDensityPhi->Merge(lists[2]);
  fCorrelationpT->Merge(lists[3]);
  fCorrelationEta->Merge(lists[4]);
  fCorrelationPhi->Merge(lists[5]);
  fCorrelationR->Merge(lists[6]);
  fCorrelationLeading2Phi->Merge(lists[7]);
  fCorrelationMultiplicity->Merge(lists[8]);
  fEventCount->Merge(lists[9]);
  fEventCountDifferential->Merge(lists[10]);
  fVertexContributors->Merge(lists[11]);
  
  for (Int_t i=0; i<kMaxLists; i++)
    delete lists[i];

  return count+1;
}
Commit	Line	Data
a75aacd6	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id: AliUEHistograms.cxx 20164 2007-08-14 15:31:50Z morsch $ */
	17
	18	//
	19	//
	20	// encapsulates several AliUEHist objects for a full UE analysis plus additional control histograms
	21	//
	22	//
	23	// Author: Jan Fiete Grosse-Oetringhaus, Sara Vallero
	24
	25	#include "AliUEHistograms.h"
	26
	27	#include "AliCFContainer.h"
	28	#include "AliVParticle.h"
	29
	30	#include "TList.h"
	31	#include "TH2F.h"
	32	#include "TH1F.h"
	33	#include "TH3F.h"
	34	#include "TMath.h"
	35
	36	ClassImp(AliUEHistograms)
	37
	38	AliUEHistograms::AliUEHistograms() :
d1c75d06	39	TObject(),
a75aacd6	40	fNumberDensitypT(0),
	41	fSumpT(0),
	42	fNumberDensityPhi(0),
	43	fCorrelationpT(0),
	44	fCorrelationEta(0),
	45	fCorrelationPhi(0),
	46	fCorrelationR(0),
	47	fCorrelationLeading2Phi(0),
	48	fCorrelationMultiplicity(0),
	49	fEventCount(0),
	50	fEventCountDifferential(0),
	51	fVertexContributors(0)
	52	{
	53	// Constructor
	54
	55	fNumberDensitypT = new AliUEHist("NumberDensitypT");
	56	fSumpT = new AliUEHist("SumpT");
	57	fNumberDensityPhi = new AliUEHist("NumberDensityPhi");
	58
	59	// do not add this hists to the directory
	60	Bool_t oldStatus = TH1::AddDirectoryStatus();
	61	TH1::AddDirectory(kFALSE);
	62
	63	fCorrelationpT = new TH2F("fCorrelationpT", ";p_{T,lead} (MC);p_{T,lead} (RECO)", 200, 0, 50, 200, 0, 50);
	64	fCorrelationEta = new TH2F("fCorrelationEta", ";#eta_{T,lead} (MC);#eta_{T,lead} (RECO)", 200, -1, 1, 200, -1, 1);
	65	fCorrelationPhi = new TH2F("fCorrelationPhi", ";#phi_{T,lead} (MC);#phi_{T,lead} (RECO)", 200, 0, TMath::TwoPi(), 200, 0, TMath::TwoPi());
	66	fCorrelationR = new TH2F("fCorrelationR", ";R;p_{T,lead} (MC)", 200, 0, 2, 200, 0, 50);
	67	fCorrelationLeading2Phi = new TH2F("fCorrelationLeading2Phi", ";#Delta #phi;p_{T,lead} (MC)", 200, -TMath::Pi(), TMath::Pi(), 200, 0, 50);
	68	fCorrelationMultiplicity = new TH2F("fCorrelationMultiplicity", ";MC tracks;Reco tracks", 100, -0.5, 99.5, 100, -0.5, 99.5);
	69
	70	fEventCount = new TH2F("fEventCount", ";step;event type;count", AliUEHist::fgkCFSteps+1, -1.5, -0.5 + AliUEHist::fgkCFSteps, 3, -0.5, 2.5);
	71	fEventCount->GetYaxis()->SetBinLabel(1, "ND");
	72	fEventCount->GetYaxis()->SetBinLabel(2, "SD");
	73	fEventCount->GetYaxis()->SetBinLabel(3, "DD");
	74
	75	fEventCountDifferential = new TH3F("fEventCountDifferential", ";p_{T,lead};step;event type", 100, 0, 50, AliUEHist::fgkCFSteps, -0.5, -0.5 + AliUEHist::fgkCFSteps, 3, -0.5, 2.5);
	76	fEventCountDifferential->GetZaxis()->SetBinLabel(1, "ND");
	77	fEventCountDifferential->GetZaxis()->SetBinLabel(2, "SD");
	78	fEventCountDifferential->GetZaxis()->SetBinLabel(3, "DD");
	79
	80	fVertexContributors = new TH1F("fVertexContributors", ";contributors;count", 100, -0.5, 99.5);
	81
	82	TH1::AddDirectory(oldStatus);
	83	}
	84
d1c75d06	85	//_____________________________________________________________________________
	86	AliUEHistograms::AliUEHistograms(const AliUEHistograms &c) :
	87	TObject(),
	88	fNumberDensitypT(0),
	89	fSumpT(0),
	90	fNumberDensityPhi(0),
	91	fCorrelationpT(0),
	92	fCorrelationEta(0),
	93	fCorrelationPhi(0),
	94	fCorrelationR(0),
	95	fCorrelationLeading2Phi(0),
	96	fCorrelationMultiplicity(0),
	97	fEventCount(0),
	98	fEventCountDifferential(0),
	99	fVertexContributors(0)
	100	{
	101	//
	102	// AliUEHistograms copy constructor
	103	//
	104
	105	((AliUEHistograms &) c).Copy(*this);
	106	}
	107
a75aacd6	108	//____________________________________________________________________
	109	AliUEHistograms::~AliUEHistograms()
	110	{
	111	// Destructor
	112
	113	if (fNumberDensitypT)
	114	{
	115	delete fNumberDensitypT;
	116	fNumberDensitypT = 0;
	117	}
	118
	119	if (fSumpT)
	120	{
	121	delete fSumpT;
	122	fSumpT = 0;
	123	}
	124
	125	if (fNumberDensityPhi)
	126	{
	127	delete fNumberDensityPhi;
	128	fNumberDensityPhi = 0;
	129	}
	130
	131	if (fCorrelationpT)
	132	{
	133	delete fCorrelationpT;
	134	fCorrelationpT = 0;
	135	}
	136
	137	if (fCorrelationEta)
	138	{
	139	delete fCorrelationEta;
	140	fCorrelationEta = 0;
	141	}
	142
	143	if (fCorrelationPhi)
	144	{
	145	delete fCorrelationPhi;
	146	fCorrelationPhi = 0;
	147	}
	148
	149	if (fCorrelationR)
	150	{
	151	delete fCorrelationR;
	152	fCorrelationR = 0;
	153	}
	154
	155	if (fCorrelationLeading2Phi)
	156	{
	157	delete fCorrelationLeading2Phi;
	158	fCorrelationLeading2Phi = 0;
	159	}
	160
	161	if (fCorrelationMultiplicity)
	162	{
	163	delete fCorrelationMultiplicity;
	164	fCorrelationMultiplicity = 0;
	165	}
	166
	167	if (fEventCount)
	168	{
	169	delete fEventCount;
	170	fEventCount = 0;
	171	}
172
173	if (fEventCountDifferential)
174	{
175	delete fEventCountDifferential;
176	fEventCountDifferential = 0;
177	}
178
179	if (fVertexContributors)
180	{
181	delete fVertexContributors;
182	fVertexContributors = 0;
183	}
184	}
185
186	//____________________________________________________________________
187	Int_t AliUEHistograms::CountParticles(TList* list, Float_t ptMin)
188	{
189	// counts the number of particles in the list with a pT above ptMin
190	// TODO eta cut needed here?
191
192	Int_t count = 0;
193	for (Int_t j=0; j<list->GetEntries(); j++)
194	if (((AliVParticle*) list->At(j))->Pt() > ptMin)
195	count++;
196
197	return count;
198	}
199
200	//____________________________________________________________________
201	void AliUEHistograms::Fill(Int_t eventType, AliUEHist::CFStep step, AliVParticle* leading, TList* toward, TList* away, TList* min, TList* max)
202	{
203	// fills the UE event histograms
204	//
205	// this function needs the leading (track or jet or ...) and four lists of AliVParticles which contain the particles/tracks to be filled in the four regions
206
207	// if leading is not set, just fill event statistics
208	if (leading)
209	{
210	Int_t multiplicity = 0;
211
212	// TODO configurable?
213	Float_t ptMin = 0.15;
214	if (leading->Pt() > ptMin)
215	multiplicity++;
216
217	multiplicity += CountParticles(toward, ptMin);
218	multiplicity += CountParticles(away, ptMin);
219	multiplicity += CountParticles(min, ptMin);
220	multiplicity += CountParticles(max, ptMin);
221
222	FillRegion(AliUEHist::kToward, step, leading, toward, multiplicity);
223	FillRegion(AliUEHist::kAway, step, leading, away, multiplicity);
224	FillRegion(AliUEHist::kMin, step, leading, min, multiplicity);
225	FillRegion(AliUEHist::kMax, step, leading, max, multiplicity);
226
227	Double_t vars[2];
228	vars[0] = leading->Pt();
229	vars[1] = multiplicity;
230	fNumberDensitypT->GetEventHist()->Fill(vars, step);
231	fSumpT->GetEventHist()->Fill(vars, step);
232	fNumberDensityPhi->GetEventHist()->Fill(vars, step);
233
234	fEventCountDifferential->Fill(leading->Pt(), step, eventType);
235	}
236
237	FillEvent(eventType, step);
238	}
239
240	//____________________________________________________________________
241	void AliUEHistograms::FillRegion(AliUEHist::Region region, AliUEHist::CFStep step, AliVParticle* leading, TList* list, Int_t multiplicity)
242	{
243	// loops over AliVParticles in list and fills the given region at the given step
244	//
245	// See also Fill(...)
246
247	for (Int_t i=0; i<list->GetEntries(); i++)
248	{
249	AliVParticle* particle = (AliVParticle*) list->At(i);
250
251	Double_t vars[5];
252	vars[0] = particle->Eta();
253	vars[1] = particle->Pt();
254	vars[2] = leading->Pt();
255	vars[3] = multiplicity;
256	vars[4] = leading->Phi() - particle->Phi();
d4abbc90	257	if (vars[4]>TMath::Pi()/2.)vars[4]-=TMath::TwoPi();
	258	if (vars[4]< - 3.*TMath::Pi()/2.)vars[4]+=TMath::TwoPi();
	259
a75aacd6	260	fNumberDensitypT->GetTrackHist(region)->Fill(vars, step);
	261	fSumpT->GetTrackHist(region)->Fill(vars, step, particle->Pt());
	262
	263	// fill all in toward region (is anyway as function of delta phi!)
	264	fNumberDensityPhi->GetTrackHist(AliUEHist::kToward)->Fill(vars, step);
	265	}
	266	}
	267
	268	//____________________________________________________________________
	269	void AliUEHistograms::Fill(AliVParticle* leadingMC, AliVParticle* leadingReco)
	270	{
	271	// fills the correlation histograms
	272
	273	if (leadingMC)
	274	{
	275	fCorrelationpT->Fill(leadingMC->Pt(), leadingReco->Pt());
	276	if (leadingMC->Pt() > 0.5)
	277	{
	278	fCorrelationEta->Fill(leadingMC->Eta(), leadingReco->Eta());
	279	fCorrelationPhi->Fill(leadingMC->Phi(), leadingReco->Phi());
	280	}
	281
	282	Float_t phiDiff = leadingMC->Phi() - leadingReco->Phi();
	283	if (phiDiff > TMath::Pi())
	284	phiDiff -= TMath::TwoPi();
	285	if (phiDiff < -TMath::Pi())
	286	phiDiff += TMath::TwoPi();
	287
	288	Float_t etaDiff = leadingMC->Eta() - leadingReco->Eta();
	289
	290	fCorrelationR->Fill(TMath::Sqrt(phiDiff * phiDiff + etaDiff * etaDiff), leadingMC->Pt());
	291	fCorrelationLeading2Phi->Fill(phiDiff, leadingMC->Pt());
	292	}
	293	else
	294	{
	295	fCorrelationpT->Fill(1.0, leadingReco->Pt());
	296	if (leadingReco->Pt() > 0.5)
	297	{
	298	fCorrelationEta->Fill(0.0, leadingReco->Eta());
	299	fCorrelationPhi->Fill(0.0, leadingReco->Phi());
	300	}
	301	}
	302	}
	303
	304	//____________________________________________________________________
	305	void AliUEHistograms::FillEvent(Int_t eventType, Int_t step)
	306	{
	307	// fills the number of events at the given step and the given enty type
	308	//
	309	// WARNING: This function is called from Fill, so only call it for steps where Fill is not called
	310
	311	fEventCount->Fill(step, eventType);
	312	}
	313
	314	//____________________________________________________________________
	315	void AliUEHistograms::SetEtaRange(Float_t etaMin, Float_t etaMax)
	316	{
	317	// sets eta min and max for all contained AliUEHist classes
	318
	319	fNumberDensitypT->SetEtaRange(etaMin, etaMax);
	320	fSumpT->SetEtaRange(etaMin, etaMax);
	321	fNumberDensityPhi->SetEtaRange(etaMin, etaMax);
	322	}
	323
324	//____________________________________________________________________
325	void AliUEHistograms::SetPtRange(Float_t ptMin, Float_t ptMax)
326	{
327	// sets pT min and max for all contained AliUEHist classes
328
329	fNumberDensitypT->SetPtRange(ptMin, ptMax);
330	fSumpT->SetPtRange(ptMin, ptMax);
331	fNumberDensityPhi->SetPtRange(ptMin, ptMax);
332	}
333
334	//____________________________________________________________________
335	void AliUEHistograms::SetCombineMinMax(Bool_t flag)
336	{
337	// sets pT min and max for all contained AliUEHist classes
338
339	fNumberDensitypT->SetCombineMinMax(flag);
340	fSumpT->SetCombineMinMax(flag);
341	fNumberDensityPhi->SetCombineMinMax(flag);
342	}
343
344	//____________________________________________________________________
345	void AliUEHistograms::Correct(AliUEHistograms* corrections)
346	{
347	// corrects the contained histograms by calling AliUEHist::Correct
348
349	fNumberDensitypT->Correct(corrections->fNumberDensitypT);
350	fSumpT->Correct(corrections->fSumpT);
351	fNumberDensityPhi->Correct(corrections->fNumberDensityPhi);
352	}
353
354	//____________________________________________________________________
355	AliUEHistograms &AliUEHistograms::operator=(const AliUEHistograms &c)
356	{
357	// assigment operator
358
359	if (this != &c)
360	((AliUEHistograms &) c).Copy(*this);
361
362	return *this;
363	}
364
365	//____________________________________________________________________
366	void AliUEHistograms::Copy(TObject& c) const
367	{
368	// copy function
369
370	AliUEHistograms& target = (AliUEHistograms &) c;
371
372	if (fNumberDensitypT)
373	target.fNumberDensitypT = dynamic_cast<AliUEHist*> (fNumberDensitypT->Clone());
374
375	if (fSumpT)
376	target.fSumpT = dynamic_cast<AliUEHist*> (fSumpT->Clone());
377
378	if (fNumberDensityPhi)
379	target.fNumberDensityPhi = dynamic_cast<AliUEHist*> (fNumberDensityPhi->Clone());
380
381	if (fCorrelationpT)
382	target.fCorrelationpT = dynamic_cast<TH2F*> (fCorrelationpT->Clone());
383
384	if (fCorrelationEta)
385	target.fCorrelationEta = dynamic_cast<TH2F*> (fCorrelationEta->Clone());
386
387	if (fCorrelationPhi)
388	target.fCorrelationPhi = dynamic_cast<TH2F*> (fCorrelationPhi->Clone());
389
390	if (fCorrelationR)
391	target.fCorrelationR = dynamic_cast<TH2F*> (fCorrelationR->Clone());
392
393	if (fCorrelationLeading2Phi)
394	target.fCorrelationLeading2Phi = dynamic_cast<TH2F*> (fCorrelationLeading2Phi->Clone());
395
396	if (fCorrelationMultiplicity)
397	target.fCorrelationMultiplicity = dynamic_cast<TH2F*> (fCorrelationMultiplicity->Clone());
398
399	if (fEventCount)
400	target.fEventCount = dynamic_cast<TH2F*> (fEventCount->Clone());
401
402	if (fEventCountDifferential)
403	target.fEventCountDifferential = dynamic_cast<TH3F*> (fEventCountDifferential->Clone());
404
405	if (fVertexContributors)
406	target.fVertexContributors = dynamic_cast<TH1F*> (fVertexContributors->Clone());
407	}
408
409	//____________________________________________________________________
410	Long64_t AliUEHistograms::Merge(TCollection* list)
411	{
412	// Merge a list of AliUEHistograms objects with this (needed for
413	// PROOF).
414	// Returns the number of merged objects (including this).
415
416	if (!list)
417	return 0;
418
419	if (list->IsEmpty())
420	return 1;
421
422	TIterator* iter = list->MakeIterator();
423	TObject* obj;
424
425	// collections of objects
426	const Int_t kMaxLists = 12;
427	TList* lists[kMaxLists];
428
429	for (Int_t i=0; i<kMaxLists; i++)
430	lists[i] = new TList;
431
432	Int_t count = 0;
433	while ((obj = iter->Next())) {
434
435	AliUEHistograms* entry = dynamic_cast<AliUEHistograms*> (obj);
436	if (entry == 0)
437	continue;
438
439	lists[0]->Add(entry->fNumberDensitypT);
440	lists[1]->Add(entry->fSumpT);
441	lists[2]->Add(entry->fNumberDensityPhi);
442	lists[3]->Add(entry->fCorrelationpT);
443	lists[4]->Add(entry->fCorrelationEta);
444	lists[5]->Add(entry->fCorrelationPhi);
445	lists[6]->Add(entry->fCorrelationR);
446	lists[7]->Add(entry->fCorrelationLeading2Phi);
447	lists[8]->Add(entry->fCorrelationMultiplicity);
448	lists[9]->Add(entry->fEventCount);
449	lists[10]->Add(entry->fEventCountDifferential);
450	lists[11]->Add(entry->fVertexContributors);
451
452	count++;
453	}
454
455	fNumberDensitypT->Merge(lists[0]);
456	fSumpT->Merge(lists[1]);
457	fNumberDensityPhi->Merge(lists[2]);
458	fCorrelationpT->Merge(lists[3]);
459	fCorrelationEta->Merge(lists[4]);
460	fCorrelationPhi->Merge(lists[5]);
461	fCorrelationR->Merge(lists[6]);
462	fCorrelationLeading2Phi->Merge(lists[7]);
463	fCorrelationMultiplicity->Merge(lists[8]);
464	fEventCount->Merge(lists[9]);
465	fEventCountDifferential->Merge(lists[10]);
466	fVertexContributors->Merge(lists[11]);
467
468	for (Int_t i=0; i<kMaxLists; i++)
469	delete lists[i];
470
471	return count+1;
472	}