]>
Commit | Line | Data |
---|---|---|
cbd576a6 | 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 | #include <iostream.h> | |
27 | ||
28 | // --- AliRoot header files --- | |
29 | ||
30 | #include "AliPHOSRecCpvManager.h" | |
31 | #include "AliPHOS.h" | |
32 | #include "AliRun.h" | |
33 | #include "AliPHOSGetter.h" | |
34 | ||
35 | ClassImp(AliPHOSRecCpvManager) | |
36 | ||
37 | //____________________________________________________________________________ | |
38 | ||
39 | AliPHOSRecCpvManager::AliPHOSRecCpvManager() | |
40 | { | |
41 | ||
42 | fOneGamChisqCut = 3.; // If Chi2/dof > fOneGamChisqCut, split point. | |
43 | ||
44 | fOneGamInitialStep = 0.00005; | |
45 | fOneGamChisqMin = 1.; | |
46 | fOneGamStepMin = 0.0005; | |
47 | fOneGamNumOfIterations = 50; | |
48 | ||
49 | fTwoGamInitialStep = 0.00005; | |
50 | fTwoGamChisqMin = 1.; | |
51 | fTwoGamEmin = 0.1; | |
52 | fTwoGamStepMin = 0.00005; | |
53 | fTwoGamNumOfIterations = 50; | |
54 | ||
55 | // fThr0 = 0.0285; // Min. energy of rec. point. If E<fThr0, point deleted. | |
56 | // fSqdCut = 3.; // Min. distance (in cm) between two rec points. | |
57 | ||
58 | fThr0 = 0.; | |
59 | fSqdCut = 0.; | |
60 | ||
61 | SetTitle("Cpv Reconstruction Manager"); | |
62 | } | |
63 | ||
64 | AliPHOSRecCpvManager::~AliPHOSRecCpvManager(void) {} | |
65 | ||
66 | Float_t AliPHOSRecCpvManager::Dispersion(Float_t Etot, Float_t Ai, Float_t Ei) | |
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 Const = 1.5; | |
74 | return Const*Ai*(1.-Ai/Etot); | |
75 | } | |
76 | ||
77 | Float_t AliPHOSRecCpvManager::OneGamChi2(Float_t Ai, Float_t Ei, Float_t Etot, Float_t& Gi) | |
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 Const = 1.5; | |
85 | ||
86 | Float_t da = Ai - Ei; | |
87 | Float_t D = Const*Ai*(1.-Ai/Etot); | |
88 | ||
89 | Float_t dd = da/D; | |
90 | Gi = dd*(2.- dd*Const*(1.-2.*Ai/Etot)); | |
91 | ||
92 | cout<<" OneGamChi2 (Ai,Ei,Etot,&Gi,chi2) "<<Ai<<" "<<Ei<<" "<<Etot<<" "<<Gi<<" "<<da*da/D<<endl<<endl; | |
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) | |
99 | { | |
100 | ||
101 | const Float_t Const = 1.5; | |
102 | ||
103 | Float_t da = Ai - Ei; | |
104 | Float_t D = Const*Ai*(1.-Ai/Etot); | |
105 | ||
106 | Float_t dd = da/D; | |
107 | Gi = dd*(2.- dd*Const*(1.-2.*Ai/Etot)); | |
108 | ||
109 | return da*da/D; | |
110 | ||
111 | } | |
112 | ||
113 | void AliPHOSRecCpvManager::AG(Float_t Ei, Float_t Xi, Float_t Yi, Float_t& Ai, Float_t& GXi, Float_t& GYi ) | |
114 | { | |
115 | //Calculates amplitude (Ai) and gradients (GXi, GYi) of CPV pad response. | |
116 | //Integrated response (total "shower energy") is E, | |
117 | //Xi and Yi are the distances along x and y from reference point | |
118 | // to the pad center. | |
119 | ||
120 | AliPHOSGetter * gime = AliPHOSGetter::GetInstance() ; | |
121 | const AliPHOSGeometry* geom = gime->PHOSGeometry(); | |
122 | Float_t CelZ = geom->GetPadSizeZ(); | |
123 | Float_t CelY = geom->GetPadSizePhi(); | |
124 | ||
125 | // // cout<<"CelZ: "<<CelZ<<" CelY: "<<CelY<<endl; | |
126 | ||
127 | Float_t dx = CelZ/2.; | |
128 | Float_t dy = CelY/2.; | |
129 | ||
130 | // // Float_t x = Xi*CelZ; | |
131 | // // Float_t y = Yi*CelZ; | |
132 | ||
133 | Float_t x = Xi*CelZ; | |
134 | Float_t y = Yi*CelY; | |
135 | ||
136 | Float_t E = Ei; | |
137 | ||
138 | Float_t A = Fcml(x+dx,y+dy) - Fcml(x+dx,y-dy) - Fcml(x-dx,y+dy) + Fcml(x-dx,y-dy); | |
139 | Ai = A*E; | |
140 | ||
141 | ||
142 | Float_t Gx = GradX(x+dx,y+dy) - GradX(x+dx,y-dy) - GradX(x-dx,y+dy) + GradX(x-dx,y-dy); | |
143 | GXi = Gx*E*E; | |
144 | ||
145 | Float_t Gy = GradY(x+dx,y+dy) - GradY(x+dx,y-dy) - GradY(x-dx,y+dy) + GradY(x-dx,y-dy); | |
146 | GYi = Gy*E*E; | |
147 | ||
148 | } | |
149 | ||
150 | Float_t AliPHOSRecCpvManager::Fcml(Float_t x, Float_t y) | |
151 | { | |
152 | //Cumulative function | |
153 | ||
154 | const Float_t A = 1.0; | |
155 | const Float_t b = 0.70; | |
156 | ||
157 | Float_t Fff = TMath::ATan(x*y/( b*TMath::Sqrt( (b*b) + x*x+y*y))) | |
158 | - TMath::ATan(x*y/(3*b*TMath::Sqrt((3*b)*(3*b) + x*x+y*y))) | |
159 | + TMath::ATan(x*y/(5*b*TMath::Sqrt((5*b)*(5*b) + x*x+y*y))) | |
160 | - TMath::ATan(x*y/(7*b*TMath::Sqrt((7*b)*(7*b) + x*x+y*y))) | |
161 | + TMath::ATan(x*y/(9*b*TMath::Sqrt((9*b)*(9*b) + x*x+y*y))); | |
162 | ||
163 | Float_t Fcml = A*Fff/6.2831853071796; | |
164 | // cout<<" Fcml: "<<Fcml<<endl; | |
165 | return Fcml; | |
166 | ||
167 | } | |
168 | ||
169 | ||
170 | Float_t AliPHOSRecCpvManager::GradX(Float_t x, Float_t y) | |
171 | { | |
172 | ||
173 | const Float_t A = 1.0; | |
174 | const Float_t b = 0.70; | |
175 | ||
176 | Float_t skv = b*b + x*x + y*y; | |
177 | ||
178 | Float_t Gradient = y*(1.-x*x/skv)* b*TMath::Sqrt(skv)/( b*b*skv+x*x*y*y) | |
179 | - y*(1.-x*x/skv)*3*b*TMath::Sqrt(skv)/((3*b)*(3*b)*skv+x*x*y*y) | |
180 | + y*(1.-x*x/skv)*5*b*TMath::Sqrt(skv)/((5*b)*(5*b)*skv+x*x*y*y) | |
181 | - y*(1.-x*x/skv)*7*b*TMath::Sqrt(skv)/((7*b)*(7*b)*skv+x*x*y*y) | |
182 | + y*(1.-x*x/skv)*9*b*TMath::Sqrt(skv)/((9*b)*(9*b)*skv+x*x*y*y); | |
183 | ||
184 | Float_t Grad = A*Gradient/6.2831853071796; | |
185 | return Grad; | |
186 | } | |
187 | ||
188 | ||
189 | Float_t AliPHOSRecCpvManager::GradY(Float_t x, Float_t y) | |
190 | { | |
191 | ||
192 | const Float_t A = 1.0; | |
193 | const Float_t b = 0.70; | |
194 | ||
195 | Float_t skv = b*b + x*x + y*y; | |
196 | Float_t Gradient = x*(1.-y*y/skv)* b*TMath::Sqrt(skv)/( b*b*skv+x*x*y*y) | |
197 | - x*(1.-y*y/skv)*3*b*TMath::Sqrt(skv)/((3*b)*(3*b)*skv+x*x*y*y) | |
198 | + x*(1.-y*y/skv)*5*b*TMath::Sqrt(skv)/((5*b)*(5*b)*skv+x*x*y*y) | |
199 | - x*(1.-y*y/skv)*7*b*TMath::Sqrt(skv)/((7*b)*(7*b)*skv+x*x*y*y) | |
200 | + x*(1.-y*y/skv)*9*b*TMath::Sqrt(skv)/((9*b)*(9*b)*skv+x*x*y*y); | |
201 | ||
202 | Float_t Grad = A*Gradient/6.2831853071796; | |
203 | return Grad; | |
204 | } | |
205 | ||
206 |