source: trunk/examples/advanced/gammaray_telescope/src/GammaRayTelTrackerROGeometry.cc@ 1257

Last change on this file since 1257 was 1230, checked in by garnier, 16 years ago

update to geant4.9.3
File size: 10.9 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: GammaRayTelTrackerROGeometry.cc,v 1.6 2006/06/29 15:57:10 gunter Exp $
28// GEANT4 tag $Name: geant4-09-03-cand-01 $
29//
30//
31// ------------------------------------------------------------
32// GEANT 4 class implementation file
33// CERN Geneva Switzerland
34//
35//
36// ------------ GammaRayTelTrackerROGeometry class ------
37// by F.Longo, R.Giannitrapani & G.Santin (13 nov 2000)
38//
39// ************************************************************
40#include "G4RunManager.hh"
41#include "GammaRayTelTrackerROGeometry.hh"
42#include "GammaRayTelDummySD.hh"
43#include "GammaRayTelDetectorConstruction.hh"
44
45#include "G4LogicalVolume.hh"
46#include "G4VPhysicalVolume.hh"
47#include "G4PVPlacement.hh"
48#include "G4PVReplica.hh"
49#include "G4SDManager.hh"
50#include "G4Box.hh"
51#include "G4ThreeVector.hh"
52#include "G4Material.hh"
53
54
55GammaRayTelTrackerROGeometry::GammaRayTelTrackerROGeometry()
56 : G4VReadOutGeometry()
57{
58}
59GammaRayTelTrackerROGeometry::GammaRayTelTrackerROGeometry(G4String aString)
60 :G4VReadOutGeometry(aString)
61{
62 G4RunManager* runManager = G4RunManager::GetRunManager();
63 GammaRayTelDetector =
64 (GammaRayTelDetectorConstruction*)(runManager->GetUserDetectorConstruction());
65}
66
67GammaRayTelTrackerROGeometry::~GammaRayTelTrackerROGeometry()
68{
69}
70
71G4VPhysicalVolume* GammaRayTelTrackerROGeometry::Build()
72{
73 // A dummy material is used to fill the volumes of the readout geometry.
74 // ( It will be allowed to set a NULL pointer in volumes of such virtual
75 // division in future, since this material is irrelevant for tracking.)
76 G4Material* dummyMat = new G4Material(name="dummyMat", 1., 1.*g/mole, 1.*g/cm3);
77
78 //Builds the ReadOut World:
79
80 G4double WorldSizeXY = GammaRayTelDetector->GetWorldSizeXY();
81 G4double WorldSizeZ = GammaRayTelDetector->GetWorldSizeZ();
82
83 G4Box* ROWorldBox = new
84 G4Box("ROWorldBox",WorldSizeXY/2,WorldSizeXY/2,WorldSizeZ/2);
85
86 G4LogicalVolume* ROWorldLog = new G4LogicalVolume(ROWorldBox, dummyMat,
87 "ROWorldLogical");
88 G4PVPlacement* ROWorldPhys =
89 new G4PVPlacement(0,G4ThreeVector(),"ROWorldPhysical",
90 ROWorldLog,0,false,0);
91
92 // Payload RO volume:
93
94 G4double PayloadSizeXY = GammaRayTelDetector->GetPayloadSizeXY();
95 G4double PayloadSizeZ = GammaRayTelDetector->GetPayloadSizeZ();
96
97 G4VSolid* solidPayloadRO
98 = new G4Box("Payload RO",
99 PayloadSizeXY/2,
100 PayloadSizeXY/2,
101 PayloadSizeZ/2);
102
103 G4LogicalVolume* logicPayloadRO = new
104 G4LogicalVolume(solidPayloadRO,dummyMat,"Payload RO",0,0,0);
105
106 G4VPhysicalVolume* physiPayloadRO =
107 new G4PVPlacement(0, G4ThreeVector(),
108 "Payload RO", logicPayloadRO,ROWorldPhys,false, 0);
109
110 // -------------------------------
111 // Tracker readout division:
112 // -------------------------------
113 // TRK Layers of Silicon MicroStrips
114
115
116 G4double TKRSizeXY = GammaRayTelDetector->GetTKRSizeXY();
117 G4double TKRSizeZ = GammaRayTelDetector->GetTKRSizeZ();
118 G4double CALSizeZ = GammaRayTelDetector->GetCALSizeZ();
119 G4double CALTKRDistance = GammaRayTelDetector->GetCALTKRDistance();
120
121 G4VSolid* ROsolidTKR =
122 new G4Box("ReadOutTKR", TKRSizeXY/2,TKRSizeXY/2,TKRSizeZ/2);
123
124 G4LogicalVolume* ROlogicTKR =
125 new G4LogicalVolume(ROsolidTKR,dummyMat, "ReadOutTKR",0,0,0);
126
127
128 G4VPhysicalVolume* ROphysiTKR =
129 new G4PVPlacement(0, G4ThreeVector(0,0,-PayloadSizeZ/2+CALSizeZ+
130 CALTKRDistance+TKRSizeZ/2),
131 "ReadOutTKR",ROlogicTKR,physiPayloadRO,
132 false, 0);
133
134 // TKR Layers
135
136
137 G4double TKRSiliconThickness =
138 GammaRayTelDetector->GetTKRSiliconThickness();
139 G4int NbOfTKRLayers = GammaRayTelDetector->GetNbOfTKRLayers();
140 G4double TKRLayerDistance = GammaRayTelDetector->GetTKRLayerDistance();
141 G4double TKRViewsDistance = GammaRayTelDetector->GetTKRViewsDistance();
142
143 G4VSolid* solidTKRDetectorYRO = new G4Box
144 ("TKRDetectorYRO",TKRSizeXY/2,TKRSizeXY/2,TKRSiliconThickness/2);
145
146 G4LogicalVolume* logicTKRDetectorYRO =
147 new G4LogicalVolume(solidTKRDetectorYRO,dummyMat, "TKRDetectorYRO",0,0,0);
148
149 G4VSolid* solidTKRDetectorXRO = new G4Box
150 ("TKRDetectorXRO",TKRSizeXY/2,TKRSizeXY/2,TKRSiliconThickness/2);
151
152 G4LogicalVolume* logicTKRDetectorXRO =
153 new G4LogicalVolume(solidTKRDetectorXRO,dummyMat, "TKRDetectorXRO",0,0,0);
154 G4int i=0;
155 G4VPhysicalVolume* physiTKRDetectorXRO = 0;
156 G4VPhysicalVolume* physiTKRDetectorYRO = 0;
157
158
159 for (i = 0; i < NbOfTKRLayers; i++)
160 {
161
162 physiTKRDetectorYRO =
163 new G4PVPlacement(0,G4ThreeVector(0.,0.,-TKRSizeZ/2
164 +TKRSiliconThickness/2
165 +(i)*TKRLayerDistance),
166 "TKRDetectorYRO",
167 logicTKRDetectorYRO,
168 ROphysiTKR,
169 false,
170 i);
171
172 physiTKRDetectorXRO =
173 new G4PVPlacement(0,G4ThreeVector(0.,0.,
174 -TKRSizeZ/2+
175 TKRSiliconThickness/2 +
176 TKRViewsDistance+
177 TKRSiliconThickness+
178 (i)*TKRLayerDistance),
179 "TKRDetectorXRO",
180 logicTKRDetectorXRO,
181 ROphysiTKR,
182 false,
183 i);
184 }
185
186
187 // Silicon Tiles
188 // some problems with the RO tree
189
190 G4double TKRActiveTileXY = GammaRayTelDetector->GetTKRActiveTileXY();
191 G4double TKRActiveTileZ = GammaRayTelDetector->GetTKRActiveTileZ();
192
193 G4VSolid * solidTKRActiveTileXRO = new
194 G4Box("Active Tile X", TKRActiveTileXY/2,TKRActiveTileXY/2,TKRActiveTileZ/2);
195
196 G4VSolid * solidTKRActiveTileYRO = new
197 G4Box("Active Tile Y", TKRActiveTileXY/2,TKRActiveTileXY/2,TKRActiveTileZ/2);
198
199
200 G4LogicalVolume* logicTKRActiveTileXRO =
201 new G4LogicalVolume(solidTKRActiveTileXRO, dummyMat,"Active Tile",0,0,0);
202
203 G4LogicalVolume* logicTKRActiveTileYRO =
204 new G4LogicalVolume(solidTKRActiveTileYRO, dummyMat,"Active Tile",0,0,0);
205
206 G4int j=0;
207 G4int k=0;
208
209 G4int NbOfTKRTiles = GammaRayTelDetector->GetNbOfTKRTiles();
210 G4double SiliconGuardRing = GammaRayTelDetector->GetSiliconGuardRing();
211 G4double TilesSeparation = GammaRayTelDetector->GetTilesSeparation();
212
213 G4VPhysicalVolume* physiTKRActiveTileXRO = 0;
214 G4VPhysicalVolume* physiTKRActiveTileYRO = 0;
215
216 G4double x=0.;
217 G4double y=0.;
218 G4double z=0.;
219
220 for (i=0;i< NbOfTKRTiles; i++)
221 {
222 for (j=0;j< NbOfTKRTiles; j++)
223 {
224 k = i*NbOfTKRTiles + j;
225
226 x = -TKRSizeXY/2+TilesSeparation+SiliconGuardRing+TKRActiveTileXY/2+
227 (j)*((2*SiliconGuardRing)+TilesSeparation+TKRActiveTileXY);
228 y = -TKRSizeXY/2+TilesSeparation+SiliconGuardRing+TKRActiveTileXY/2+
229 (i)*((2*SiliconGuardRing)+TilesSeparation+TKRActiveTileXY);
230 z = 0.;
231
232 physiTKRActiveTileXRO =
233 new G4PVPlacement(0,
234 G4ThreeVector(x,y,z),
235 "Active Tile X",
236 logicTKRActiveTileXRO,
237 physiTKRDetectorXRO,
238 false,
239 k);
240
241 x = -TKRSizeXY/2+TilesSeparation+SiliconGuardRing+TKRActiveTileXY/2+
242 (i)*((2*SiliconGuardRing)+TilesSeparation+TKRActiveTileXY);
243 y = -TKRSizeXY/2+TilesSeparation+SiliconGuardRing+TKRActiveTileXY/2+
244 (j)*((2*SiliconGuardRing)+TilesSeparation+TKRActiveTileXY);
245 z = 0.;
246
247 physiTKRActiveTileYRO =
248 new G4PVPlacement(0,
249 G4ThreeVector(x,y,z),
250 "Active Tile Y",
251 logicTKRActiveTileYRO,
252 physiTKRDetectorYRO,
253 false,
254 k);
255
256 }
257 }
258
259
260 // Silicon Strips
261 // some problems with the RO tree
262
263 G4double TKRXStripX=0.;
264 G4double TKRYStripY=0.;
265 G4double TKRYStripX=0.;
266 G4double TKRXStripY=0.;
267
268 TKRXStripX = TKRYStripY = GammaRayTelDetector->GetTKRSiliconPitch();
269 TKRYStripX = TKRXStripY= GammaRayTelDetector->GetTKRActiveTileXY();
270 G4double TKRZStrip = GammaRayTelDetector->GetTKRSiliconThickness();
271
272 G4int NbOfTKRStrips = GammaRayTelDetector->GetNbOfTKRStrips();
273
274
275 G4VSolid* solidTKRStripX = new G4Box("Strip X",
276 TKRXStripX/2,TKRYStripX/2,
277 TKRZStrip/2);
278
279 G4LogicalVolume* logicTKRStripX =
280 new G4LogicalVolume(solidTKRStripX,dummyMat,"Strip X",0,0,0);
281
282
283 G4VSolid* solidTKRStripY = new G4Box("Strip Y",
284 TKRXStripY/2,TKRYStripY/2,
285 TKRZStrip/2);
286
287
288 G4LogicalVolume* logicTKRStripY =
289 new G4LogicalVolume(solidTKRStripY,dummyMat,"Strip Y",0,0,0);
290
291
292 G4VPhysicalVolume* physiTKRStripX = 0;
293 G4VPhysicalVolume* physiTKRStripY = 0;
294 G4double TKRSiliconPitch = GammaRayTelDetector->GetTKRSiliconPitch();
295
296 for (i=0;i< NbOfTKRStrips; i++)
297 {
298 physiTKRStripX = new
299 G4PVPlacement(0,G4ThreeVector(-TKRActiveTileXY/2 +TKRSiliconPitch/2 +
300 (i)*TKRSiliconPitch, 0., 0.),
301 "Strip X",
302 logicTKRStripX,
303 physiTKRActiveTileXRO,
304 false,
305 i);
306
307
308 physiTKRStripY = new
309 G4PVPlacement(0,G4ThreeVector(0.,-TKRActiveTileXY/2
310 +TKRSiliconPitch/2 +
311 (i)*TKRSiliconPitch, 0.),
312 "Strip Y",
313 logicTKRStripY,
314 physiTKRActiveTileYRO,
315 false,
316 i);
317
318
319
320
321
322 }
323
324
325
326 //Flags the strip as sensitive .The pointer here serves
327 // as a flag only to check for sensitivity.
328 // (Could we make it by a simple cast of a non-NULL value ?)
329
330 GammaRayTelDummySD * dummySensi = new GammaRayTelDummySD("Orpo");
331
332 logicTKRStripX->SetSensitiveDetector(dummySensi);
333 logicTKRStripY->SetSensitiveDetector(dummySensi);
334
335 //logicTKRActiveTileXRO->SetSensitiveDetector(dummySensi);
336 //logicTKRActiveTileYRO->SetSensitiveDetector(dummySensi);
337 //logicTKRDetectorRO->SetSensitiveDetector(dummySensi);
338
339 return ROWorldPhys;
340}
341
342
343
344
345
346
347
348
349
350
Note: See TracBrowser for help on using the repository browser.