New version of RALICE introduced
[u/mrichter/AliRoot.git] / RALICE / AliCalcluster.cxx
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 $Log$
18 Revision 1.2  1999/09/29 09:24:28  fca
19 Introduction of the Copyright and cvs Log
20
21 */
22
23 ///////////////////////////////////////////////////////////////////////////
24 // Class AliCalcluster
25 // Description of a cluster of calorimeter modules.
26 // A matrix geometry is assumed in which a cluster center
27 // is identified by (row,col) and contains sig as signal
28 // being the signal of the complete cluster.
29 // Some info about cluster topology is provided in order
30 // to enable EM or hadronic cluster identification.
31 //
32 //--- Author: Nick van Eijndhoven 13-jun-1997 UU-SAP Utrecht
33 //- Modified: NvE 31-oct-1999 UU-SAP Utrecht 
34 ///////////////////////////////////////////////////////////////////////////
35
36 #include "AliCalcluster.h"
37  
38 ClassImp(AliCalcluster) // Class implementation to enable ROOT I/O
39  
40 AliCalcluster::AliCalcluster()
41 {
42 // Default constructer, all data is set to 0
43  fCenter=0;
44  fSig=0.;
45  fNmods=0;
46  fSig11=0.;
47  fSig33=0.;
48  fSig55=0.;
49  fRowdisp=0.;
50  fColdisp=0.;
51  fNvetos=0;
52  fVetos=0;
53 }
54 ///////////////////////////////////////////////////////////////////////////
55 AliCalcluster::~AliCalcluster()
56 {
57 // Destructor to delete dynamically allocated memory
58  if (fVetos)
59  {
60   fVetos->Delete();
61   delete fVetos;
62   fVetos=0;
63  }
64 }
65 ///////////////////////////////////////////////////////////////////////////
66 AliCalcluster::AliCalcluster(AliCalmodule& m)
67 {
68 // Cluster constructor with module m as center.
69 // Module data is only entered for a module which contains
70 // a signal and has not been used in a cluster yet.
71 // Modules situated at a detector edge are not allowed to start a cluster.
72
73  Float_t pos[3]={0,0,0};
74
75  if ((m.GetClusteredSignal() > 0.) && (m.GetEdgeValue() == 0))
76  {
77   fCenter=&m;
78   m.GetPosition(pos,"sph");
79   SetPosition(pos,"sph");
80   fSig=m.GetClusteredSignal();
81   fNmods=1;
82   fSig11=m.GetClusteredSignal();
83   fSig33=m.GetClusteredSignal();
84   fSig55=m.GetClusteredSignal();
85   fRowdisp=0.;
86   fColdisp=0.;
87   m.SetClusteredSignal(0.); // mark module as used in cluster
88   fNvetos=0;
89   fVetos=0;
90  }
91  else
92  {
93   fCenter=0;
94   SetPosition(pos,"sph");
95   fSig=0.;
96   fNmods=0;
97   fSig11=0.;
98   fSig33=0.;
99   fSig55=0.;
100   fRowdisp=0.;
101   fColdisp=0.;
102   fNvetos=0;
103   fVetos=0;
104 }
105 }
106 ///////////////////////////////////////////////////////////////////////////
107 Int_t AliCalcluster::GetRow()
108 {
109 // Provide the row number of the cluster center
110  if (fCenter)
111  {
112   return fCenter->GetRow();
113  }
114  else
115  {
116   return 0;
117  }
118 }
119 ///////////////////////////////////////////////////////////////////////////
120 Int_t AliCalcluster::GetColumn()
121 {
122 // Provide the column number of the cluster center
123  if (fCenter)
124  {
125   return fCenter->GetColumn();
126  }
127  else
128  {
129   return 0;
130  }
131 }
132 ///////////////////////////////////////////////////////////////////////////
133 Float_t AliCalcluster::GetSignal(Int_t n)
134 {
135 // Provide the total signal of a module matrix of n modules around
136 // the cluster center.
137 // Example : n=9 --> total signal in the 3x3 matrix
138 //             1 --> signal of central module
139 // Note : n=0 provides the total cluster signal (Default)
140  
141  Float_t signal=-1;
142  
143  if (n == 0)  signal=fSig;
144  if (n == 1)  signal=fSig11;
145  if (n == 9)  signal=fSig33;
146  if (n == 25) signal=fSig55;
147  
148  if (signal > 0.)
149  {
150   return signal;
151  }
152  else
153  {
154   cout << " *AliCalcluster::GetSignal* Invalid argument n = " << n << endl;
155   return 0;
156  }
157 }
158 ///////////////////////////////////////////////////////////////////////////
159 Int_t AliCalcluster::GetNmodules()
160 {
161 // Provide the number of modules in the cluster
162  return fNmods;
163 }
164 ///////////////////////////////////////////////////////////////////////////
165 Float_t AliCalcluster::GetRowDispersion()
166 {
167 // Provide the normalised row dispersion of the cluster
168  if (fSig > 0.)
169  {
170   return fRowdisp/fSig;
171  }
172  else
173  {
174   return 0.;
175  }
176 }
177 ///////////////////////////////////////////////////////////////////////////
178 Float_t AliCalcluster::GetColumnDispersion()
179 {
180 // Provide the normalised column dispersion of the cluster
181  if (fSig > 0.)
182  {
183   return fColdisp/fSig;
184  }
185  else
186  {
187   return 0.;
188  }
189 }
190 ///////////////////////////////////////////////////////////////////////////
191 void AliCalcluster::Start(AliCalmodule& m)
192 {
193 // Reset cluster data and start with module m.
194 // A module can only start a cluster when it contains
195 // a signal, has not been used in a cluster yet, is not
196 // situated at a detector edge and is not declared dead.
197
198  Float_t pos[3]={0,0,0};
199
200  if (m.GetClusteredSignal()>0. && m.GetEdgeValue()==0 && m.GetDeadValue()==0)
201  {
202   fCenter=&m;
203   m.GetPosition(pos,"sph");
204   SetPosition(pos,"sph");
205   fSig=m.GetSignal();
206   fNmods=1;
207   fSig11=m.GetSignal();
208   fSig33=m.GetSignal();
209   fSig55=m.GetSignal();
210   fRowdisp=0.;
211   fColdisp=0.;
212   m.SetClusteredSignal(0.); // mark module as used in cluster
213  }
214  else
215  {
216   fCenter=0;
217   SetPosition(pos,"sph");
218   fSig=0.;
219   fNmods=0;
220   fSig11=0.;
221   fSig33=0.;
222   fSig55=0.;
223   fRowdisp=0.;
224   fColdisp=0.;
225  }
226 }
227 ///////////////////////////////////////////////////////////////////////////
228 void AliCalcluster::Add(AliCalmodule& m)
229 {
230 // Add module data to the cluster
231
232  Float_t signal=m.GetClusteredSignal();
233  
234  if (signal > 0.) // only add unused modules
235  {
236   fSig+=signal;
237   fNmods+=1;
238   Int_t drow=int(fabs(double(GetRow()-m.GetRow())));       // row distance to center
239   Int_t dcol=int(fabs(double(GetColumn()-m.GetColumn()))); // column distance to center
240   if ((drow < 2) && (dcol < 2)) fSig33+=signal;
241   if ((drow < 3) && (dcol < 3)) fSig55+=signal;
242   fRowdisp+=signal*float(drow*drow);
243   fColdisp+=signal*float(dcol*dcol);
244   m.SetClusteredSignal(0.); // mark module as used in cluster
245  }
246 }
247 ///////////////////////////////////////////////////////////////////////////
248 void AliCalcluster::AddVetoSignal(Float_t* r,TString f,Float_t s)
249 {
250 // Associate an (extrapolated) AliSignal at location r as veto to the cluster.
251 // The signal value s indicates the confidence level of hit association
252 // and has to be provided by the user.
253 // Note : The default signal value (s) is 0
254  if (!fVetos)
255  {
256   fNvetos=0;
257   fVetos=new TObjArray();
258  } 
259
260  fVetos->Add(new AliSignal(1));
261  fNvetos++;
262
263  ((AliSignal*)fVetos->At(fNvetos-1))->SetPosition(r,f);
264  ((AliSignal*)fVetos->At(fNvetos-1))->SetSignal(s);
265 }
266 ///////////////////////////////////////////////////////////////////////////
267 Int_t AliCalcluster::GetNvetos()
268 {
269 // Provide the number of veto signals associated to the cluster
270  return fNvetos;
271 }
272 ///////////////////////////////////////////////////////////////////////////
273 AliSignal* AliCalcluster::GetVetoSignal(Int_t i)
274 {
275 // Provide access to the i-th veto signal of this cluster.
276 // Note : The first hit corresponds to i=1.
277
278  if (i>0 && i<=fNvetos)
279  {
280   return (AliSignal*)fVetos->At(i-1);
281  }
282  else
283  {
284   cout << " *AliCalcluster::GetVetoSignal* Signal number " << i
285        << " out of range." << endl;
286   cout << " --- First signal (if any) returned." << endl;
287   return (AliSignal*)fVetos->At(0);
288  }
289 }
290 ///////////////////////////////////////////////////////////////////////////
291 Float_t AliCalcluster::GetVetoLevel()
292 {
293 // Provide the confidence level of best associated veto signal.
294  Float_t cl=0;
295  Float_t clmax=0;
296  if (fVetos)
297  {
298   for (Int_t i=0; i<fNvetos; i++)
299   {
300    cl=((AliSignal*)fVetos->At(i))->GetSignal();
301    if (cl>clmax) clmax=cl;
302   }
303  }
304  return clmax;
305 }
306 ///////////////////////////////////////////////////////////////////////////
307 Int_t AliCalcluster::HasVetoHit(Double_t cl)
308 {
309 // Investigate if cluster has an associated veto hit with conf. level > cl.
310 // Returns 1 if there is such an associated veto hit, otherwise returns 0.
311 // Note : This function is faster than GetVetoLevel().
312  if (fVetos)
313  {
314   for (Int_t i=0; i<fNvetos; i++)
315   {
316    if (((AliSignal*)fVetos->At(i))->GetSignal() > cl) return 1;
317   }
318  }
319  return 0;
320 }
321 ///////////////////////////////////////////////////////////////////////////