[u/mrichter/AliRoot.git] / FMD / AliFMDAnaRing.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.                  *
 **************************************************************************/
//____________________________________________________________________
//
// Utility class for analysing ESD data. 
// This class does sharing and background correction 
//
#include "AliFMDAnaRing.h"
#include <TH2.h>
#include <TMath.h>
#include <TBrowser.h>
// #include <AliLog.h>

namespace {
  Int_t   ne   = 80;
  Float_t emin = -3.7;
  Float_t emax =  5.3;
  Int_t   nm   = 100;
  Int_t   mmin = -.5;
  Int_t   mmax = 9.5;
}

//____________________________________________________________________
AliFMDAnaRing::AliFMDAnaRing()
  : fDet(0), 
    fRing('\0'), 
    fBg(0), 
    fCut0(0), 
    fCut1(0), 
    fUseBgCor(kFALSE), 
    fNSeq(0)
{
  // Default constructor.  
  // Do not use.  
  // Used by ROOT I/O
}

//____________________________________________________________________
AliFMDAnaRing::AliFMDAnaRing(UShort_t det, Char_t ring, 
			     TH2* bg, Float_t c0, Float_t c1) 
  : fDet(det), 
    fRing(ring), 
    fBg(bg), 
    fCut0(c0), 
    fCut1(c1), 
    fUseBgCor(bg ? kTRUE : kFALSE), 
    fNSeq(ring == 'I' || ring == 'i' ? 20 : 40), 
    fBareMult(Form("bareMult%d%c", fDet, fRing), "Bare multiplicity",
	      ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
    fMergedMult(Form("mergedMult%d%c", fDet, fRing), "Merged multiplicity",
		ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
    fRemovedMult(Form("removedMult%d%c", fDet, fRing), "Removed multiplicity",
		 ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
    fMult(Form("mult%d%c", fDet, fRing), "Multiplicity", 
	  ne, emin, emax, fNSeq, 0, 2*TMath::Pi()), 
    fStep1(Form("step1_%d%c",fDet,fRing), "Step 1", nm,mmin,mmax,nm,mmin,mmax),
    fStep2(Form("step2_%d%c",fDet,fRing), "Step 2", nm,mmin,mmax,nm,mmin,mmax),
    fStep3(Form("step3_%d%c",fDet,fRing), "Step 3", nm,mmin,mmax,nm,mmin,mmax)
{
  // Constructor 
  // Parameters
  //     det   Detector 
  //     ring  Ring 
  //     bg    Background 
  //     c0    Lower cut 
  //     c1    higher cut */
  fName[0] = 'F'; fName[1] = 'M'; fName[2] = 'D'; 
  fName[3] = Char_t(det+48);      fName[4] = ring; 
  fName[5] = '\0';
  fBareMult.SetDirectory(0);
  fBareMult.SetXTitle("#eta");
  fBareMult.SetYTitle("#varphi");
  fBareMult.SetZTitle("d^2M_{ch}'/d#etad#varphi");
  fMergedMult.SetDirectory(0);
  fMergedMult.SetXTitle("#eta");
  fMergedMult.SetYTitle("#varphi");
  fMergedMult.SetZTitle("d^2M_{ch}''/d#etad#varphi");
  fRemovedMult.SetDirectory(0);
  fRemovedMult.SetXTitle("#eta");
  fRemovedMult.SetYTitle("#varphi");
  fRemovedMult.SetZTitle("d^2M_{ch}'''/d#etad#varphi");
  fMult.SetDirectory(0);
  fMult.SetXTitle("#eta");
  fMult.SetYTitle("#varphi");
  fMult.SetZTitle("d^2M_{ch}/d#etad#varphi");
  fStep1.SetDirectory(0);
  fStep1.SetXTitle("Bare multiplicity");
  fStep1.SetYTitle("Merged multiplicity");
  fStep2.SetDirectory(0);
  fStep2.SetXTitle("Merged multiplicity");
  fStep2.SetYTitle("Cut multiplicity");
  fStep3.SetDirectory(0);
  fStep3.SetXTitle("Cut multiplicity");
  fStep3.SetYTitle("Multiplicity");
}

//____________________________________________________________________
AliFMDAnaRing::AliFMDAnaRing(const AliFMDAnaRing& o)
  : fDet(o.fDet), 
    fRing(o.fRing), 
    fBg(o.fBg), 
    fCut0(o.fCut0), 
    fCut1(o.fCut1), 
    fUseBgCor(o.fUseBgCor), 
    fNSeq(o.fNSeq), 
    fBareMult(o.fBareMult),
    fMergedMult(o.fMergedMult),
    fRemovedMult(o.fRemovedMult),
    fMult(o.fMult)
{
  // Copy constructor.  
  // Do not use.  
  // Used by ROOT I/O
  fBareMult.SetDirectory(0);
  fBareMult.SetXTitle("#eta");
  fBareMult.SetYTitle("#varphi");
  fBareMult.SetZTitle("dM_{ch}'/d#eta");
  fMergedMult.SetDirectory(0);
  fMergedMult.SetXTitle("#eta");
  fMergedMult.SetYTitle("#varphi");
  fMergedMult.SetZTitle("dM_{ch}''/d#eta");
  fRemovedMult.SetDirectory(0);
  fRemovedMult.SetXTitle("#eta");
  fRemovedMult.SetYTitle("#varphi");
  fRemovedMult.SetZTitle("dM_{ch}'''/d#eta");
  fMult.SetDirectory(0);
  fMult.SetXTitle("#eta");
  fMult.SetYTitle("#varphi");
  fMult.SetZTitle("dM_{ch}/d#eta");
}

//____________________________________________________________________
AliFMDAnaRing&
AliFMDAnaRing::operator=(const AliFMDAnaRing& o)
{
  // Assignment operator 
  this->fDet      = o.fDet;
  this->fRing     = o.fRing;
  this->fBg       = o.fBg;
  this->fCut0     = o.fCut0; 
  this->fCut1     = o.fCut1;
  this->fUseBgCor = o.fUseBgCor;
  this->fNSeq     = o.fNSeq;
  fBareMult.Reset();	fBareMult.Add(&o.fBareMult);
  fMergedMult.Reset();	fMergedMult.Add(&o.fMergedMult);
  fRemovedMult.Reset();	fRemovedMult.Add(&o.fRemovedMult);
  fMult.Reset();	fMult.Add(&o.fMult);
  return *this;
}


//____________________________________________________________________
Bool_t 
AliFMDAnaRing::ProcessESD(Float_t phi, Float_t eta, Float_t& m1, Float_t m2) 
{ 
  // Process ESD 
  // Parameters
  //     phi Azimuthal angle @f$ \varphi @f$ of the hit 
  //     eta Psuedo-rapidity @f$ \eta@f$ of hit
  //     m1  Multiplicity of this strip. C ontains the corrected 
  //         value on return 
  //     m2  Multiplicity of neighbor strip 
  // Return 
  //     true if hits are merged */

  // Merge shared hits 
  Bool_t  merged = false;
  Float_t sig    = m1;
  fBareMult.Fill(eta, phi, m1);
  if ((m1 < fCut0 || m2 < fCut0) && m2 > 0.001) { 
    sig = m1 + m2;
    merged = true;
    fRemovedMult.Fill(eta, phi, TMath::Min(m1,m2));
  }
  fMergedMult.Fill(eta, phi, sig);
  fStep1.Fill(m1, sig);

  // Real multiplicity 
  Double_t cmult = 1;
  if (sig < fCut0 / 2)  cmult = 0; // return merged; // cmult = 0;
  if (sig > fCut1)      cmult = 2;
  fStep2.Fill(sig, cmult);

  // Background correction
  Float_t bmult = cmult;
  if (fUseBgCor && fBg) { 
    // Float_t bgPhi = phi + (phi >  TMath::Pi() ? -2*TMath::Pi() : 0);
    Float_t bgPhi = phi - TMath::Pi();
    Int_t   bgBin = fBg->FindBin(eta, bgPhi);
    Float_t bgCor = (bgBin > 0 ? fBg->GetBinContent(bgBin) : 0);
    bmult         = (bgCor < 0.01 ? 0 : cmult / bgCor);
  }
  fStep3.Fill(cmult, bmult);
  fMult.Fill(eta, phi, bmult);

  // Call user code 
  Fill(phi, eta, bmult);
  m1 = bmult;

  return merged;
}
//____________________________________________________________________
void
AliFMDAnaRing::Finish()
{
  Double_t de    = (fMult.GetXaxis()->GetXmax() - 
		    fMult.GetXaxis()->GetXmin())/fMult.GetNbinsX(); 
  Double_t dp    = 2*TMath::Pi() / fNSeq;
  Double_t scale = ((fNEvents == 0 ? 1. : 1. / fNEvents) * 1 / de * 1 / dp);
  fBareMult.Scale(scale);
  fMergedMult.Scale(scale);
  fRemovedMult.Scale(scale);
  fMult.Scale(scale);
}
//____________________________________________________________________
Int_t  
AliFMDAnaRing::Color() const 
{ 
  // Get the ring specific color 
  switch (fDet) { 
  case 1: return kGreen + 2; 
  case 2: return kRed  + (fRing == 'I' || fRing == 'i' ? 2 : -7);
  case 3: return kBlue + (fRing == 'I' || fRing == 'i' ? 2 : -7);
  }
  return 0;
}
//____________________________________________________________________
void
AliFMDAnaRing::Browse(TBrowser* b) 
{
  b->Add(&fBareMult);
  b->Add(&fMergedMult);
  b->Add(&fRemovedMult);
  b->Add(&fMult);
  b->Add(&fStep1);
  b->Add(&fStep2);
  b->Add(&fStep3);
  if (fBg) b->Add(fBg);
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
9b98d361	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	//
	17	// Utility class for analysing ESD data.
	18	// This class does sharing and background correction
	19	//
	20	#include "AliFMDAnaRing.h"
	21	#include <TH2.h>
	22	#include <TMath.h>
	23	#include <TBrowser.h>
	24	// #include <AliLog.h>
	25
	26	namespace {
	27	Int_t ne = 80;
	28	Float_t emin = -3.7;
	29	Float_t emax = 5.3;
	30	Int_t nm = 100;
	31	Int_t mmin = -.5;
	32	Int_t mmax = 9.5;
	33	}
	34
	35	//____________________________________________________________________
	36	AliFMDAnaRing::AliFMDAnaRing()
	37	: fDet(0),
	38	fRing('\0'),
	39	fBg(0),
	40	fCut0(0),
	41	fCut1(0),
	42	fUseBgCor(kFALSE),
	43	fNSeq(0)
	44	{
	45	// Default constructor.
	46	// Do not use.
	47	// Used by ROOT I/O
	48	}
	49
	50	//____________________________________________________________________
	51	AliFMDAnaRing::AliFMDAnaRing(UShort_t det, Char_t ring,
	52	TH2* bg, Float_t c0, Float_t c1)
	53	: fDet(det),
	54	fRing(ring),
	55	fBg(bg),
	56	fCut0(c0),
	57	fCut1(c1),
	58	fUseBgCor(bg ? kTRUE : kFALSE),
	59	fNSeq(ring == 'I' \|\| ring == 'i' ? 20 : 40),
	60	fBareMult(Form("bareMult%d%c", fDet, fRing), "Bare multiplicity",
	61	ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
	62	fMergedMult(Form("mergedMult%d%c", fDet, fRing), "Merged multiplicity",
	63	ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
	64	fRemovedMult(Form("removedMult%d%c", fDet, fRing), "Removed multiplicity",
65	ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
66	fMult(Form("mult%d%c", fDet, fRing), "Multiplicity",
67	ne, emin, emax, fNSeq, 0, 2*TMath::Pi()),
68	fStep1(Form("step1_%d%c",fDet,fRing), "Step 1", nm,mmin,mmax,nm,mmin,mmax),
69	fStep2(Form("step2_%d%c",fDet,fRing), "Step 2", nm,mmin,mmax,nm,mmin,mmax),
70	fStep3(Form("step3_%d%c",fDet,fRing), "Step 3", nm,mmin,mmax,nm,mmin,mmax)
71	{
72	// Constructor
73	// Parameters
74	// det Detector
75	// ring Ring
76	// bg Background
77	// c0 Lower cut
78	// c1 higher cut */
79	fName[0] = 'F'; fName[1] = 'M'; fName[2] = 'D';
80	fName[3] = Char_t(det+48); fName[4] = ring;
81	fName[5] = '\0';
82	fBareMult.SetDirectory(0);
83	fBareMult.SetXTitle("#eta");
84	fBareMult.SetYTitle("#varphi");
85	fBareMult.SetZTitle("d^2M_{ch}'/d#etad#varphi");
86	fMergedMult.SetDirectory(0);
87	fMergedMult.SetXTitle("#eta");
88	fMergedMult.SetYTitle("#varphi");
89	fMergedMult.SetZTitle("d^2M_{ch}''/d#etad#varphi");
90	fRemovedMult.SetDirectory(0);
91	fRemovedMult.SetXTitle("#eta");
92	fRemovedMult.SetYTitle("#varphi");
93	fRemovedMult.SetZTitle("d^2M_{ch}'''/d#etad#varphi");
94	fMult.SetDirectory(0);
95	fMult.SetXTitle("#eta");
96	fMult.SetYTitle("#varphi");
97	fMult.SetZTitle("d^2M_{ch}/d#etad#varphi");
98	fStep1.SetDirectory(0);
99	fStep1.SetXTitle("Bare multiplicity");
100	fStep1.SetYTitle("Merged multiplicity");
101	fStep2.SetDirectory(0);
102	fStep2.SetXTitle("Merged multiplicity");
103	fStep2.SetYTitle("Cut multiplicity");
104	fStep3.SetDirectory(0);
105	fStep3.SetXTitle("Cut multiplicity");
106	fStep3.SetYTitle("Multiplicity");
107	}
108
109	//____________________________________________________________________
110	AliFMDAnaRing::AliFMDAnaRing(const AliFMDAnaRing& o)
111	: fDet(o.fDet),
112	fRing(o.fRing),
113	fBg(o.fBg),
114	fCut0(o.fCut0),
115	fCut1(o.fCut1),
116	fUseBgCor(o.fUseBgCor),
117	fNSeq(o.fNSeq),
118	fBareMult(o.fBareMult),
119	fMergedMult(o.fMergedMult),
120	fRemovedMult(o.fRemovedMult),
121	fMult(o.fMult)
122	{
123	// Copy constructor.
124	// Do not use.
125	// Used by ROOT I/O
126	fBareMult.SetDirectory(0);
127	fBareMult.SetXTitle("#eta");
128	fBareMult.SetYTitle("#varphi");
129	fBareMult.SetZTitle("dM_{ch}'/d#eta");
130	fMergedMult.SetDirectory(0);
131	fMergedMult.SetXTitle("#eta");
132	fMergedMult.SetYTitle("#varphi");
133	fMergedMult.SetZTitle("dM_{ch}''/d#eta");
134	fRemovedMult.SetDirectory(0);
135	fRemovedMult.SetXTitle("#eta");
136	fRemovedMult.SetYTitle("#varphi");
137	fRemovedMult.SetZTitle("dM_{ch}'''/d#eta");
138	fMult.SetDirectory(0);
139	fMult.SetXTitle("#eta");
140	fMult.SetYTitle("#varphi");
141	fMult.SetZTitle("dM_{ch}/d#eta");
142	}
143
144	//____________________________________________________________________
145	AliFMDAnaRing&
146	AliFMDAnaRing::operator=(const AliFMDAnaRing& o)
147	{
148	// Assignment operator
149	this->fDet = o.fDet;
150	this->fRing = o.fRing;
151	this->fBg = o.fBg;
152	this->fCut0 = o.fCut0;
153	this->fCut1 = o.fCut1;
154	this->fUseBgCor = o.fUseBgCor;
155	this->fNSeq = o.fNSeq;
156	fBareMult.Reset(); fBareMult.Add(&o.fBareMult);
157	fMergedMult.Reset(); fMergedMult.Add(&o.fMergedMult);
158	fRemovedMult.Reset(); fRemovedMult.Add(&o.fRemovedMult);
159	fMult.Reset(); fMult.Add(&o.fMult);
160	return *this;
161	}
162
163
164	//____________________________________________________________________
165	Bool_t
166	AliFMDAnaRing::ProcessESD(Float_t phi, Float_t eta, Float_t& m1, Float_t m2)
167	{
168	// Process ESD
169	// Parameters
170	// phi Azimuthal angle @f$ \varphi @f$ of the hit
171	// eta Psuedo-rapidity @f$ \eta@f$ of hit
172	// m1 Multiplicity of this strip. C ontains the corrected
173	// value on return
174	// m2 Multiplicity of neighbor strip
175	// Return
176	// true if hits are merged */
177
178	// Merge shared hits
179	Bool_t merged = false;
180	Float_t sig = m1;
181	fBareMult.Fill(eta, phi, m1);
182	if ((m1 < fCut0 \|\| m2 < fCut0) && m2 > 0.001) {
183	sig = m1 + m2;
184	merged = true;
185	fRemovedMult.Fill(eta, phi, TMath::Min(m1,m2));
186	}
187	fMergedMult.Fill(eta, phi, sig);
188	fStep1.Fill(m1, sig);
189
190	// Real multiplicity
191	Double_t cmult = 1;
192	if (sig < fCut0 / 2) cmult = 0; // return merged; // cmult = 0;
193	if (sig > fCut1) cmult = 2;
194	fStep2.Fill(sig, cmult);
195
196	// Background correction
197	Float_t bmult = cmult;
198	if (fUseBgCor && fBg) {
199	// Float_t bgPhi = phi + (phi > TMath::Pi() ? -2*TMath::Pi() : 0);
200	Float_t bgPhi = phi - TMath::Pi();
201	Int_t bgBin = fBg->FindBin(eta, bgPhi);
202	Float_t bgCor = (bgBin > 0 ? fBg->GetBinContent(bgBin) : 0);
203	bmult = (bgCor < 0.01 ? 0 : cmult / bgCor);
204	}
205	fStep3.Fill(cmult, bmult);
206	fMult.Fill(eta, phi, bmult);
207
208	// Call user code
209	Fill(phi, eta, bmult);
210	m1 = bmult;
211
212	return merged;
213	}
214	//____________________________________________________________________
215	void
216	AliFMDAnaRing::Finish()
217	{
218	Double_t de = (fMult.GetXaxis()->GetXmax() -
219	fMult.GetXaxis()->GetXmin())/fMult.GetNbinsX();
220	Double_t dp = 2*TMath::Pi() / fNSeq;
221	Double_t scale = ((fNEvents == 0 ? 1. : 1. / fNEvents) * 1 / de * 1 / dp);
222	fBareMult.Scale(scale);
223	fMergedMult.Scale(scale);
224	fRemovedMult.Scale(scale);
225	fMult.Scale(scale);
226	}
227	//____________________________________________________________________
228	Int_t
229	AliFMDAnaRing::Color() const
230	{
231	// Get the ring specific color
232	switch (fDet) {
233	case 1: return kGreen + 2;
234	case 2: return kRed + (fRing == 'I' \|\| fRing == 'i' ? 2 : -7);
235	case 3: return kBlue + (fRing == 'I' \|\| fRing == 'i' ? 2 : -7);
236	}
237	return 0;
238	}
239	//____________________________________________________________________
240	void
241	AliFMDAnaRing::Browse(TBrowser* b)
242	{
243	b->Add(&fBareMult);
244	b->Add(&fMergedMult);
245	b->Add(&fRemovedMult);
246	b->Add(&fMult);
247	b->Add(&fStep1);
248	b->Add(&fStep2);
249	b->Add(&fStep3);
250	if (fBg) b->Add(fBg);
251	}
252
253	//____________________________________________________________________
254	//
255	// EOF
256	//
257