[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliBaseMCTrackDensity.cxx

#include "AliBaseMCTrackDensity.h"
#include <AliMCEvent.h>
#include <AliTrackReference.h>
#include <AliStack.h>
#include <TMath.h>
#include <AliLog.h>
#include <TH2D.h>
#include <TH1D.h>
#include <TList.h>
#include <TROOT.h>
#include <iostream>
#include "AliCollisionGeometry.h"
#include "AliGenEventHeader.h"
#include "AliForwardUtil.h"
#include <TF1.h>
#include <TGraph.h>

//____________________________________________________________________
AliBaseMCTrackDensity::AliBaseMCTrackDensity()
  : TNamed(), 
    fUseOnlyPrimary(false), 
    fUseFlowWeights(false),
    fBinFlow(0), 
    fEtaBinFlow(0),
    fPhiBinFlow(0),
    fNRefs(0),
    fWeights(),
    fVz(0), 
    fB(0),
    fPhiR(0),
    fDebug(false)
{
  // Default constructor 
  DGUARD(fDebug, 3,"Default CTOR of AliBasMCTrackDensity");
}

//____________________________________________________________________
AliBaseMCTrackDensity::AliBaseMCTrackDensity(const char* name)
  : TNamed(name,"mcTrackDensity"), 
    fUseOnlyPrimary(false), 
    fUseFlowWeights(false),
    fBinFlow(0), 
    fEtaBinFlow(0),
    fPhiBinFlow(0),
    fNRefs(0),
    fWeights(),
    fVz(0), 
    fB(0),
    fPhiR(0),
    fDebug(false)
{
  // Normal constructor constructor 
  DGUARD(fDebug, 3,"Named CTOR of AliBasMCTrackDensity: %s", name);
}

//____________________________________________________________________
AliBaseMCTrackDensity::AliBaseMCTrackDensity(const AliBaseMCTrackDensity& o)
  : TNamed(o),
    fUseOnlyPrimary(o.fUseOnlyPrimary), 
    fUseFlowWeights(o.fUseFlowWeights),
    fBinFlow(o.fBinFlow), 
    fEtaBinFlow(o.fEtaBinFlow),
    fPhiBinFlow(o.fPhiBinFlow),
    fNRefs(o.fNRefs),
    fWeights(o.fWeights),
    fVz(o.fVz), 
    fB(o.fB),
    fPhiR(o.fPhiR),
    fDebug(o.fDebug)
{
  // Normal constructor constructor 
  DGUARD(fDebug, 3,"Copy CTOR of AliBasMCTrackDensity");
}

//____________________________________________________________________
AliBaseMCTrackDensity&
AliBaseMCTrackDensity::operator=(const AliBaseMCTrackDensity& o)
{
  // Assignment operator 
  DGUARD(fDebug,3,"MC track density assignmetn");
  if (&o == this) return *this; 
  TNamed::operator=(o);
  fUseOnlyPrimary       = o.fUseOnlyPrimary;
  fBinFlow              = o.fBinFlow;
  fEtaBinFlow           = o.fEtaBinFlow;
  fPhiBinFlow           = o.fPhiBinFlow;
  fNRefs                = o.fNRefs;
  fDebug                = o.fDebug;
  fUseFlowWeights       = o.fUseFlowWeights;
  fWeights              = o.fWeights;
  fVz                   = o.fVz;
  fB                    = o.fB;
  fPhiR                 = o.fPhiR;
  return *this;
}

//____________________________________________________________________
void
AliBaseMCTrackDensity::CreateOutputObjects(TList* l)
{
  DGUARD(fDebug,1,"MC track defines output");
  TList* ll = new TList;
  ll->SetName(GetTitle());
  ll->SetOwner();
  l->Add(ll);
  
  fBinFlow = new TH2D("binFlow", "#eta and #varphi bin flow", 
		      200, -5, 5, 40, -180, 180);
  fBinFlow->SetXTitle("#Delta#eta");
  fBinFlow->SetYTitle("#Delta#varphi");
  fBinFlow->SetOption("colz");
  fBinFlow->SetDirectory(0);
  ll->Add(fBinFlow);

  fEtaBinFlow = new TH2D("binFlowEta", "#eta bin flow vs #eta", 
			 200, -4, 6, 200, -5, 5);
  fEtaBinFlow->SetXTitle("#eta");
  fEtaBinFlow->SetYTitle("#Delta#eta");
  fEtaBinFlow->SetOption("colz");
  fEtaBinFlow->SetDirectory(0);
  ll->Add(fEtaBinFlow);

  fPhiBinFlow = new TH2D("binFlowPhi", "#phi bin flow vs #phi", 
			 40, 0, 360, 40, -180, 180);
  fPhiBinFlow->SetXTitle("#varphi");
  fPhiBinFlow->SetYTitle("#Delta#varphi");
  fPhiBinFlow->SetOption("colz");
  fPhiBinFlow->SetDirectory(0);
  ll->Add(fPhiBinFlow);

  fNRefs = new TH1D("nRefs", "# references per track", 21, -.5, 20.5);
  fNRefs->SetXTitle("# references");
  fNRefs->SetFillColor(kMagenta+1);
  fNRefs->SetFillStyle(3001);
  fNRefs->SetDirectory(0);
  ll->Add(fNRefs);
  
  fWeights.Init(ll);
}


//____________________________________________________________________
Double_t
AliBaseMCTrackDensity::StoreParticle(AliMCParticle*       particle, 
				     const AliMCParticle* mother, 
				     AliTrackReference*   ref) const
{
  DGUARD(fDebug,3,"MC track density store particle");
  // Store a particle. 
  if (!ref) return 0;

  Double_t weight = 1;
  if (fUseFlowWeights) {
    Double_t phi = (mother ? mother->Phi() : particle->Phi());
    Double_t eta = (mother ? mother->Eta() : particle->Eta());
    Double_t pt  = (mother ? mother->Pt() : particle->Pt());
    Int_t    id  = (mother ? mother->PdgCode() : 2212);
    weight       = CalculateWeight(eta, pt, phi, id);
  }

  // Get track-reference stuff 
  Double_t x      = ref->X();
  Double_t y      = ref->Y();
  Double_t z      = ref->Z()-fVz;
  Double_t rr     = TMath::Sqrt(x*x+y*y);
  Double_t thetaR = TMath::ATan2(rr,z);
  Double_t phiR   = TMath::ATan2(y,x);
  Double_t etaR   = -TMath::Log(TMath::Tan(thetaR/2));
  
  // Correct angle and convert to degrees 
  if (thetaR < 0) thetaR += 2*TMath::Pi();
  thetaR *= 180. / TMath::Pi();
  if (phiR < 0) phiR += 2*TMath::Pi();
  phiR *= 180. / TMath::Pi();

  const AliMCParticle* mp = (mother ? mother : particle);
  Double_t dEta = mp->Eta() - etaR;
  Double_t dPhi = mp->Phi() * 180 / TMath::Pi() - phiR;
  if (dPhi >  180) dPhi -= 360;
  if (dPhi < -180) dPhi += 360;
  fBinFlow->Fill(dEta, dPhi);
  fEtaBinFlow->Fill(etaR, dEta);
  fPhiBinFlow->Fill(phiR, dPhi);

  return weight;
}

//____________________________________________________________________
Double_t
AliBaseMCTrackDensity::GetTrackRefTheta(const AliTrackReference* ref) const
{
  // Get the incidient angle of the track reference. 
  Double_t x    = ref->X();
  Double_t y    = ref->Y();
  Double_t z    = ref->Z()-fVz;
  Double_t rr   = TMath::Sqrt(x*x+y*y);
  Double_t theta= TMath::ATan2(rr,z);
  Double_t ang  = TMath::Abs(TMath::Pi()-theta);
  return ang;
}
				    
//____________________________________________________________________
const AliMCParticle*
AliBaseMCTrackDensity::GetMother(Int_t     iTr,
				const AliMCEvent& event) const
{
  // 
  // Track down primary mother 
  // 
  Int_t i  = iTr;
  do { 
    const AliMCParticle* p = static_cast<AliMCParticle*>(event.GetTrack(i));
    if (const_cast<AliMCEvent&>(event).Stack()->IsPhysicalPrimary(i)) return p;
    
    i = p->GetMother();
  } while (i > 0);

  return 0;
}  

//____________________________________________________________________
Bool_t
AliBaseMCTrackDensity::GetCollisionParameters(const AliMCEvent& event)
{ 
  DGUARD(fDebug,3,"MC track density get collision parameters");
  AliCollisionGeometry* hd = 
    dynamic_cast<AliCollisionGeometry*>(event.GenEventHeader());
  fPhiR = (hd ? hd->ReactionPlaneAngle() : 0.);
  fB    = (hd ? hd->ImpactParameter() : -1 );
  return hd != 0;
}

//____________________________________________________________________
Bool_t
AliBaseMCTrackDensity::ProcessTrack(AliMCParticle* particle, 
				    const AliMCParticle* mother)
{
  // Check the returned particle 
  DGUARD(fDebug,3,"MC track density Process a track");
  if (!particle) return false;
    
  Int_t              nTrRef = particle->GetNumberOfTrackReferences();
  AliTrackReference* store  = 0;

  BeginTrackRefs();

  // Double_t oTheta= 0;
  Int_t nRefs = 0;
  for (Int_t iTrRef = 0; iTrRef < nTrRef; iTrRef++) { 
    AliTrackReference* ref = particle->GetTrackReference(iTrRef);
      
    // Check existence 
    if (!ref) continue;

    // Check that we hit an Base element 
    if (ref->DetectorId() != GetDetectorId()) continue;
    if (!CheckTrackRef(ref)) continue;

    nRefs++;

    AliTrackReference* test = ProcessRef(particle, mother, ref);
    if (test) store = test;

  } // Loop over track references
  if (!store) return true; // Nothing found
  
  StoreParticle(particle, mother, store);

  fNRefs->Fill(nRefs);

  EndTrackRefs(nRefs);

  return true;
}


//____________________________________________________________________
Bool_t
AliBaseMCTrackDensity::ProcessTracks(const AliMCEvent& event,
				     Double_t          vz,
				     TH2D*             primary)
{
  // 
  // Filter the input kinematics and track references, using 
  // some of the ESD information
  // 
  // Parameters:
  //    input   Input ESD event
  //    event   Input MC event
  //    vz      Vertex position 
  //    output  Output ESD-like object
  //    primary Per-event histogram of primaries 
  //
  // Return:
  //    True on succes, false otherwise 
  //
  DGUARD(fDebug,3,"MC track density Process a tracks");
  fVz = vz;
  GetCollisionParameters(event);
  
  AliStack* stack = const_cast<AliMCEvent&>(event).Stack();
  Int_t nTracks   = stack->GetNtrack();//event.GetNumberOfTracks();
  Int_t nPrim     = stack->GetNprimary();//event.GetNumberOfPrimary();
  for (Int_t iTr = 0; iTr < nTracks; iTr++) { 
    AliMCParticle* particle = 
      static_cast<AliMCParticle*>(event.GetTrack(iTr));
    
    // Check if this charged and a primary 
    if (!particle->Charge() != 0) continue;
    
    Bool_t isPrimary = stack->IsPhysicalPrimary(iTr) && iTr < nPrim;
    
    // Fill 'dn/deta' histogram 
    if (isPrimary && primary) 
      primary->Fill(particle->Eta(), particle->Phi());

    // Bail out if we're only processing primaries - perhaps we should
    // track back to the original primary?
    if (fUseOnlyPrimary && !isPrimary) continue;

    const AliMCParticle* mother = isPrimary ? particle : GetMother(iTr, event);
    ProcessTrack(particle, mother);

  } // Loop over tracks
  return kTRUE;
}

  
//____________________________________________________________________
Double_t
AliBaseMCTrackDensity::CalculateWeight(Double_t eta, Double_t pt, 
				       Double_t phi, Int_t id) const
{
  return fWeights.CalcWeight(eta, pt, phi, id, fPhiR, fB);
}

#define PF(N,V,...)					\
  AliForwardUtil::PrintField(N,V, ## __VA_ARGS__)
#define PFB(N,FLAG)				\
  do {									\
    AliForwardUtil::PrintName(N);					\
    std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
  } while(false)
#define PFV(N,VALUE)					\
  do {							\
    AliForwardUtil::PrintName(N);			\
    std::cout << (VALUE) << std::endl; } while(false)

//____________________________________________________________________
void
AliBaseMCTrackDensity::Print(Option_t* /*option*/) const 
{
  AliForwardUtil::PrintTask(*this);
  gROOT->IncreaseDirLevel();  
  PFB("Only primary tracks", fUseOnlyPrimary);
  PFB("Use flow after burner", fUseFlowWeights);
  gROOT->DecreaseDirLevel();
  
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
4bcdcbc1	1	#include "AliBaseMCTrackDensity.h"
	2	#include <AliMCEvent.h>
	3	#include <AliTrackReference.h>
	4	#include <AliStack.h>
	5	#include <TMath.h>
	6	#include <AliLog.h>
	7	#include <TH2D.h>
	8	#include <TH1D.h>
	9	#include <TList.h>
	10	#include <TROOT.h>
	11	#include <iostream>
	12	#include "AliCollisionGeometry.h"
	13	#include "AliGenEventHeader.h"
f53fb4f6	14	#include "AliForwardUtil.h"
4bcdcbc1	15	#include <TF1.h>
	16	#include <TGraph.h>
	17
	18	//____________________________________________________________________
	19	AliBaseMCTrackDensity::AliBaseMCTrackDensity()
	20	: TNamed(),
	21	fUseOnlyPrimary(false),
	22	fUseFlowWeights(false),
	23	fBinFlow(0),
	24	fEtaBinFlow(0),
	25	fPhiBinFlow(0),
	26	fNRefs(0),
936b0a6c	27	fWeights(),
4bcdcbc1	28	fVz(0),
	29	fB(0),
	30	fPhiR(0),
	31	fDebug(false)
	32	{
	33	// Default constructor
5ca83fee	34	DGUARD(fDebug, 3,"Default CTOR of AliBasMCTrackDensity");
4bcdcbc1	35	}
	36
	37	//____________________________________________________________________
	38	AliBaseMCTrackDensity::AliBaseMCTrackDensity(const char* name)
	39	: TNamed(name,"mcTrackDensity"),
	40	fUseOnlyPrimary(false),
	41	fUseFlowWeights(false),
	42	fBinFlow(0),
	43	fEtaBinFlow(0),
	44	fPhiBinFlow(0),
	45	fNRefs(0),
936b0a6c	46	fWeights(),
4bcdcbc1	47	fVz(0),
	48	fB(0),
	49	fPhiR(0),
	50	fDebug(false)
	51	{
	52	// Normal constructor constructor
5ca83fee	53	DGUARD(fDebug, 3,"Named CTOR of AliBasMCTrackDensity: %s", name);
4bcdcbc1	54	}
	55
	56	//____________________________________________________________________
	57	AliBaseMCTrackDensity::AliBaseMCTrackDensity(const AliBaseMCTrackDensity& o)
	58	: TNamed(o),
	59	fUseOnlyPrimary(o.fUseOnlyPrimary),
	60	fUseFlowWeights(o.fUseFlowWeights),
	61	fBinFlow(o.fBinFlow),
	62	fEtaBinFlow(o.fEtaBinFlow),
	63	fPhiBinFlow(o.fPhiBinFlow),
	64	fNRefs(o.fNRefs),
936b0a6c	65	fWeights(o.fWeights),
4bcdcbc1	66	fVz(o.fVz),
	67	fB(o.fB),
	68	fPhiR(o.fPhiR),
	69	fDebug(o.fDebug)
	70	{
	71	// Normal constructor constructor
5ca83fee	72	DGUARD(fDebug, 3,"Copy CTOR of AliBasMCTrackDensity");
4bcdcbc1	73	}
	74
	75	//____________________________________________________________________
	76	AliBaseMCTrackDensity&
	77	AliBaseMCTrackDensity::operator=(const AliBaseMCTrackDensity& o)
	78	{
	79	// Assignment operator
f53fb4f6	80	DGUARD(fDebug,3,"MC track density assignmetn");
4bcdcbc1	81	if (&o == this) return *this;
	82	TNamed::operator=(o);
	83	fUseOnlyPrimary = o.fUseOnlyPrimary;
	84	fBinFlow = o.fBinFlow;
	85	fEtaBinFlow = o.fEtaBinFlow;
	86	fPhiBinFlow = o.fPhiBinFlow;
	87	fNRefs = o.fNRefs;
	88	fDebug = o.fDebug;
	89	fUseFlowWeights = o.fUseFlowWeights;
936b0a6c	90	fWeights = o.fWeights;
4bcdcbc1	91	fVz = o.fVz;
	92	fB = o.fB;
	93	fPhiR = o.fPhiR;
	94	return *this;
	95	}
	96
	97	//____________________________________________________________________
	98	void
5934a3e3	99	AliBaseMCTrackDensity::CreateOutputObjects(TList* l)
4bcdcbc1	100	{
f53fb4f6	101	DGUARD(fDebug,1,"MC track defines output");
4bcdcbc1	102	TList* ll = new TList;
	103	ll->SetName(GetTitle());
	104	ll->SetOwner();
	105	l->Add(ll);
	106
	107	fBinFlow = new TH2D("binFlow", "#eta and #varphi bin flow",
	108	200, -5, 5, 40, -180, 180);
	109	fBinFlow->SetXTitle("#Delta#eta");
	110	fBinFlow->SetYTitle("#Delta#varphi");
	111	fBinFlow->SetOption("colz");
	112	fBinFlow->SetDirectory(0);
	113	ll->Add(fBinFlow);
	114
	115	fEtaBinFlow = new TH2D("binFlowEta", "#eta bin flow vs #eta",
	116	200, -4, 6, 200, -5, 5);
	117	fEtaBinFlow->SetXTitle("#eta");
	118	fEtaBinFlow->SetYTitle("#Delta#eta");
	119	fEtaBinFlow->SetOption("colz");
	120	fEtaBinFlow->SetDirectory(0);
	121	ll->Add(fEtaBinFlow);
	122
	123	fPhiBinFlow = new TH2D("binFlowPhi", "#phi bin flow vs #phi",
	124	40, 0, 360, 40, -180, 180);
	125	fPhiBinFlow->SetXTitle("#varphi");
	126	fPhiBinFlow->SetYTitle("#Delta#varphi");
	127	fPhiBinFlow->SetOption("colz");
	128	fPhiBinFlow->SetDirectory(0);
	129	ll->Add(fPhiBinFlow);
	130
	131	fNRefs = new TH1D("nRefs", "# references per track", 21, -.5, 20.5);
	132	fNRefs->SetXTitle("# references");
	133	fNRefs->SetFillColor(kMagenta+1);
	134	fNRefs->SetFillStyle(3001);
	135	fNRefs->SetDirectory(0);
	136	ll->Add(fNRefs);
936b0a6c	137
936b0a6c	138	fWeights.Init(ll);
4bcdcbc1	139	}
	140
	141
	142	//____________________________________________________________________
	143	Double_t
	144	AliBaseMCTrackDensity::StoreParticle(AliMCParticle* particle,
	145	const AliMCParticle* mother,
	146	AliTrackReference* ref) const
	147	{
f53fb4f6	148	DGUARD(fDebug,3,"MC track density store particle");
4bcdcbc1	149	// Store a particle.
	150	if (!ref) return 0;
	151
	152	Double_t weight = 1;
	153	if (fUseFlowWeights) {
	154	Double_t phi = (mother ? mother->Phi() : particle->Phi());
	155	Double_t eta = (mother ? mother->Eta() : particle->Eta());
	156	Double_t pt = (mother ? mother->Pt() : particle->Pt());
	157	Int_t id = (mother ? mother->PdgCode() : 2212);
	158	weight = CalculateWeight(eta, pt, phi, id);
	159	}
	160
	161	// Get track-reference stuff
	162	Double_t x = ref->X();
	163	Double_t y = ref->Y();
	164	Double_t z = ref->Z()-fVz;
	165	Double_t rr = TMath::Sqrt(xx+yy);
	166	Double_t thetaR = TMath::ATan2(rr,z);
	167	Double_t phiR = TMath::ATan2(y,x);
	168	Double_t etaR = -TMath::Log(TMath::Tan(thetaR/2));
	169
	170	// Correct angle and convert to degrees
	171	if (thetaR < 0) thetaR += 2*TMath::Pi();
	172	thetaR *= 180. / TMath::Pi();
	173	if (phiR < 0) phiR += 2*TMath::Pi();
	174	phiR *= 180. / TMath::Pi();
	175
	176	const AliMCParticle* mp = (mother ? mother : particle);
	177	Double_t dEta = mp->Eta() - etaR;
	178	Double_t dPhi = mp->Phi() * 180 / TMath::Pi() - phiR;
	179	if (dPhi > 180) dPhi -= 360;
	180	if (dPhi < -180) dPhi += 360;
	181	fBinFlow->Fill(dEta, dPhi);
	182	fEtaBinFlow->Fill(etaR, dEta);
	183	fPhiBinFlow->Fill(phiR, dPhi);
	184
	185	return weight;
	186	}
	187
	188	//____________________________________________________________________
	189	Double_t
	190	AliBaseMCTrackDensity::GetTrackRefTheta(const AliTrackReference* ref) const
	191	{
	192	// Get the incidient angle of the track reference.
	193	Double_t x = ref->X();
	194	Double_t y = ref->Y();
	195	Double_t z = ref->Z()-fVz;
	196	Double_t rr = TMath::Sqrt(xx+yy);
	197	Double_t theta= TMath::ATan2(rr,z);
	198	Double_t ang = TMath::Abs(TMath::Pi()-theta);
	199	return ang;
	200	}
	201
	202	//____________________________________________________________________
	203	const AliMCParticle*
	204	AliBaseMCTrackDensity::GetMother(Int_t iTr,
	205	const AliMCEvent& event) const
	206	{
	207	//
	208	// Track down primary mother
	209	//
	210	Int_t i = iTr;
	211	do {
	212	const AliMCParticle* p = static_cast<AliMCParticle*>(event.GetTrack(i));
213	if (const_cast<AliMCEvent&>(event).Stack()->IsPhysicalPrimary(i)) return p;
214
215	i = p->GetMother();
216	} while (i > 0);
217
218	return 0;
219	}
220
221	//____________________________________________________________________
222	Bool_t
223	AliBaseMCTrackDensity::GetCollisionParameters(const AliMCEvent& event)
224	{
f53fb4f6	225	DGUARD(fDebug,3,"MC track density get collision parameters");
4bcdcbc1	226	AliCollisionGeometry* hd =
	227	dynamic_cast<AliCollisionGeometry*>(event.GenEventHeader());
	228	fPhiR = (hd ? hd->ReactionPlaneAngle() : 0.);
	229	fB = (hd ? hd->ImpactParameter() : -1 );
	230	return hd != 0;
	231	}
	232
	233	//____________________________________________________________________
	234	Bool_t
	235	AliBaseMCTrackDensity::ProcessTrack(AliMCParticle* particle,
	236	const AliMCParticle* mother)
	237	{
	238	// Check the returned particle
f53fb4f6	239	DGUARD(fDebug,3,"MC track density Process a track");
4bcdcbc1	240	if (!particle) return false;
	241
	242	Int_t nTrRef = particle->GetNumberOfTrackReferences();
	243	AliTrackReference* store = 0;
	244
	245	BeginTrackRefs();
	246
	247	// Double_t oTheta= 0;
	248	Int_t nRefs = 0;
	249	for (Int_t iTrRef = 0; iTrRef < nTrRef; iTrRef++) {
	250	AliTrackReference* ref = particle->GetTrackReference(iTrRef);
	251
	252	// Check existence
	253	if (!ref) continue;
	254
	255	// Check that we hit an Base element
	256	if (ref->DetectorId() != GetDetectorId()) continue;
	257	if (!CheckTrackRef(ref)) continue;
	258
	259	nRefs++;
	260
	261	AliTrackReference* test = ProcessRef(particle, mother, ref);
	262	if (test) store = test;
	263
	264	} // Loop over track references
	265	if (!store) return true; // Nothing found
	266
	267	StoreParticle(particle, mother, store);
	268
	269	fNRefs->Fill(nRefs);
	270
	271	EndTrackRefs(nRefs);
	272
	273	return true;
	274	}
	275
	276
	277	//____________________________________________________________________
	278	Bool_t
	279	AliBaseMCTrackDensity::ProcessTracks(const AliMCEvent& event,
	280	Double_t vz,
	281	TH2D* primary)
	282	{
	283	//
	284	// Filter the input kinematics and track references, using
	285	// some of the ESD information
	286	//
	287	// Parameters:
	288	// input Input ESD event
	289	// event Input MC event
	290	// vz Vertex position
	291	// output Output ESD-like object
	292	// primary Per-event histogram of primaries
	293	//
	294	// Return:
	295	// True on succes, false otherwise
	296	//
f53fb4f6	297	DGUARD(fDebug,3,"MC track density Process a tracks");
4bcdcbc1	298	fVz = vz;
	299	GetCollisionParameters(event);
	300
	301	AliStack* stack = const_cast<AliMCEvent&>(event).Stack();
	302	Int_t nTracks = stack->GetNtrack();//event.GetNumberOfTracks();
	303	Int_t nPrim = stack->GetNprimary();//event.GetNumberOfPrimary();
	304	for (Int_t iTr = 0; iTr < nTracks; iTr++) {
	305	AliMCParticle* particle =
	306	static_cast<AliMCParticle*>(event.GetTrack(iTr));
	307
	308	// Check if this charged and a primary
	309	if (!particle->Charge() != 0) continue;
	310
	311	Bool_t isPrimary = stack->IsPhysicalPrimary(iTr) && iTr < nPrim;
	312
	313	// Fill 'dn/deta' histogram
	314	if (isPrimary && primary)
	315	primary->Fill(particle->Eta(), particle->Phi());
	316
	317	// Bail out if we're only processing primaries - perhaps we should
	318	// track back to the original primary?
	319	if (fUseOnlyPrimary && !isPrimary) continue;
	320
7a3e34f4	321	const AliMCParticle* mother = isPrimary ? particle : GetMother(iTr, event);
4bcdcbc1	322	ProcessTrack(particle, mother);
	323
	324	} // Loop over tracks
	325	return kTRUE;
	326	}
	327
	328
	329	//____________________________________________________________________
	330	Double_t
	331	AliBaseMCTrackDensity::CalculateWeight(Double_t eta, Double_t pt,
	332	Double_t phi, Int_t id) const
	333	{
936b0a6c	334	return fWeights.CalcWeight(eta, pt, phi, id, fPhiR, fB);
4bcdcbc1	335	}
c8b1a7db	336
	337	#define PF(N,V,...) \
	338	AliForwardUtil::PrintField(N,V, ## __VA_ARGS__)
	339	#define PFB(N,FLAG) \
	340	do { \
	341	AliForwardUtil::PrintName(N); \
	342	std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
	343	} while(false)
	344	#define PFV(N,VALUE) \
	345	do { \
	346	AliForwardUtil::PrintName(N); \
	347	std::cout << (VALUE) << std::endl; } while(false)
	348
4bcdcbc1	349	//____________________________________________________________________
	350	void
	351	AliBaseMCTrackDensity::Print(Option_t* /option/) const
	352	{
c8b1a7db	353	AliForwardUtil::PrintTask(*this);
	354	gROOT->IncreaseDirLevel();
	355	PFB("Only primary tracks", fUseOnlyPrimary);
	356	PFB("Use flow after burner", fUseFlowWeights);
	357	gROOT->DecreaseDirLevel();
4bcdcbc1	358
	359	}
	360
	361	//____________________________________________________________________
	362	//
	363	// EOF
	364	//