]>
Commit | Line | Data |
---|---|---|
5e319bd5 | 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: AliAD.cxx $ */ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // AD (ALICE Diffractive) Detector // | |
21 | // // | |
22 | // This class contains the base procedures for the AD detector // | |
23 | // Default geometry of 2013: 16 modules // | |
24 | // All comments should be sent to : // | |
25 | // // | |
26 | // // | |
27 | /////////////////////////////////////////////////////////////////////////// | |
28 | ||
29 | // --- Standard libraries --- | |
30 | #include <Riostream.h> | |
31 | ||
32 | // --- ROOT libraries --- | |
33 | #include <TMath.h> | |
34 | #include <TString.h> | |
35 | #include <TVirtualMC.h> | |
36 | #include <TGeoManager.h> | |
37 | #include <TGeoMatrix.h> | |
38 | #include <TGeoTube.h> | |
39 | #include <TGeoCone.h> | |
40 | #include <TGeoShape.h> | |
41 | #include <TTree.h> | |
42 | #include <TSystem.h> | |
43 | #include <TGeoCompositeShape.h> | |
44 | #include <TGeoGlobalMagField.h> | |
45 | #include <TGeoMaterial.h> | |
46 | #include <TGeoMedium.h> | |
47 | #include <TGeoVolume.h> | |
48 | #include <TGeoArb8.h> | |
49 | #include <TClonesArray.h> | |
50 | #include <TGeoTrd2.h> | |
51 | #include <TParticle.h> | |
52 | ||
53 | #include <TH2F.h> | |
54 | #include <TCanvas.h> | |
55 | ||
56 | // --- AliRoot header files --- | |
57 | ||
58 | ||
59 | #include "AliADhit.h" | |
60 | #include "AliADdigit.h" | |
61 | #include "AliADv1.h" | |
62 | #include "AliLog.h" | |
63 | #include "AliConst.h" | |
64 | #include "AliMagF.h" | |
65 | #include "AliRun.h" | |
66 | #include "AliMC.h" | |
67 | ||
68 | ||
69 | ClassImp(AliADv1) | |
70 | //__________________________________________________________________ | |
71 | AliADv1::AliADv1() | |
72 | : AliAD(), | |
73 | fADCLightYield(93.75), | |
74 | fADCPhotoCathodeEfficiency(0.18), | |
75 | fADALightYield(93.75), | |
76 | fADAPhotoCathodeEfficiency(0.18) | |
77 | ||
78 | { | |
79 | // Default Constructor | |
80 | fHits = 0; | |
81 | } | |
82 | ||
83 | //_____________________________________________________________________________ | |
84 | AliADv1::AliADv1(const char *name, const char *title) : | |
85 | AliAD(name,title), | |
86 | fADCLightYield(93.75), | |
87 | fADCPhotoCathodeEfficiency(0.18), | |
88 | fADALightYield(93.75), | |
89 | fADAPhotoCathodeEfficiency(0.18) | |
90 | { | |
91 | // Standard constructor for AD Detector | |
92 | ||
93 | AliModule* pipe = gAlice->GetModule("PIPE"); | |
94 | if( (!pipe) ) { | |
95 | Error("Constructor","AD needs PIPE!!!\n"); | |
96 | exit(1); | |
97 | } | |
98 | fHits = new TClonesArray("AliADhit",400); | |
99 | gAlice->GetMCApp()->AddHitList(fHits); | |
100 | } | |
101 | ||
102 | //_____________________________________________________________________________ | |
103 | AliADv1::~AliADv1() | |
104 | { | |
105 | // default destructor | |
106 | } | |
107 | //_____________________________________________________________________________ | |
108 | void AliADv1::Init() | |
109 | { | |
110 | // Initialise L3 magnet after it has been built | |
111 | Int_t i; | |
112 | if(AliLog::GetGlobalDebugLevel()>0) { | |
113 | printf("\n%s: ",ClassName()); | |
114 | for(i=0;i<35;i++) printf("*"); | |
115 | printf(" ADv1_INIT "); | |
116 | for(i=0;i<35;i++) printf("*"); | |
117 | printf("\n%s: ",ClassName()); | |
118 | for(i=0;i<80;i++) printf("*"); | |
119 | printf("\n"); | |
120 | } | |
121 | } | |
122 | ||
123 | //_____________________________________________________________________________ | |
124 | void AliADv1::CreateGeometry() | |
125 | { | |
126 | // | |
127 | // Create the geometry for the AD arrays | |
128 | // | |
129 | ||
130 | CreateAD(); | |
131 | ||
132 | } | |
133 | ||
134 | ||
135 | //_____________________________________________________________________________ | |
136 | void AliADv1::CreateAD() | |
137 | { | |
138 | ||
139 | // here we create AD: ADA & ADC | |
140 | ||
141 | // Get ALICE volume | |
142 | ||
143 | TGeoVolume *alice = gGeoManager->GetVolume("ALIC"); | |
144 | ||
145 | // Define the mother volume for AD | |
146 | ||
147 | TGeoVolume *ad = new TGeoVolumeAssembly("AD"); | |
148 | ||
149 | // Get medium | |
150 | ||
151 | TGeoMedium *medADASci = gGeoManager->GetMedium("AD_NE102"); // AD Scin. | |
152 | TGeoMedium *medADALG = gGeoManager->GetMedium("AD_PMMA"); // lightGuide | |
153 | TGeoMedium *medADAPMGlass = gGeoManager->GetMedium("AD_Glass"); // Glass for Aluminium simulation | |
154 | TGeoMedium *medADAPMAlum = gGeoManager->GetMedium("AD_Alum"); // Aluminium | |
155 | ||
156 | ||
157 | /// ADA Scintillator Pad Measures | |
158 | const Double_t kADATriangleSide = 7.8; // | |
159 | const Double_t kADACellSide = 20.0; | |
160 | const Double_t kADACellThickness = 2.0; // Half thickness | |
161 | const int kColorADA = kGreen; | |
162 | ||
163 | ||
164 | // Creation of the Box's pad | |
165 | ||
166 | new TGeoBBox( "ADAbox", kADACellSide/2.0-kADATriangleSide/2., kADACellSide/2.0, kADACellThickness ); | |
167 | const Double_t boxSide2 = kADACellSide/2.0-kADATriangleSide/2.; | |
168 | new TGeoBBox( "ADAbox1", kADATriangleSide/2., boxSide2, kADACellThickness ); | |
169 | ||
170 | // translation | |
171 | ||
172 | TGeoTranslation *trada2 = new TGeoTranslation( -kADACellSide/2.0, kADACellSide/2.0 - boxSide2, 0. ); | |
173 | trada2->SetName( "trada2" ); | |
174 | trada2->RegisterYourself(); | |
175 | ||
176 | TGeoArb8* sADAtriang = new TGeoArb8( "ADAtriang", kADACellThickness ); | |
177 | for ( int iz = 0; iz < 2; iz++ ) { | |
178 | sADAtriang->SetVertex( 0+iz*4, kADACellSide/2.0, kADACellSide/2.0 ); | |
179 | sADAtriang->SetVertex( 1+iz*4, kADACellSide/2.0, (kADACellSide/2.0)-kADATriangleSide ); | |
180 | sADAtriang->SetVertex( 2+iz*4, kADACellSide/2.0, (kADACellSide/2.0)-kADATriangleSide ); | |
181 | sADAtriang->SetVertex( 3+iz*4, kADACellSide/2.0-kADATriangleSide, kADACellSide/2.0 ); | |
182 | } | |
183 | TGeoTranslation *trada1 = new TGeoTranslation( -kADACellSide+kADATriangleSide/2. , -kADACellSide+kADATriangleSide, 0. ); | |
184 | trada1->SetName( "trada1" ); | |
185 | trada1->RegisterYourself(); | |
186 | ||
187 | TGeoCompositeShape *sADA1 = new TGeoCompositeShape ( "sADA1s1", "ADAbox+(ADAbox1:trada2)+(ADAtriang:trada1)" ); | |
188 | TGeoVolume *vADA1 = new TGeoVolume( "ADApad", sADA1, medADASci ); | |
189 | vADA1->SetLineColor( kColorADA ); | |
190 | ||
191 | /// Light guide | |
192 | Double_t kADALGThickness = 2.0; // Half thickness | |
193 | Double_t kADALGSideScint = 20.0; | |
194 | Double_t kADALGHeigth = TMath::Sqrt( kADALGSideScint*kADALGSideScint - (10.5 * 10.5) ); | |
195 | Double_t kADALGSideCoupling = 3.0; | |
196 | const int kColorADALG = kYellow; | |
197 | ||
198 | // Triangle | |
199 | TGeoTrd2* sADALGtriang = new TGeoTrd2( kADALGThickness, kADALGThickness, kADALGSideScint/2., kADALGSideCoupling/2., kADALGHeigth/2.0); | |
200 | TGeoVolume *vADALGtriang = new TGeoVolume( "ADALG", sADALGtriang, medADALG ); | |
201 | vADALGtriang->SetLineColor( kColorADALG ); | |
202 | ||
203 | // Coupling | |
204 | Double_t kADALGCoupling = 5.0; | |
205 | TGeoTube* sADACouplTube = new TGeoTube( "ADACouplTube", 0, 1.4, kADALGCoupling/2. ); | |
206 | TGeoVolume * vADACoupling = new TGeoVolume( "ADACoupling", sADACouplTube, medADALG ); | |
207 | vADACoupling->SetLineColor( kColorADALG ); | |
208 | ||
209 | TGeoVolume * vADALG1 = new TGeoVolumeAssembly( "ADALG" ); | |
210 | vADALG1->AddNode( vADALGtriang, 1 ); | |
211 | vADALG1->AddNode( vADACoupling, 1, new TGeoTranslation(0., 0., kADALGHeigth/2.+kADALGCoupling/2.) ); | |
212 | vADALG1->SetLineColor( kColorADALG ); | |
213 | ||
214 | /// PMT Hamamatsu R5946 | |
215 | Double_t kADAPMR1 = 1.95; // 3.9 cm diameter | |
216 | Double_t kADAPMR2 = 2.15; // + 2 mm?? aluminium case | |
217 | Double_t kADAPMlength = 6.4; // 5 cm PMT + 1.4 socket | |
218 | const int kColorPMG = kWhite; | |
219 | const int kColorPMA = kGray; | |
220 | ||
221 | TGeoTube *sADAPMg1 = new TGeoTube( "sADAPMg", 0., kADAPMR1, kADAPMlength/2. ); | |
222 | TGeoVolume *vADAPMg1 = new TGeoVolume( "ADAPMg", sADAPMg1, medADAPMGlass ); | |
223 | vADAPMg1->SetLineColor( kColorPMG ); | |
224 | TGeoTube *sADAPMa1 = new TGeoTube( "ADAPMa", kADAPMR1, kADAPMR2, kADAPMlength/2. ); | |
225 | TGeoVolume *vADAPMa1 = new TGeoVolume( "ADAPMa", sADAPMa1, medADAPMAlum ); | |
226 | vADAPMa1->SetLineColor( kColorPMA ); | |
227 | TGeoVolume *vADAPM1 = new TGeoVolumeAssembly("ADAPM"); | |
228 | vADAPM1->AddNode( vADAPMg1, 1 ); | |
229 | vADAPM1->AddNode( vADAPMa1, 1 ); | |
230 | ||
231 | /// Sector (Assembly: Scintillator Pad + Light guide + PM ) | |
232 | TGeoVolume *secADA = new TGeoVolumeAssembly( "ADAsec" ); | |
233 | // Add PAD | |
234 | secADA->AddNode( vADA1, 1, new TGeoTranslation( kADACellSide/2.0+kADATriangleSide/2. + 0.05, kADACellSide/2.0 + 0.05, 0. ) ); | |
235 | // Add Light Guide | |
236 | TGeoCombiTrans *transrot = new TGeoCombiTrans( kADACellSide + kADALGHeigth/2.0 + 0.05, kADALGSideScint/2.0 + 0.05, 0., | |
237 | new TGeoRotation("rot",90.,90.,90.) ); | |
238 | secADA->AddNode( vADALG1, 1, transrot ); | |
239 | // Add PM | |
240 | transrot = new TGeoCombiTrans( kADACellSide + kADALGHeigth + kADALGCoupling + kADAPMlength/2. + 0.05, kADACellSide/2.0 + 0.05, 0, | |
241 | new TGeoRotation("rot",90.,90.,0.) ); | |
242 | secADA->AddNode(vADAPM1, 1, transrot); | |
243 | ||
244 | // TODO: Add mechanical support | |
245 | ||
246 | /// Assembling ADA adding 4 sectors // Sectors | |
247 | TGeoVolume *vADAarray = new TGeoVolumeAssembly( "ADA" ); // ^ y | |
248 | vADAarray->AddNode( secADA, 1 ); // | | |
249 | vADAarray->AddNode( secADA, 2, new TGeoRotation("rot",0. , 180.,0.) ); // 4 | 1 | |
250 | vADAarray->AddNode( secADA, 3, new TGeoRotation("rot",180., 0., 0.) ); // ---------------> x | |
251 | vADAarray->AddNode( secADA, 4, new TGeoRotation("rot",180., 180.,0.) ); // 3 | 2 | |
252 | TGeoRotation *rotADA90 = new TGeoRotation("adarot",90,0,0); | |
253 | // here I add ADA to AD volume | |
254 | const Float_t kPosADA = 1700.0; | |
255 | ad->AddNode(vADAarray,1, new TGeoCombiTrans("ada",0,0,kPosADA,rotADA90)); // | | |
256 | ||
257 | if (GetADAToInstalled()) | |
258 | { | |
259 | const Float_t kPosADA2 = 1695.0; | |
260 | ad->AddNode(vADAarray,2, new TGeoCombiTrans("ada",0,0,kPosADA2,rotADA90)); | |
261 | } | |
262 | ||
263 | // Creation of ADC | |
264 | ||
265 | // Get Medium for ADC (in principle is the same as ADA, but I keep the previous variables) | |
266 | ||
267 | TGeoMedium *medADCSci = gGeoManager->GetMedium("AD_NE102"); | |
268 | TGeoMedium *medADCLG = gGeoManager->GetMedium("AD_PMMA"); | |
269 | TGeoMedium *medADCPMGlass = gGeoManager->GetMedium("AD_Glass"); | |
270 | TGeoMedium *medADCPMAlum = gGeoManager->GetMedium("AD_Alum"); | |
271 | ||
272 | /// Creation of assembly of one ADC sector | |
273 | ||
274 | /// ADC Scintillator Pad | |
275 | const Double_t kADCCellSide = 30.; | |
276 | const Double_t kADCCellThickness = 4.0; | |
277 | const int kColorADC = kGreen; | |
278 | ||
279 | new TGeoBBox( "ADCbox0", kADCCellSide/4.0, kADCCellSide/2.0, kADCCellThickness/2.0 ); | |
280 | new TGeoBBox( "ADCbox1", kADCCellSide/4.0, kADCCellSide/4.0, kADCCellThickness/2.0 ); | |
281 | new TGeoBBox( "ADCbox2", 2.5, 5.5, kADCCellThickness/2.0 ); | |
282 | TGeoTranslation *tradd1 = new TGeoTranslation( -kADCCellSide/2.0, kADCCellSide/4.0, 0. ); | |
283 | TGeoTranslation *tradd2 = new TGeoTranslation( -kADCCellSide/4.0 - 2.5, -kADCCellSide/2.0 + 5.5 , 0. ); | |
284 | tradd1->SetName( "tradd1" ); | |
285 | tradd2->SetName( "tradd2" ); | |
286 | tradd1->RegisterYourself(); | |
287 | tradd2->RegisterYourself(); | |
288 | TGeoCompositeShape *sADC1 = new TGeoCompositeShape ( "sADCpad", "ADCbox0+(ADCbox1:tradd1)+(ADCbox2:tradd2)" ); | |
289 | TGeoVolume *vADC = new TGeoVolume( "ADCpad", sADC1, medADCSci ); | |
290 | vADC->SetLineColor( kColorADC ); | |
291 | ||
292 | /// Light guide | |
293 | const Double_t kADCLGThickness = 4.0; | |
294 | const Double_t kADCLGHeigth = 28.95; // Dist from scint to coupling | |
295 | const Double_t kADCLGSideScint = kADCCellSide; // 30.0 | |
296 | const Double_t kADCLGSideCoupling = 4.0; | |
297 | const int kColorADCLG = kYellow; | |
298 | ||
299 | // Triangle | |
300 | TGeoTrd2* sADCLGtriang = new TGeoTrd2( kADCLGThickness/2., kADCLGThickness/2., kADCLGSideScint/2., kADCLGSideCoupling/2., kADCLGHeigth/2.0); | |
301 | TGeoVolume *vADCLGtriang = new TGeoVolume( "ADCLG", sADCLGtriang, medADCLG ); | |
302 | vADCLGtriang->SetLineColor( kColorADCLG ); | |
303 | ||
304 | // Coupling | |
305 | Double_t kADCLGCoupling = 10.0; // Total lenght | |
306 | new TGeoCone( "ADCCouplCone", kADCLGCoupling/4., 0, kADCLGSideCoupling/TMath::Sqrt(2.), 0, 1.4 ); | |
307 | new TGeoBBox( "ADCCouplBox", kADCLGSideCoupling/2., kADCLGSideCoupling/2., kADCLGCoupling/4. ); | |
308 | new TGeoTube( "ADCCouplTube", 0, 1.4, kADCLGCoupling/4. ); | |
309 | TGeoTranslation *tradd3 = new TGeoTranslation(0, 0, kADCLGCoupling/2. ); | |
310 | tradd3->SetName( "tradd3" ); | |
311 | tradd3->RegisterYourself(); | |
312 | ||
313 | TGeoCompositeShape * sADCCoupling = new TGeoCompositeShape ( "sADCCoupling", "ADCCouplBox * ADCCouplCone + (ADCCouplTube:tradd3)" ); | |
314 | TGeoVolume * vADCCoupling = new TGeoVolume( "ADCCoupling", sADCCoupling, medADCLG ); | |
315 | vADCCoupling->SetLineColor( kColorADCLG ); | |
316 | ||
317 | TGeoVolume * vADCLG = new TGeoVolumeAssembly( "ADCLG" ); | |
318 | vADCLG->AddNode( vADCLGtriang, 1 ); | |
319 | vADCLG->AddNode( vADCCoupling, 1, new TGeoTranslation(0., 0., kADCLGHeigth/2.+kADCLGCoupling/4.) ); | |
320 | vADCLG->SetLineColor( kColorADCLG ); | |
321 | ||
322 | /// PM Hamamatsu R5946 | |
323 | const Double_t kADCPMR1 = 1.95; // 3.9 cm diameter | |
324 | const Double_t kADCPMR2 = 2.15; // + 2 mm?? aluminium case | |
325 | const Double_t kADCPMlength = 6.4; // 5 cm PMT + 1.4 socket | |
326 | //const int kColorPMG = kWhite; | |
327 | ////const int kColorPMA = kGray; | |
328 | ||
329 | TGeoTube *sADCPMg = new TGeoTube( "sADCPMg", 0., kADCPMR1, kADCPMlength/2. ); | |
330 | TGeoVolume *vADCPMg = new TGeoVolume( "ADCPMg", sADCPMg, medADCPMGlass ); | |
331 | vADCPMg->SetLineColor(kColorPMG); | |
332 | TGeoTube *sADCPMa = new TGeoTube( "ADCPMa", kADCPMR1, kADCPMR2, kADCPMlength/2. ); | |
333 | TGeoVolume *vADCPMa = new TGeoVolume( "ADCPMa", sADCPMa, medADCPMAlum ); | |
334 | vADCPMa->SetLineColor( kColorPMA ); | |
335 | TGeoVolume *vADCPM = new TGeoVolumeAssembly( "ADCPM" ); | |
336 | vADCPM->AddNode( vADCPMg, 1 ); | |
337 | vADCPM->AddNode( vADCPMa, 1 ); | |
338 | ||
339 | /// Sector (Asembly: Scintillator Pad + Light guide + PM ) | |
340 | TGeoVolume *secADC = new TGeoVolumeAssembly("ADCsec"); | |
341 | // Add PAD | |
342 | TGeoCombiTrans *transrot1 = new TGeoCombiTrans( 3*kADCCellSide/4.0, kADCCellSide/2.0, 0., new TGeoRotation("rot",0.,0.,0.) ); | |
343 | secADC->AddNode( vADC, 1, transrot1 ); | |
344 | // Add Light Guide | |
345 | transrot1 = new TGeoCombiTrans( kADCCellSide + kADCLGHeigth/2.0, kADCLGSideScint/2.0, 0., new TGeoRotation("rot",90.,90.,90.) ); | |
346 | secADC->AddNode( vADCLG, 1, transrot1 ); | |
347 | // Add PM | |
348 | transrot1 = new TGeoCombiTrans( kADCCellSide + kADCLGHeigth + kADCLGCoupling + kADCPMlength/2., kADCCellSide/2.0, 0, new TGeoRotation("rot",90.,90.,0.) ); | |
349 | secADC->AddNode( vADCPM, 1, transrot1 ); | |
350 | ||
351 | // TODO: Add mechanical support | |
352 | ||
353 | /// Assembling ADC adding the 4 sectors // Sectors | |
354 | TGeoVolume *vADCarray = new TGeoVolumeAssembly("ADC"); // ^ y | |
355 | vADCarray->AddNode( secADC, 1 ); // | | |
356 | vADCarray->AddNode( secADC, 2, new TGeoRotation("rot", 0. , 180., 0.) ); // 4 | 1 | |
357 | vADCarray->AddNode( secADC, 3, new TGeoRotation("rot", 180., 0., 0.) ); // ---------------> x | |
358 | vADCarray->AddNode( secADC, 4, new TGeoRotation("rot", 180., 180., 0.) ); // 3 | 2 | |
359 | // | | |
360 | // here I add ADC to AD volume | |
361 | ||
362 | //const Float_t kPosADC = -1902.75; // -1902.75 (with 4cm thick) puts the ADC just next to the YSAA3_CC_BLOCK | |
363 | const Float_t kPosADC = -1900.0; | |
364 | ad->AddNode(vADCarray,3,new TGeoTranslation(0,0,kPosADC)); | |
365 | // add second array | |
366 | if (GetADCToInstalled()) | |
367 | { | |
368 | const Float_t kPosADC2 = -1895.0; | |
369 | ad->AddNode(vADCarray,4,new TGeoTranslation(0,0,kPosADC2)); | |
370 | } | |
371 | ||
372 | // at the end, I add "AD" volume into ALICE | |
373 | ||
374 | alice->AddNode(ad,1); | |
375 | } | |
376 | ||
377 | //_____________________________________________________________________________ | |
378 | void AliADv1::AddAlignableVolumes() const | |
379 | { | |
380 | // | |
381 | // Create entries for alignable volumes associating the symbolic volume | |
382 | // name with the corresponding volume path. Needs to be syncronized with | |
383 | // eventual changes in the geometry. | |
384 | // | |
385 | // ADA and ADC | |
386 | ||
387 | ||
388 | ||
389 | TString volpath1 = "/ALIC_1/AD_1/ADC_3"; | |
390 | TString volpath2 = "/ALIC_1/AD_1/ADC_4"; | |
391 | TString volpath3 = "/ALIC_1/AD_1/ADA_1"; | |
392 | TString volpath4 = "/ALIC_1/AD_1/ADA_2"; | |
393 | ||
394 | TString symname1 = "AD/ADC3"; | |
395 | TString symname2 = "AD/ADC4"; | |
396 | TString symname3 = "AD/ADA1"; | |
397 | TString symname4 = "AD/ADA2"; | |
398 | ||
399 | if ( !gGeoManager->SetAlignableEntry(symname1.Data(), volpath1.Data()) ) | |
400 | AliFatal(Form( "Alignable entry %s not created. Volume path %s not valid", symname1.Data(), volpath1.Data()) ); | |
401 | if ( GetADCToInstalled() && !gGeoManager->SetAlignableEntry(symname2.Data(), volpath2.Data()) ) | |
402 | AliFatal(Form( "Alignable entry %s not created. Volume path %s not valid", symname2.Data(), volpath2.Data()) ); | |
403 | if ( !gGeoManager->SetAlignableEntry(symname3.Data(), volpath3.Data()) ) | |
404 | AliFatal(Form( "Alignable entry %s not created. Volume path %s not valid", symname3.Data(), volpath3.Data()) ); | |
405 | if ( GetADAToInstalled() && !gGeoManager->SetAlignableEntry(symname4.Data(), volpath4.Data()) ) | |
406 | AliFatal(Form("Alignable entry %s not created. Volume path %s not valid", symname4.Data(), volpath4.Data()) ); | |
407 | ||
408 | } | |
409 | ||
410 | ||
411 | //_____________________________________________________________________________ | |
412 | void AliADv1::StepManager() | |
413 | { | |
414 | ||
415 | // | |
416 | // Routine called at every step in the AD | |
417 | // | |
418 | ||
419 | // ADA and ADC static Variables // | |
420 | //static Int_t numStep_ad = 0; // | |
421 | // static Int_t vol_ad[2]; // | |
422 | ||
423 | ///////////////////////////////////////////////////////////////////////// | |
424 | // ADA and ADC | |
425 | ///////////////////////////////////////////////////////////////////////// | |
426 | ||
427 | ||
428 | // Get sensitive volumes id (scintillator pads) | |
aa8120bb | 429 | static Int_t idADA = gMC->VolId( "ADApad" ); |
430 | static Int_t idADC = gMC->VolId( "ADCpad" ); | |
5e319bd5 | 431 | |
432 | // We keep only charged tracks : | |
aa8120bb | 433 | // if ( !gMC->TrackCharge() || !gMC->IsTrackAlive() ) return; |
5e319bd5 | 434 | // We keep charged and non-charged tracks : |
aa8120bb | 435 | if ( !gMC->IsTrackAlive() ) return; |
5e319bd5 | 436 | |
437 | Int_t copy; | |
aa8120bb | 438 | Int_t current_volid = gMC->CurrentVolID( copy ); |
5e319bd5 | 439 | |
440 | // check is the track is in a sensitive volume | |
441 | if( current_volid != idADA && current_volid != idADC ) { | |
442 | return; // not in the sensitive volume | |
443 | } | |
444 | ||
445 | // First read the position, otherwise weird reults! //ecv | |
446 | Double_t s[3]; | |
447 | Float_t x[3]; | |
aa8120bb | 448 | gMC->TrackPosition( s[0], s[1], s[2] ); |
5e319bd5 | 449 | for ( Int_t j=0; j<3; j++ ) x[j] = s[j]; |
450 | ||
451 | // Set detectro type: ADA or ADC | |
452 | Int_t detType = (current_volid == idADA ) ? 0 : 1; | |
453 | ||
454 | // Get sector copy (1,2,3,4) ( 1 level up from pad ) | |
455 | Int_t sect; | |
aa8120bb | 456 | gMC->CurrentVolOffID( 1, sect ); |
5e319bd5 | 457 | |
458 | // Get Detector copy (1,2) ( 2 levels up from pad ) | |
459 | Int_t detc; | |
aa8120bb | 460 | gMC->CurrentVolOffID( 2, detc ); |
5e319bd5 | 461 | |
462 | // Sector number | |
463 | // ADA1 = 10-14 | |
464 | // ADA2 = 20-24 | |
465 | // ADC1 = 30-34 | |
466 | // ADC2 = 40-44 | |
467 | Int_t sectorNumber_AD = detType*20 + detc*10 + sect; | |
468 | ||
469 | Double_t lightYield_ad; | |
470 | Double_t photoCathodeEfficiency; | |
471 | ||
472 | if( detType == 1 ) { | |
473 | lightYield_ad = fADCLightYield; | |
474 | photoCathodeEfficiency = fADCPhotoCathodeEfficiency; | |
475 | } else { | |
476 | lightYield_ad = fADALightYield; | |
477 | photoCathodeEfficiency = fADAPhotoCathodeEfficiency; | |
478 | } | |
479 | ||
aa8120bb | 480 | Float_t destep_ad = gMC->Edep(); |
481 | Float_t step_ad = gMC->TrackStep(); | |
5e319bd5 | 482 | Int_t nPhotonsInStep_ad = Int_t( destep_ad / (lightYield_ad * 1e-9) ); |
483 | nPhotonsInStep_ad = gRandom->Poisson( nPhotonsInStep_ad ); | |
484 | ||
485 | static Float_t eloss_ad = 0.; | |
486 | static Float_t tlength_ad = 0.; | |
487 | static Int_t nPhotons_ad = 0; | |
488 | static Float_t hits_ad[11]; | |
489 | static Int_t vol_ad[5]; | |
490 | ||
491 | eloss_ad += destep_ad; | |
492 | tlength_ad += step_ad; | |
493 | ||
aa8120bb | 494 | if ( gMC->IsTrackEntering() ) { |
5e319bd5 | 495 | nPhotons_ad = nPhotonsInStep_ad; |
496 | Double_t p[4]; | |
aa8120bb | 497 | gMC->TrackMomentum( p[0], p[1], p[2], p[3] ); |
5e319bd5 | 498 | Float_t pt = TMath::Sqrt( p[0]*p[0] + p[1]*p[1] + p[2]*p[2] ); |
499 | TParticle *par = gAlice->GetMCApp()->Particle(gAlice->GetMCApp()->GetCurrentTrackNumber()); | |
500 | Int_t imo = par->GetFirstMother(); | |
501 | Int_t pdgMo = 0; | |
502 | if ( imo > 0 ) { | |
503 | TParticle * pmot = gAlice->GetMCApp()->Particle(imo); | |
504 | pdgMo = pmot->GetPdgCode(); | |
505 | } | |
506 | ||
507 | // Set integer values | |
508 | vol_ad[0] = par->GetStatusCode(); // secondary flag //ecv | |
509 | vol_ad[1] = par->GetPdgCode(); // PDG code | |
510 | vol_ad[2] = pdgMo; // PDG of the mother | |
511 | // Set float values | |
512 | hits_ad[0] = x[0]; // X | |
513 | hits_ad[1] = x[1]; // Y | |
514 | hits_ad[2] = x[2]; // Z | |
515 | hits_ad[3] = p[3]; // kinetic energy of the entering particle | |
516 | hits_ad[4] = pt; // Pt | |
517 | hits_ad[5] = p[0]; // Px | |
518 | hits_ad[6] = p[1]; // Py | |
519 | hits_ad[7] = p[2]; // Pz | |
aa8120bb | 520 | hits_ad[8] = 1.0e09*gMC->TrackTime(); // in ns! |
5e319bd5 | 521 | |
522 | tlength_ad = 0.0; | |
523 | eloss_ad = 0.0; | |
524 | ||
525 | return; // without return, we count 2 times nPhotonsInStep_ad !!!??? | |
526 | } | |
527 | ||
528 | nPhotons_ad += nPhotonsInStep_ad; | |
529 | ||
aa8120bb | 530 | if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared() ) { |
5e319bd5 | 531 | |
532 | // Set integer values | |
533 | vol_ad[3] = nPhotons_ad; | |
534 | // brutal correction for ADA_1 | |
535 | if (sectorNumber_AD==11) sectorNumber_AD=0; | |
536 | if (sectorNumber_AD==12) sectorNumber_AD=1; | |
537 | if (sectorNumber_AD==13) sectorNumber_AD=2; | |
538 | if (sectorNumber_AD==14) sectorNumber_AD=3; | |
539 | ||
540 | // same for ADA_2 | |
541 | if (sectorNumber_AD==21) sectorNumber_AD=4; | |
542 | if (sectorNumber_AD==22) sectorNumber_AD=5; | |
543 | if (sectorNumber_AD==23) sectorNumber_AD=6; | |
544 | if (sectorNumber_AD==24) sectorNumber_AD=7; | |
545 | ||
546 | // brutal correction for ADC_3 | |
547 | if (sectorNumber_AD==51) sectorNumber_AD=8; | |
548 | if (sectorNumber_AD==52) sectorNumber_AD=9; | |
549 | if (sectorNumber_AD==53) sectorNumber_AD=10; | |
550 | if (sectorNumber_AD==54) sectorNumber_AD=11; | |
551 | ||
552 | // same for ADC_4 | |
553 | if (sectorNumber_AD==61) sectorNumber_AD=12; | |
554 | if (sectorNumber_AD==62) sectorNumber_AD=13; | |
555 | if (sectorNumber_AD==63) sectorNumber_AD=14; | |
556 | if (sectorNumber_AD==64) sectorNumber_AD=15; | |
557 | ||
558 | ||
559 | vol_ad[4] = sectorNumber_AD; // sector number (scintillator ID) | |
560 | // Set float values | |
561 | hits_ad[9] = tlength_ad; // track lenght inside ADC or ADA | |
562 | hits_ad[10] = eloss_ad; // energy loss | |
563 | Int_t track = gAlice->GetMCApp()->GetCurrentTrackNumber(); | |
564 | AddHit( track, vol_ad, hits_ad ); // <-- this is in AliAD.cxx | |
565 | tlength_ad = 0.0; | |
566 | eloss_ad = 0.0; | |
567 | nPhotons_ad = 0; | |
568 | } | |
569 | ||
570 | // Do we need track reference ???? | |
aa8120bb | 571 | // if( gMC->IsTrackEntering() || gMC->IsTrackExiting() ) { |
5e319bd5 | 572 | // AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), 49); |
573 | // } | |
574 | } | |
575 | //_________________________________________________________ | |
576 | void AliADv1::AddHit(Int_t track, Int_t *vol, Float_t *hits) | |
577 | { | |
578 | TClonesArray &lhits = *fHits; | |
579 | new(lhits[fNhits++]) AliADhit(fIshunt,track,vol,hits); | |
580 | } | |
581 | //_________________________________________________________ | |
5e319bd5 | 582 | void AliADv1::MakeBranch(Option_t *option) |
583 | { | |
584 | ||
585 | // Create branches in the current tree | |
586 | TString branchname(Form("%s",GetName())); | |
587 | AliDebug(2,Form("fBufferSize = %d",fBufferSize)); | |
588 | const char *cH = strstr(option,"H"); | |
589 | if (fHits && fLoader->TreeH() && cH) | |
590 | { | |
591 | fLoader->TreeH()->Branch(branchname.Data(),&fHits,fBufferSize); | |
592 | AliDebug(2,Form("Making Branch %s for hits",branchname.Data())); | |
593 | } | |
594 | const char *cD = strstr(option,"D"); | |
595 | if (fDigits && fLoader->TreeD() && cD) | |
596 | { | |
597 | fLoader->TreeD()->Branch(branchname.Data(),&fDigits, fBufferSize); | |
598 | AliDebug(2,Form("Making Branch %s for digits",branchname.Data())); | |
599 | } | |
600 | } |