| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // Hadrontherapy advanced example for Geant4 26 // Hadrontherapy advanced example for Geant4
27 // See more at: https://twiki.cern.ch/twiki/bi 27 // See more at: https://twiki.cern.ch/twiki/bin/view/Geant4/AdvancedExamplesHadrontherapy
28 28
29 #include "G4UnitsTable.hh" 29 #include "G4UnitsTable.hh"
30 #include "G4SystemOfUnits.hh" 30 #include "G4SystemOfUnits.hh"
31 #include "G4LogicalVolume.hh" 31 #include "G4LogicalVolume.hh"
32 #include "G4VPhysicalVolume.hh" 32 #include "G4VPhysicalVolume.hh"
33 #include "G4PVPlacement.hh" 33 #include "G4PVPlacement.hh"
34 #include "G4PVReplica.hh" 34 #include "G4PVReplica.hh"
35 #include "G4Box.hh" 35 #include "G4Box.hh"
36 #include "G4ThreeVector.hh" 36 #include "G4ThreeVector.hh"
37 #include "G4Material.hh" 37 #include "G4Material.hh"
38 #include "G4NistManager.hh" 38 #include "G4NistManager.hh"
39 #include "G4GeometryManager.hh" 39 #include "G4GeometryManager.hh"
40 #include "G4SolidStore.hh" 40 #include "G4SolidStore.hh"
41 #include "G4LogicalVolumeStore.hh" 41 #include "G4LogicalVolumeStore.hh"
42 42
43 43
44 44
45 #include "G4SDManager.hh" 45 #include "G4SDManager.hh"
46 #include "G4RunManager.hh" 46 #include "G4RunManager.hh"
47 47
48 #include "G4PhysicalVolumeStore.hh" 48 #include "G4PhysicalVolumeStore.hh"
49 49
50 #include "G4ThreeVector.hh" 50 #include "G4ThreeVector.hh"
51 51
52 #include "globals.hh" 52 #include "globals.hh"
53 #include "G4Transform3D.hh" 53 #include "G4Transform3D.hh"
54 #include "G4RotationMatrix.hh" 54 #include "G4RotationMatrix.hh"
55 #include "G4Colour.hh" 55 #include "G4Colour.hh"
56 #include "G4UserLimits.hh" 56 #include "G4UserLimits.hh"
57 57
58 #include "G4VisAttributes.hh" 58 #include "G4VisAttributes.hh"
59 59
60 #include "HadrontherapyDetectorROGeometry.hh" 60 #include "HadrontherapyDetectorROGeometry.hh"
61 #include "HadrontherapyDummySD.hh" 61 #include "HadrontherapyDummySD.hh"
62 #include "HadrontherapyDetectorSD.hh" 62 #include "HadrontherapyDetectorSD.hh"
63 63
64 ////////////////////////////////////////////// 64 /////////////////////////////////////////////////////////////////////////////
65 HadrontherapyDetectorROGeometry::Hadrontherapy 65 HadrontherapyDetectorROGeometry::HadrontherapyDetectorROGeometry(G4String aString)
66 : G4VUserParallelWorld(aString),RODetector(0 66 : G4VUserParallelWorld(aString),RODetector(0),RODetectorXDivision(0),
67 RODetectorYDivision(0),RODetectorZDivision 67 RODetectorYDivision(0),RODetectorZDivision(0),worldLogical(0),RODetectorLog(0),
68 RODetectorXDivisionLog(0),RODetectorYDivis 68 RODetectorXDivisionLog(0),RODetectorYDivisionLog(0),RODetectorZDivisionLog(0),
69 sensitiveLogicalVolume(0) 69 sensitiveLogicalVolume(0)
70 { 70 {
71 isBuilt = false; 71 isBuilt = false;
72 isInitialized = false; 72 isInitialized = false;
73 } 73 }
74 74
75 ////////////////////////////////////////////// 75 /////////////////////////////////////////////////////////////////////////////
76 76
77 void HadrontherapyDetectorROGeometry::Initiali 77 void HadrontherapyDetectorROGeometry::Initialize(G4ThreeVector pos,
78 G4double detectorDimX, 78 G4double detectorDimX,
79 G4double detectorDimY, 79 G4double detectorDimY,
80 G4double detectorDimZ, 80 G4double detectorDimZ,
81 G4int numberOfVoxelsX, 81 G4int numberOfVoxelsX,
82 G4int numberOfVoxelsY, 82 G4int numberOfVoxelsY,
83 G4int numberOfVoxelsZ) 83 G4int numberOfVoxelsZ)
84 { 84 {
85 detectorToWorldPosition = pos; 85 detectorToWorldPosition = pos;
86 detectorSizeX = detectorDimX; 86 detectorSizeX = detectorDimX;
87 detectorSizeY= detectorDimY; 87 detectorSizeY= detectorDimY;
88 detectorSizeZ=detectorDimZ; 88 detectorSizeZ=detectorDimZ;
89 numberOfVoxelsAlongX=numberOfVoxelsX; 89 numberOfVoxelsAlongX=numberOfVoxelsX;
90 numberOfVoxelsAlongY=numberOfVoxelsY; 90 numberOfVoxelsAlongY=numberOfVoxelsY;
91 numberOfVoxelsAlongZ=numberOfVoxelsZ; 91 numberOfVoxelsAlongZ=numberOfVoxelsZ;
92 92
93 isInitialized = true; 93 isInitialized = true;
94 94
95 95
96 96
97 } 97 }
98 98
99 void HadrontherapyDetectorROGeometry::UpdateRO 99 void HadrontherapyDetectorROGeometry::UpdateROGeometry()
100 { 100 {
101 //Nothing happens if the RO geometry is not 101 //Nothing happens if the RO geometry is not built. But parameters are properly set.
102 if (!isBuilt) 102 if (!isBuilt)
103 { 103 {
104 //G4Exception("HadrontherapyDetectorROGe 104 //G4Exception("HadrontherapyDetectorROGeometry::UpdateROGeometry","had001",
105 // JustWarning,"Cannot update geome 105 // JustWarning,"Cannot update geometry before it is built");
106 return; 106 return;
107 } 107 }
108 108
109 //1) Update the dimensions of the G4Boxes 109 //1) Update the dimensions of the G4Boxes
110 G4double halfDetectorSizeX = detectorSizeX; 110 G4double halfDetectorSizeX = detectorSizeX;
111 G4double halfDetectorSizeY = detectorSizeY; 111 G4double halfDetectorSizeY = detectorSizeY;
112 G4double halfDetectorSizeZ = detectorSizeZ; 112 G4double halfDetectorSizeZ = detectorSizeZ;
113 113
114 RODetector->SetXHalfLength(halfDetectorSizeX 114 RODetector->SetXHalfLength(halfDetectorSizeX);
115 RODetector->SetYHalfLength(halfDetectorSizeY 115 RODetector->SetYHalfLength(halfDetectorSizeY);
116 RODetector->SetZHalfLength(halfDetectorSizeZ 116 RODetector->SetZHalfLength(halfDetectorSizeZ);
117 117
118 G4double halfXVoxelSizeX = halfDetectorSizeX 118 G4double halfXVoxelSizeX = halfDetectorSizeX/numberOfVoxelsAlongX;
119 G4double halfXVoxelSizeY = halfDetectorSizeY 119 G4double halfXVoxelSizeY = halfDetectorSizeY;
120 G4double halfXVoxelSizeZ = halfDetectorSizeZ 120 G4double halfXVoxelSizeZ = halfDetectorSizeZ;
121 G4double voxelXThickness = 2*halfXVoxelSizeX 121 G4double voxelXThickness = 2*halfXVoxelSizeX;
122 122
123 RODetectorXDivision->SetXHalfLength(halfXVox 123 RODetectorXDivision->SetXHalfLength(halfXVoxelSizeX);
124 RODetectorXDivision->SetYHalfLength(halfXVox 124 RODetectorXDivision->SetYHalfLength(halfXVoxelSizeY);
125 RODetectorXDivision->SetZHalfLength(halfXVox 125 RODetectorXDivision->SetZHalfLength(halfXVoxelSizeZ);
126 126
127 G4double halfYVoxelSizeX = halfXVoxelSizeX; 127 G4double halfYVoxelSizeX = halfXVoxelSizeX;
128 G4double halfYVoxelSizeY = halfDetectorSizeY 128 G4double halfYVoxelSizeY = halfDetectorSizeY/numberOfVoxelsAlongY;
129 G4double halfYVoxelSizeZ = halfDetectorSizeZ 129 G4double halfYVoxelSizeZ = halfDetectorSizeZ;
130 G4double voxelYThickness = 2*halfYVoxelSizeY 130 G4double voxelYThickness = 2*halfYVoxelSizeY;
131 131
132 RODetectorYDivision->SetXHalfLength(halfYVox 132 RODetectorYDivision->SetXHalfLength(halfYVoxelSizeX);
133 RODetectorYDivision->SetYHalfLength(halfYVox 133 RODetectorYDivision->SetYHalfLength(halfYVoxelSizeY);
134 RODetectorYDivision->SetZHalfLength(halfYVox 134 RODetectorYDivision->SetZHalfLength(halfYVoxelSizeZ);
135 135
136 G4double halfZVoxelSizeX = halfXVoxelSizeX; 136 G4double halfZVoxelSizeX = halfXVoxelSizeX;
137 G4double halfZVoxelSizeY = halfYVoxelSizeY; 137 G4double halfZVoxelSizeY = halfYVoxelSizeY;
138 G4double halfZVoxelSizeZ = halfDetectorSizeZ 138 G4double halfZVoxelSizeZ = halfDetectorSizeZ/numberOfVoxelsAlongZ;
139 G4double voxelZThickness = 2*halfZVoxelSizeZ 139 G4double voxelZThickness = 2*halfZVoxelSizeZ;
140 140
141 RODetectorZDivision->SetXHalfLength(halfZVox 141 RODetectorZDivision->SetXHalfLength(halfZVoxelSizeX);
142 RODetectorZDivision->SetYHalfLength(halfZVox 142 RODetectorZDivision->SetYHalfLength(halfZVoxelSizeY);
143 RODetectorZDivision->SetZHalfLength(halfZVox 143 RODetectorZDivision->SetZHalfLength(halfZVoxelSizeZ);
144 144
145 //Delete and re-build the relevant physical 145 //Delete and re-build the relevant physical volumes
146 G4PhysicalVolumeStore* store = 146 G4PhysicalVolumeStore* store =
147 G4PhysicalVolumeStore::GetInstance(); 147 G4PhysicalVolumeStore::GetInstance();
148 148
149 //Delete... 149 //Delete...
150 G4VPhysicalVolume* myVol = store->GetVolume( 150 G4VPhysicalVolume* myVol = store->GetVolume("RODetectorPhys");
151 store->DeRegister(myVol); 151 store->DeRegister(myVol);
152 //..and rebuild 152 //..and rebuild
153 G4VPhysicalVolume *RODetectorPhys = new G4PV 153 G4VPhysicalVolume *RODetectorPhys = new G4PVPlacement(0,
154 detectorToWorldPosition, 154 detectorToWorldPosition,
155 RODetectorLog, 155 RODetectorLog,
156 "RODetectorPhys", 156 "RODetectorPhys",
157 worldLogical, 157 worldLogical,
158 false,0); 158 false,0);
159 159
160 myVol = store->GetVolume("RODetectorXDivisio 160 myVol = store->GetVolume("RODetectorXDivisionPhys");
161 store->DeRegister(myVol); 161 store->DeRegister(myVol);
162 G4VPhysicalVolume *RODetectorXDivisionPhys = 162 G4VPhysicalVolume *RODetectorXDivisionPhys = new G4PVReplica("RODetectorXDivisionPhys",
163 RODetectorXDivisionLog, 163 RODetectorXDivisionLog,
164 RODetectorPhys, 164 RODetectorPhys,
165 kXAxis, 165 kXAxis,
166 numberOfVoxelsAlongX, 166 numberOfVoxelsAlongX,
167 voxelXThickness); 167 voxelXThickness);
168 myVol = store->GetVolume("RODetectorYDivisio 168 myVol = store->GetVolume("RODetectorYDivisionPhys");
169 store->DeRegister(myVol); 169 store->DeRegister(myVol);
170 G4VPhysicalVolume *RODetectorYDivisionPhys = 170 G4VPhysicalVolume *RODetectorYDivisionPhys = new G4PVReplica("RODetectorYDivisionPhys",
171 RODetectorYDivisionLog, 171 RODetectorYDivisionLog,
172 RODetectorXDivisionPhys, 172 RODetectorXDivisionPhys,
173 kYAxis, 173 kYAxis,
174 numberOfVoxelsAlongY, 174 numberOfVoxelsAlongY,
175 voxelYThickness); 175 voxelYThickness);
176 176
177 myVol = store->GetVolume("RODetectorZDivisio 177 myVol = store->GetVolume("RODetectorZDivisionPhys");
178 store->DeRegister(myVol); 178 store->DeRegister(myVol);
179 new G4PVReplica("RODetectorZDivisionPhys", 179 new G4PVReplica("RODetectorZDivisionPhys",
180 RODetectorZDivisionLog, 180 RODetectorZDivisionLog,
181 RODetectorYDivisionPhys, 181 RODetectorYDivisionPhys,
182 kZAxis, 182 kZAxis,
183 numberOfVoxelsAlongZ, 183 numberOfVoxelsAlongZ,
184 voxelZThickness); 184 voxelZThickness);
185 185
186 return; 186 return;
187 187
188 } 188 }
189 189
190 ////////////////////////////////////////////// 190 /////////////////////////////////////////////////////////////////////////////
191 HadrontherapyDetectorROGeometry::~Hadrontherap 191 HadrontherapyDetectorROGeometry::~HadrontherapyDetectorROGeometry()
192 {;} 192 {;}
193 193
194 ////////////////////////////////////////////// 194 /////////////////////////////////////////////////////////////////////////////
195 void HadrontherapyDetectorROGeometry::Construc 195 void HadrontherapyDetectorROGeometry::Construct()
196 { 196 {
197 // A dummy material is used to fill the volu 197 // A dummy material is used to fill the volumes of the readout geometry.
198 // (It will be allowed to set a NULL pointer 198 // (It will be allowed to set a NULL pointer in volumes of such virtual
199 // division in future, since this material i 199 // division in future, since this material is irrelevant for tracking.)
200 200
201 201
202 // 202 //
203 // World 203 // World
204 // 204 //
205 G4VPhysicalVolume* ghostWorld = GetWorld(); 205 G4VPhysicalVolume* ghostWorld = GetWorld();
206 worldLogical = ghostWorld->GetLogicalVolume( 206 worldLogical = ghostWorld->GetLogicalVolume();
207 207
208 if (!isInitialized) 208 if (!isInitialized)
209 { 209 {
210 G4Exception("HadrontherapyDetectorROGeom 210 G4Exception("HadrontherapyDetectorROGeometry::Construct","had001",
211 FatalException,"Parameters of the RO geo 211 FatalException,"Parameters of the RO geometry are not initialized");
212 return; 212 return;
213 } 213 }
214 214
215 215
216 G4double halfDetectorSizeX = detectorSizeX; 216 G4double halfDetectorSizeX = detectorSizeX;
217 G4double halfDetectorSizeY = detectorSizeY; 217 G4double halfDetectorSizeY = detectorSizeY;
218 G4double halfDetectorSizeZ = detectorSizeZ; 218 G4double halfDetectorSizeZ = detectorSizeZ;
219 219
220 // World volume of ROGeometry ... SERVE SO 220 // World volume of ROGeometry ... SERVE SOLO PER LA ROG
221 221
222 // Detector ROGeometry 222 // Detector ROGeometry
223 RODetector = new G4Box("RODetector", 223 RODetector = new G4Box("RODetector",
224 halfDetectorSizeX, 224 halfDetectorSizeX,
225 halfDetectorSizeY, 225 halfDetectorSizeY,
226 halfDetectorSizeZ); 226 halfDetectorSizeZ);
227 227
228 RODetectorLog = new G4LogicalVolume(RODetect 228 RODetectorLog = new G4LogicalVolume(RODetector,
229 0, 229 0,
230 "RODetectorLog", 230 "RODetectorLog",
231 0,0,0); 231 0,0,0);
232 232
233 233
234 234
235 G4VPhysicalVolume *RODetectorPhys = new G4PV 235 G4VPhysicalVolume *RODetectorPhys = new G4PVPlacement(0,
236 detectorToWorldPosition,RODetect 236 detectorToWorldPosition,RODetectorLog,
237 "RODetectorPhys", 237 "RODetectorPhys",
238 worldLogical, 238 worldLogical,
239 false,0); 239 false,0);
240 240
241 241
242 242
243 243
244 // Division along X axis: the detector is di 244 // Division along X axis: the detector is divided in slices along the X axis
245 245
246 G4double halfXVoxelSizeX = halfDetectorSizeX 246 G4double halfXVoxelSizeX = halfDetectorSizeX/numberOfVoxelsAlongX;
247 G4double halfXVoxelSizeY = halfDetectorSizeY 247 G4double halfXVoxelSizeY = halfDetectorSizeY;
248 G4double halfXVoxelSizeZ = halfDetectorSizeZ 248 G4double halfXVoxelSizeZ = halfDetectorSizeZ;
249 G4double voxelXThickness = 2*halfXVoxelSizeX 249 G4double voxelXThickness = 2*halfXVoxelSizeX;
250 250
251 251
252 RODetectorXDivision = new G4Box("RODetectorX 252 RODetectorXDivision = new G4Box("RODetectorXDivision",
253 halfXVoxelSizeX, 253 halfXVoxelSizeX,
254 halfXVoxelSizeY, 254 halfXVoxelSizeY,
255 halfXVoxelSizeZ); 255 halfXVoxelSizeZ);
256 256
257 RODetectorXDivisionLog = new G4LogicalVolume 257 RODetectorXDivisionLog = new G4LogicalVolume(RODetectorXDivision,
258 0, 258 0,
259 "RODetectorXDivisionLog", 259 "RODetectorXDivisionLog",
260 0,0,0); 260 0,0,0);
261 261
262 G4VPhysicalVolume *RODetectorXDivisionPhys = 262 G4VPhysicalVolume *RODetectorXDivisionPhys = new G4PVReplica("RODetectorXDivisionPhys",
263 263 RODetectorXDivisionLog,
264 264 RODetectorPhys,
265 265 kXAxis,
266 266 numberOfVoxelsAlongX,
267 267 voxelXThickness);
268 268
269 // Division along Y axis: the slices along t 269 // Division along Y axis: the slices along the X axis are divided along the Y axis
270 270
271 G4double halfYVoxelSizeX = halfXVoxelSizeX; 271 G4double halfYVoxelSizeX = halfXVoxelSizeX;
272 G4double halfYVoxelSizeY = halfDetectorSizeY 272 G4double halfYVoxelSizeY = halfDetectorSizeY/numberOfVoxelsAlongY;
273 G4double halfYVoxelSizeZ = halfDetectorSizeZ 273 G4double halfYVoxelSizeZ = halfDetectorSizeZ;
274 G4double voxelYThickness = 2*halfYVoxelSizeY 274 G4double voxelYThickness = 2*halfYVoxelSizeY;
275 275
276 RODetectorYDivision = new G4Box("RODetectorY 276 RODetectorYDivision = new G4Box("RODetectorYDivision",
277 halfYVoxelSizeX, 277 halfYVoxelSizeX,
278 halfYVoxelSizeY, 278 halfYVoxelSizeY,
279 halfYVoxelSizeZ); 279 halfYVoxelSizeZ);
280 280
281 RODetectorYDivisionLog = new G4LogicalVolume 281 RODetectorYDivisionLog = new G4LogicalVolume(RODetectorYDivision,
282 0, 282 0,
283 "RODetectorYDivisionLog", 283 "RODetectorYDivisionLog",
284 0,0,0); 284 0,0,0);
285 285
286 G4VPhysicalVolume *RODetectorYDivisionPhys = 286 G4VPhysicalVolume *RODetectorYDivisionPhys = new G4PVReplica("RODetectorYDivisionPhys",
287 RODetectorYDivisionLog, 287 RODetectorYDivisionLog,
288 RODetectorXDivisionPhys, 288 RODetectorXDivisionPhys,
289 kYAxis, 289 kYAxis,
290 numberOfVoxelsAlongY, 290 numberOfVoxelsAlongY,
291 voxelYThickness); 291 voxelYThickness);
292 292
293 // Division along Z axis: the slices along t 293 // Division along Z axis: the slices along the Y axis are divided along the Z axis
294 294
295 G4double halfZVoxelSizeX = halfXVoxelSizeX; 295 G4double halfZVoxelSizeX = halfXVoxelSizeX;
296 G4double halfZVoxelSizeY = halfYVoxelSizeY; 296 G4double halfZVoxelSizeY = halfYVoxelSizeY;
297 G4double halfZVoxelSizeZ = halfDetectorSizeZ 297 G4double halfZVoxelSizeZ = halfDetectorSizeZ/numberOfVoxelsAlongZ;
298 G4double voxelZThickness = 2*halfZVoxelSizeZ 298 G4double voxelZThickness = 2*halfZVoxelSizeZ;
299 299
300 RODetectorZDivision = new G4Box("RODetectorZ 300 RODetectorZDivision = new G4Box("RODetectorZDivision",
301 halfZVoxelSizeX, 301 halfZVoxelSizeX,
302 halfZVoxelSizeY, 302 halfZVoxelSizeY,
303 halfZVoxelSizeZ); 303 halfZVoxelSizeZ);
304 304
305 RODetectorZDivisionLog = new G4LogicalVolume 305 RODetectorZDivisionLog = new G4LogicalVolume(RODetectorZDivision,
306 0, 306 0,
307 "RODetectorZDivisionLog", 307 "RODetectorZDivisionLog",
308 0,0,0); 308 0,0,0);
309 309
310 new G4PVReplica("RODetectorZDivisionPhys", 310 new G4PVReplica("RODetectorZDivisionPhys",
311 RODetectorZDivisionLog, 311 RODetectorZDivisionLog,
312 RODetectorYDivisionPhys, 312 RODetectorYDivisionPhys,
313 kZAxis, 313 kZAxis,
314 numberOfVoxelsAlongZ, 314 numberOfVoxelsAlongZ,
315 voxelZThickness); 315 voxelZThickness);
316 316
317 sensitiveLogicalVolume = RODetectorZDivision 317 sensitiveLogicalVolume = RODetectorZDivisionLog;
318 isBuilt = true; 318 isBuilt = true;
319 } 319 }
320 320
321 void HadrontherapyDetectorROGeometry::Construc 321 void HadrontherapyDetectorROGeometry::ConstructSD()
322 { 322 {
323 G4String sensitiveDetectorName = "RODetector" 323 G4String sensitiveDetectorName = "RODetector";
324 324
325 HadrontherapyDetectorSD* detectorSD = new Had 325 HadrontherapyDetectorSD* detectorSD = new HadrontherapyDetectorSD(sensitiveDetectorName);
326 G4SDManager::GetSDMpointer()->AddNewDetector( 326 G4SDManager::GetSDMpointer()->AddNewDetector(detectorSD);
327 sensitiveLogicalVolume->SetSensitiveDetector( 327 sensitiveLogicalVolume->SetSensitiveDetector(detectorSD);
328 328
329 // SetSensitiveDetector(sensitiveLogicalVolum 329 // SetSensitiveDetector(sensitiveLogicalVolume,detectorSD);
330 330
331 331
332 } 332 }
333 333
334 334