fixing small memory leak
[u/mrichter/AliRoot.git] / PHOS / AliPHOSRecCpvManager.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 /* $Id$ */
17
18 //_________________________________________________________________________
19 // Class for the management by the CPV reconstruction.
20 ////                  
21 //*-- Author   : Boris Polichtchouk (IHEP, Protvino) 6 Mar 2001
22 //
23 // --- ROOT system ---
24
25 #include <TMath.h>
26
27 // --- Standard library ---
28
29 // --- AliRoot header files ---
30
31 #include "AliPHOSRecCpvManager.h"
32 #include "AliPHOSGeometry.h" 
33
34 ClassImp(AliPHOSRecCpvManager) 
35
36 //____________________________________________________________________________
37 AliPHOSRecCpvManager::AliPHOSRecCpvManager() :
38   fOneGamChisqCut(3.),
39   fOneGamInitialStep(0.00005),
40   fOneGamChisqMin(1.),
41   fOneGamStepMin(0.0005),
42   fOneGamNumOfIterations(50),
43   fTwoGamInitialStep(0.00005),
44   fTwoGamChisqMin(1.),
45   fTwoGamEmin(0.1),
46   fTwoGamStepMin(0.00005),
47   fTwoGamNumOfIterations(50),  
48   fThr0(0.),
49   fSqdCut(0.) 
50 {
51   // Put a comment here
52   SetTitle("Cpv Reconstruction Manager");
53 }
54
55 AliPHOSRecCpvManager::~AliPHOSRecCpvManager(void) 
56 {
57   // Put a comment here
58 }
59
60 Float_t AliPHOSRecCpvManager::Dispersion(Float_t etot, Float_t ai) const
61 {
62   //"Dispresion" of energy deposition in the cell.
63   // etot is the total shower energy, ai is the
64   // calculated cell response,
65   // ei is the measured cell response.
66
67   const Float_t kConst = 1.5;
68   return kConst*ai*(1.-ai/etot);
69 }
70
71 Float_t AliPHOSRecCpvManager::OneGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& Gi) const
72 {
73   //"Chi2" for one cell.
74   // etot is the total "shower" energy, ai is the
75   // calculated cell response,
76   // ei is the measured cell response.
77
78   const Float_t kConst = 1.5;
79
80   Float_t da = ai - ei;
81   Float_t d = kConst*ai*(1.-ai/etot);
82
83   Float_t dd = da/d;
84   Gi = dd*(2.- dd*kConst*(1.-2.*ai/etot));
85
86   Info("OneGamChi2", " OneGamChi2 (ai,ei,etot,&Gi,chi2) %f %f %f %f %f", ai, ei, etot, Gi, da*da/d );
87
88   return da*da/d;
89
90 }
91
92 Float_t AliPHOSRecCpvManager::TwoGamChi2(Float_t ai, Float_t ei, Float_t etot, Float_t& gi) const 
93 {
94   // Put a comment here
95
96   const Float_t kConst = 1.5;
97
98   Float_t da = ai - ei;
99   Float_t d = kConst*ai*(1.-ai/etot);
100
101   Float_t dd = da/d;
102   gi = dd*(2.- dd*kConst*(1.-2.*ai/etot));
103
104   return da*da/d;
105  
106 }
107
108 void AliPHOSRecCpvManager::AG(Float_t ei, Float_t xi, Float_t yi, Float_t& ai, Float_t& gxi, Float_t& gyi )
109 {
110   //Calculates amplitude (ai) and gradients (gxi, gyi) of CPV pad response.
111   //Integrated response (total "shower energy") is e, 
112   //xi and yi are the distances along x and y from reference point 
113   // to the pad center.
114
115   AliPHOSGeometry * geom =  AliPHOSGeometry::GetInstance() ;
116
117   Float_t celZ = geom->GetPadSizeZ();
118   Float_t celY = geom->GetPadSizePhi();
119
120 //  //    Info("AG", "celZ: %f celY: %f", celZ, celY) ;
121
122   Float_t dx = celZ/2.;
123   Float_t dy = celY/2.;
124
125 //  //    Float_t x = xi*celZ;
126 //  //    Float_t y = yi*celZ;
127
128   Float_t x = xi*celZ;
129   Float_t y = yi*celY;
130
131   Float_t e = ei;
132
133   Float_t a = Fcml(x+dx,y+dy) - Fcml(x+dx,y-dy) - Fcml(x-dx,y+dy) + Fcml(x-dx,y-dy);
134   ai = a*e;
135
136
137   Float_t gx = GradX(x+dx,y+dy) - GradX(x+dx,y-dy) - GradX(x-dx,y+dy) + GradX(x-dx,y-dy);
138   gxi = gx*e*e;
139
140   Float_t gy = GradY(x+dx,y+dy) - GradY(x+dx,y-dy) - GradY(x-dx,y+dy) + GradY(x-dx,y-dy);
141   gyi = gy*e*e;
142
143 }
144
145 Float_t AliPHOSRecCpvManager::Fcml(Float_t x, Float_t y)
146 {
147   //Cumulative function
148
149   const Float_t ka = 1.0;
150   const Float_t kb = 0.70;
151
152   Float_t fff  = TMath::ATan(x*y/(  kb*TMath::Sqrt(  (kb*kb) + x*x+y*y)))
153     - TMath::ATan(x*y/(3*kb*TMath::Sqrt((3*kb)*(3*kb) + x*x+y*y)))
154     + TMath::ATan(x*y/(5*kb*TMath::Sqrt((5*kb)*(5*kb) + x*x+y*y))) 
155     - TMath::ATan(x*y/(7*kb*TMath::Sqrt((7*kb)*(7*kb) + x*x+y*y)))
156     + TMath::ATan(x*y/(9*kb*TMath::Sqrt((9*kb)*(9*kb) + x*x+y*y))); 
157   
158   Float_t fcml = ka*fff/TMath::TwoPi();
159 //    Info("Fcml", "fcml: %f", fcml) ;
160   return fcml;
161
162 }
163
164
165 Float_t AliPHOSRecCpvManager::GradX(Float_t x, Float_t y)
166 {
167   // Put a comment here
168
169   const Float_t ka = 1.0;
170   const Float_t kb = 0.70;
171
172   Float_t skv      = kb*kb + x*x + y*y;
173
174   Float_t sqskv=TMath::Sqrt(skv);
175   Float_t yxskv=y*(1.-x/sqskv)*(1.+x/sqskv);
176   
177   Float_t gradient = 
178       yxskv*  kb*sqskv/( kb*kb*skv+x*x*y*y)
179     - yxskv*3*kb*sqskv/((3*kb)*(3*kb)*skv+x*x*y*y)
180     + yxskv*5*kb*sqskv/((5*kb)*(5*kb)*skv+x*x*y*y)
181     - yxskv*7*kb*sqskv/((7*kb)*(7*kb)*skv+x*x*y*y)
182     + yxskv*9*kb*sqskv/((9*kb)*(9*kb)*skv+x*x*y*y);
183       
184   Float_t grad    = ka*gradient/TMath::TwoPi();
185   return grad;
186 }
187
188
189 Float_t AliPHOSRecCpvManager::GradY(Float_t x, Float_t y)
190 {
191   // Put a comment here
192   
193   const Float_t ka = 1.0;
194   const Float_t kb = 0.70;
195  
196   Float_t skv      = kb*kb + x*x + y*y;
197
198   Float_t sqskv=TMath::Sqrt(skv);
199   Float_t xyskv=x*(1.-y/sqskv)*(1.+y/sqskv);
200
201   Float_t gradient = 
202       xyskv*  kb*sqskv/( kb*kb*skv+x*x*y*y)
203     - xyskv*3*kb*sqskv/((3*kb)*(3*kb)*skv+x*x*y*y)
204     + xyskv*5*kb*sqskv/((5*kb)*(5*kb)*skv+x*x*y*y)
205     - xyskv*7*kb*sqskv/((7*kb)*(7*kb)*skv+x*x*y*y)
206     + xyskv*9*kb*sqskv/((9*kb)*(9*kb)*skv+x*x*y*y);
207   
208   Float_t grad    = ka*gradient/TMath::TwoPi();
209   return grad;
210 }
211
212