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