| 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 //
27 // See more at: https://twiki.cern.ch/twiki/bi << 27 // $Id: HadrontherapyDetectorConstruction.cc;
>> 28 // Last modified: G.A.P.Cirrone, April 2008;
>> 29 //
>> 30 // See more at: http://geant4infn.wikispaces.com
>> 31 //
>> 32 // ----------------------------------------------------------------------------
>> 33 // GEANT 4 - Hadrontherapy example
>> 34 // ----------------------------------------------------------------------------
>> 35 // Code developed by:
>> 36 //
>> 37 // G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
>> 38 //
>> 39 // (a) Laboratori Nazionali del Sud
>> 40 // of the INFN, Catania, Italy
>> 41 // (b) INFN Section of Genova, Genova, Italy
>> 42 //
>> 43 // * cirrone@lns.infn.it
>> 44 // ----------------------------------------------------------------------------
28 45
29 #include "G4UnitsTable.hh" <<
30 #include "G4SDManager.hh" 46 #include "G4SDManager.hh"
31 #include "G4RunManager.hh" 47 #include "G4RunManager.hh"
32 #include "G4GeometryManager.hh" <<
33 #include "G4SolidStore.hh" <<
34 #include "G4PhysicalVolumeStore.hh" <<
35 #include "G4LogicalVolumeStore.hh" <<
36 #include "G4Box.hh" 48 #include "G4Box.hh"
37 #include "G4LogicalVolume.hh" 49 #include "G4LogicalVolume.hh"
38 #include "G4ThreeVector.hh" 50 #include "G4ThreeVector.hh"
39 #include "G4PVPlacement.hh" 51 #include "G4PVPlacement.hh"
40 #include "globals.hh" 52 #include "globals.hh"
41 #include "G4Transform3D.hh" 53 #include "G4Transform3D.hh"
42 #include "G4RotationMatrix.hh" 54 #include "G4RotationMatrix.hh"
43 #include "G4Colour.hh" 55 #include "G4Colour.hh"
44 #include "G4UserLimits.hh" 56 #include "G4UserLimits.hh"
45 #include "G4UnitsTable.hh" <<
46 #include "G4VisAttributes.hh" 57 #include "G4VisAttributes.hh"
47 #include "G4NistManager.hh" <<
48 #include "HadrontherapyDetectorConstruction.hh <<
49 #include "HadrontherapyDetectorROGeometry.hh" 58 #include "HadrontherapyDetectorROGeometry.hh"
50 #include "HadrontherapyDetectorMessenger.hh" 59 #include "HadrontherapyDetectorMessenger.hh"
51 #include "HadrontherapyDetectorSD.hh" 60 #include "HadrontherapyDetectorSD.hh"
52 #include "HadrontherapyMatrix.hh" << 61 #include "HadrontherapyDetectorConstruction.hh"
53 #include "HadrontherapyLet.hh" << 62 #include "HadrontherapyMaterial.hh"
54 #include "PassiveProtonBeamLine.hh" << 63 #include "HadrontherapyBeamLine.hh"
55 #include "BESTPassiveProtonBeamLine.hh" << 64 #include "HadrontherapyModulator.hh"
56 #include "HadrontherapyMatrix.hh" << 65
57 << 66 /////////////////////////////////////////////////////////////////////////////
58 #include "HadrontherapyRBE.hh" << 67 HadrontherapyDetectorConstruction::HadrontherapyDetectorConstruction()
59 #include "G4SystemOfUnits.hh" << 68 : detectorSD(0), detectorROGeometry(0), beamLine(0), modulator(0),
60 << 69 physicalTreatmentRoom(0),
61 #include <cmath> << 70 patientPhysicalVolume(0),
62 << 71 detectorLogicalVolume(0),
63 << 72 detectorPhysicalVolume(0)
64 << 73 {
65 HadrontherapyDetectorConstruction* Hadronthera << 74 // Messenger to change parameters of the geometry
66 ////////////////////////////////////////////// << 75 detectorMessenger = new HadrontherapyDetectorMessenger(this);
67 HadrontherapyDetectorConstruction::Hadronthera << 76
68 : motherPhys(physicalTreatmentRoom), // pointe << 77 material = new HadrontherapyMaterial();
69 detectorSD(0), detectorROGeometry(0), matrix(0 << 78
70 phantom(0), detector(0), << 79 // Detector sizes
71 phantomLogicalVolume(0), detectorLogicalVolume << 80 detectorSizeX = 20.*mm;
72 phantomPhysicalVolume(0), detectorPhysicalVolu << 81 detectorSizeY = 20.*mm;
73 aRegion(0) << 82 detectorSizeZ = 20.*mm;
74 { << 83
75 << 84 // Number of the detector voxels
76 << 85 numberOfVoxelsAlongX = 400;
77 /* NOTE! that the HadrontherapyDetectorCon << 86 numberOfVoxelsAlongY = 1;
78 * does NOT inherit from G4VUserDetectorCo << 87 numberOfVoxelsAlongZ = 1;
79 * So the Construct() mandatory virtual me <<
80 * like the passiveProtonBeamLIne, ... <<
81 */ <<
82 <<
83 // Messenger to change parameters of the p <<
84 detectorMessenger = new HadrontherapyDetec <<
85 <<
86 // Default detector voxels size <<
87 // 200 slabs along the beam direction (X) <<
88 sizeOfVoxelAlongX = 200 *um; <<
89 sizeOfVoxelAlongY = 4 *cm; <<
90 sizeOfVoxelAlongZ = 4 *cm; <<
91 <<
92 // Define here the material of the water p <<
93 SetPhantomMaterial("G4_WATER"); <<
94 // Construct geometry (messenger commands) <<
95 // SetDetectorSize(4.*cm, 4.*cm, 4.*cm); <<
96 SetDetectorSize(4. *cm, 4. *cm, 4. *cm); <<
97 SetPhantomSize(40. *cm, 40. *cm, 40. *cm); <<
98 <<
99 SetPhantomPosition(G4ThreeVector(20. *cm, <<
100 SetDetectorToPhantomPosition(G4ThreeVector <<
101 SetDetectorPosition(); <<
102 //GetDetectorToWorldPosition(); <<
103 <<
104 // Write virtual parameters to the real on <<
105 UpdateGeometry(); <<
106 <<
107 <<
108 <<
109 } 88 }
110 89
111 ////////////////////////////////////////////// 90 /////////////////////////////////////////////////////////////////////////////
112 HadrontherapyDetectorConstruction::~Hadronther 91 HadrontherapyDetectorConstruction::~HadrontherapyDetectorConstruction()
113 { << 92 {
114 delete detectorROGeometry; << 93 delete material;
115 delete matrix; << 94 if (detectorROGeometry) delete detectorROGeometry;
116 delete detectorMessenger; << 95 delete detectorMessenger;
>> 96 }
>> 97
>> 98 G4VPhysicalVolume* HadrontherapyDetectorConstruction::Construct()
>> 99 {
>> 100 // Define the materials of the experimental set-up
>> 101 material -> DefineMaterials();
>> 102
>> 103 // Define the geometry components
>> 104 ConstructBeamLine();
>> 105 ConstructDetector();
>> 106
>> 107 // Set the sensitive detector where the energy deposit is collected
>> 108 ConstructSensitiveDetector();
>> 109
>> 110 return physicalTreatmentRoom;
>> 111 }
>> 112
>> 113 /////////////////////////////////////////////////////////////////////////////
>> 114 void HadrontherapyDetectorConstruction::ConstructBeamLine()
>> 115 {
>> 116 G4Material* air = material -> GetMat("Air") ;
>> 117 G4Material* water = material -> GetMat("G4_WATER");
>> 118
>> 119 // -----------------------------
>> 120 // Treatment room - World volume
>> 121 //------------------------------
>> 122
>> 123 // Treatment room sizes
>> 124 const G4double worldX = 400.0 *cm;
>> 125 const G4double worldY = 400.0 *cm;
>> 126 const G4double worldZ = 400.0 *cm;
>> 127
>> 128 G4Box* treatmentRoom = new G4Box("TreatmentRoom",worldX,worldY,worldZ);
>> 129
>> 130 G4LogicalVolume* logicTreatmentRoom = new G4LogicalVolume(treatmentRoom,
>> 131 air,
>> 132 "logicTreatmentRoom",
>> 133 0,0,0);
>> 134 physicalTreatmentRoom = new G4PVPlacement(0,
>> 135 G4ThreeVector(),
>> 136 "physicalTreatmentRoom",
>> 137 logicTreatmentRoom,
>> 138 0,false,0);
>> 139
>> 140 G4double maxStepTreatmentRoom = 0.1 *mm;
>> 141 logicTreatmentRoom -> SetUserLimits(new G4UserLimits(maxStepTreatmentRoom));
>> 142
>> 143 // The treatment room is invisible in the Visualisation
>> 144 logicTreatmentRoom -> SetVisAttributes (G4VisAttributes::Invisible);
>> 145
>> 146 beamLine = new HadrontherapyBeamLine(physicalTreatmentRoom);
>> 147 beamLine -> HadrontherapyBeamLineSupport();
>> 148 beamLine -> HadrontherapyBeamScatteringFoils();
>> 149 beamLine -> HadrontherapyRangeShifter();
>> 150 beamLine -> HadrontherapyBeamCollimators();
>> 151 beamLine -> HadrontherapyBeamMonitoring();
>> 152 beamLine -> HadrontherapyMOPIDetector();
>> 153 beamLine -> HadrontherapyBeamNozzle();
>> 154 beamLine -> HadrontherapyBeamFinalCollimator();
>> 155
>> 156 modulator = new HadrontherapyModulator();
>> 157 modulator -> BuildModulator(physicalTreatmentRoom);
>> 158
>> 159 //----------------------------------------
>> 160 // Patient:
>> 161 // a water box used to approximate tissues
>> 162 //----------------------------------------
>> 163
>> 164 G4Box* patient = new G4Box("patient",20 *cm, 20 *cm, 20 *cm);
>> 165
>> 166 G4LogicalVolume* patientLogicalVolume = new G4LogicalVolume(patient,
>> 167 water,
>> 168 "patientLog", 0, 0, 0);
>> 169
>> 170 patientPhysicalVolume = new G4PVPlacement(0,G4ThreeVector(200.*mm, 0.*mm, 0.*mm),
>> 171 "patientPhys",
>> 172 patientLogicalVolume,
>> 173 physicalTreatmentRoom,
>> 174 false,0);
>> 175
>> 176 // Visualisation attributes of the patient
>> 177 G4VisAttributes * redWire = new G4VisAttributes(G4Colour(1. ,0. ,0.));
>> 178 redWire -> SetVisibility(true);
>> 179 redWire -> SetForceWireframe(true);
>> 180 patientLogicalVolume -> SetVisAttributes(redWire);
117 } 181 }
118 182
119 ////////////////////////////////////////////// 183 /////////////////////////////////////////////////////////////////////////////
120 HadrontherapyDetectorConstruction* Hadronthera <<
121 { <<
122 return instance; <<
123 } <<
124 <<
125 ////////////////////////////////////////////// <<
126 // ConstructPhantom() is the method that const <<
127 // (or water phantom) in the usual Medical phy <<
128 // A water phantom can be considered a good ap <<
129 void HadrontherapyDetectorConstruction::Constr <<
130 { <<
131 // Definition of the solid volume of the P <<
132 phantom = new G4Box("Phantom", <<
133 phantomSizeX/2, <<
134 phantomSizeY/2, <<
135 phantomSizeZ/2); <<
136 <<
137 // Definition of the logical volume of the <<
138 phantomLogicalVolume = new G4LogicalVolume <<
139 <<
140 <<
141 <<
142 // Definition of the physics volume of the <<
143 phantomPhysicalVolume = new G4PVPlacement( <<
144 <<
145 <<
146 <<
147 <<
148 <<
149 <<
150 <<
151 // Visualisation attributes of the phantom <<
152 red = new G4VisAttributes(G4Colour(255/255 <<
153 red -> SetVisibility(true); <<
154 red -> SetForceSolid(true); <<
155 red -> SetForceWireframe(true); <<
156 phantomLogicalVolume -> SetVisAttributes(r <<
157 } <<
158 <<
159 ////////////////////////////////////////////// <<
160 // ConstructDetector() is the method the recon <<
161 // inside the water phantom. It is a volume, l <<
162 // <<
163 // ************************** <<
164 // * water phantom * <<
165 // * * <<
166 // * * <<
167 // *--------------- * <<
168 // Beam * - * <<
169 // -----> * detector - * <<
170 // * - * <<
171 // *--------------- * <<
172 // * * <<
173 // * * <<
174 // * * <<
175 // ************************** <<
176 // <<
177 // The detector can be dived in slices or voxe <<
178 // and inside it different quantities (dose di <<
179 // can be stored. <<
180 void HadrontherapyDetectorConstruction::Constr 184 void HadrontherapyDetectorConstruction::ConstructDetector()
181 <<
182 { 185 {
183 // Definition of the solid volume of the D << 186 G4Colour lightBlue (0.0, 0.0, .75);
184 detector = new G4Box("Detector", << 187 G4Material* water = material -> GetMat("G4_WATER");
185 << 188
186 phantomSizeX/2, << 189 //-----------
187 << 190 // Detector
188 phantomSizeY/2, << 191 //-----------
189 << 192
190 phantomSizeZ/2); << 193 G4Box* detector = new G4Box("Detector",detectorSizeX,detectorSizeY,detectorSizeZ);
191 << 194
192 // Definition of the logic volume of the P << 195 detectorLogicalVolume = new G4LogicalVolume(detector,
193 detectorLogicalVolume = new G4LogicalVolum << 196 water,
194 << 197 "DetectorLog",
195 << 198 0,0,0);
196 << 199
197 // Definition of the physical volume of th << 200 // Fixing the max step allowed in the detector
198 detectorPhysicalVolume = new G4PVPlacement << 201 G4double maxStep = 0.01 *mm;
199 << 202 detectorLogicalVolume -> SetUserLimits(new G4UserLimits(maxStep));
200 << 203
201 << 204 G4double detectorXtranslation = -180.*mm;
202 << 205 detectorPhysicalVolume = new G4PVPlacement(0,
203 << 206 G4ThreeVector(detectorXtranslation, 0.0 *mm, 0.0 *mm),
204 << 207 "DetectorPhys",
205 // Visualisation attributes of the detecto << 208 detectorLogicalVolume,
206 skyBlue = new G4VisAttributes( G4Colour(13 << 209 patientPhysicalVolume,
207 skyBlue -> SetVisibility(true); << 210 false,0);
208 skyBlue -> SetForceSolid(true); << 211
209 //skyBlue -> SetForceWireframe(true); << 212 // Visualisation attributes of the phantom
210 detectorLogicalVolume -> SetVisAttributes( << 213 G4VisAttributes* simpleBoxVisAttributes = new G4VisAttributes(lightBlue);
211 << 214 simpleBoxVisAttributes -> SetVisibility(true);
212 // ************** << 215 simpleBoxVisAttributes -> SetForceSolid(true);
213 // ************** << 216 detectorLogicalVolume -> SetVisAttributes(simpleBoxVisAttributes);
214 // Cut per Region << 217
215 // ************** << 218 // **************
216 // << 219 // Cut per Region
217 // A smaller cut is fixed in the phantom t << 220 // **************
218 // required accuracy << 221
219 if (!aRegion) << 222 // A smaller cut is fixed in the phantom to calculate the energy deposit with the
220 { << 223 // required accuracy
221 aRegion = new G4Region("DetectorLog"); << 224 G4Region* aRegion = new G4Region("DetectorLog");
222 detectorLogicalVolume -> SetRegion(aRe << 225 detectorLogicalVolume -> SetRegion(aRegion);
223 aRegion->AddRootLogicalVolume( detecto << 226 aRegion -> AddRootLogicalVolume(detectorLogicalVolume);
224 } << 227 }
225 } << 228
>> 229 void HadrontherapyDetectorConstruction::ConstructSensitiveDetector()
>> 230 {
>> 231 // Sensitive Detector and ReadOut geometry definition
>> 232 G4SDManager* sensitiveDetectorManager = G4SDManager::GetSDMpointer();
226 233
227 ////////////////////////////////////////////// << 234 G4String sensitiveDetectorName = "Detector";
228 void HadrontherapyDetectorConstruction::Initia << 235
229 << 236 if(!detectorSD)
230 <<
231 <<
232 { <<
233 RO->Initialize(detectorToWorldPosition, <<
234 detectorSizeX/2, <<
235 detectorSizeY/2, <<
236 detectorSizeZ/2, <<
237 numberOfVoxelsAlongX, <<
238 numberOfVoxelsAlongY, <<
239 numberOfVoxelsAlongZ); <<
240 } <<
241 void HadrontherapyDetectorConstruction::Virtua <<
242 { <<
243 <<
244 //Virtual plane <<
245 VirtualLayerPosition = G4ThreeVector(0*cm, <<
246 NewSource= Varbool; <<
247 if(NewSource == true) <<
248 { 237 {
249 // std::cout<<"trr"<<std::endl; << 238 // The sensitive detector is instantiated
250 G4Material* airNist = G4NistManager:: << 239 detectorSD = new HadrontherapyDetectorSD(sensitiveDetectorName);
251 << 240
252 solidVirtualLayer = new G4Box("Virtual << 241 // The Read Out Geometry is instantiated
253 1.*um, << 242 G4String ROGeometryName = "DetectorROGeometry";
254 20.*cm, << 243 detectorROGeometry = new HadrontherapyDetectorROGeometry(ROGeometryName,
255 40.*cm); << 244 detectorSizeX,
256 << 245 detectorSizeY,
257 logicVirtualLayer = new G4LogicalVolum << 246 detectorSizeZ,
258 << 247 numberOfVoxelsAlongX,
259 << 248 numberOfVoxelsAlongY,
260 << 249 numberOfVoxelsAlongZ);
261 << 250 detectorROGeometry -> BuildROGeometry();
262 physVirtualLayer= new G4PVPlacement(0, << 251 detectorSD -> SetROgeometry(detectorROGeometry);
263 "V << 252 sensitiveDetectorManager -> AddNewDetector(detectorSD);
264 lo << 253 detectorLogicalVolume -> SetSensitiveDetector(detectorSD);
265 mo <<
266 fa <<
267 0) <<
268 <<
269 logicVirtualLayer -> SetVisAttributes( <<
270 } 254 }
271 <<
272 <<
273 <<
274 <<
275 } 255 }
276 256
277 << 257 void HadrontherapyDetectorConstruction::SetModulatorAngle(G4double value)
278 ////////////////////////////////////////////// << 258 {
279 void HadrontherapyDetectorConstruction::Param << 259 modulator -> SetModulatorAngle(value);
280 { << 260 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
281 // Check phantom/detector sizes & relative <<
282 if (!IsInside(detectorSizeX, <<
283 detectorSizeY, <<
284 detectorSizeZ, <<
285 phantomSizeX, <<
286 phantomSizeY, <<
287 phantomSizeZ, <<
288 detectorToPhantomPosition <<
289 )) <<
290 G4Exception("HadrontherapyDetectorCons <<
291 <<
292 // Check Detector sizes respect to the vox <<
293 <<
294 if ( detectorSizeX < sizeOfVoxelAlongX) { <<
295 G4Exception("HadrontherapyDetectorCons <<
296 } <<
297 if ( detectorSizeY < sizeOfVoxelAlongY) { <<
298 G4Exception(" HadrontherapyDetectorCon <<
299 } <<
300 if ( detectorSizeZ < sizeOfVoxelAlongZ) { <<
301 G4Exception(" HadrontherapyDetectorCon <<
302 } <<
303 } 261 }
304 262
305 ////////////////////////////////////////////// << 263 void HadrontherapyDetectorConstruction::SetRangeShifterXPosition(G4double value)
306 G4bool HadrontherapyDetectorConstruction::SetP <<
307 { <<
308 <<
309 if (G4Material* pMat = G4NistManager::Inst <<
310 { <<
311 phantomMaterial = pMat; <<
312 detectorMaterial = pMat; <<
313 if (detectorLogicalVolume && phantomLo <<
314 { <<
315 detectorLogicalVolume -> SetMateri <<
316 phantomLogicalVolume -> SetMateri <<
317 <<
318 G4RunManager::GetRunManager() -> P <<
319 G4RunManager::GetRunManager() -> G <<
320 G4cout << "The material of Phantom <<
321 } <<
322 } <<
323 else <<
324 { <<
325 G4cout << "WARNING: material \"" << ma <<
326 " table [located in $G4INSTALL/source/ <<
327 G4cout << "Use command \"/parameter/ni <<
328 return false; <<
329 } <<
330 <<
331 return true; <<
332 } <<
333 ////////////////////////////////////////////// <<
334 void HadrontherapyDetectorConstruction::SetPha <<
335 { 264 {
336 if (sizeX > 0.) phantomSizeX = sizeX; << 265 beamLine -> SetRangeShifterXPosition(value);
337 if (sizeY > 0.) phantomSizeY = sizeY; << 266 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
338 if (sizeZ > 0.) phantomSizeZ = sizeZ; <<
339 } 267 }
340 268
341 ////////////////////////////////////////////// << 269 void HadrontherapyDetectorConstruction::SetRangeShifterXSize(G4double value)
342 void HadrontherapyDetectorConstruction::SetDet <<
343 { 270 {
344 if (sizeX > 0.) {detectorSizeX = sizeX;} << 271 beamLine -> SetRangeShifterXSize(value);
345 if (sizeY > 0.) {detectorSizeY = sizeY;} << 272 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
346 if (sizeZ > 0.) {detectorSizeZ = sizeZ;} <<
347 SetVoxelSize(sizeOfVoxelAlongX, sizeOfVoxe <<
348 } 273 }
349 274
350 ////////////////////////////////////////////// << 275 void HadrontherapyDetectorConstruction::SetFirstScatteringFoilSize(G4double value)
351 void HadrontherapyDetectorConstruction::SetVox <<
352 { 276 {
353 if (sizeX > 0.) {sizeOfVoxelAlongX = sizeX << 277 beamLine -> SetFirstScatteringFoilXSize(value);
354 if (sizeY > 0.) {sizeOfVoxelAlongY = sizeY << 278 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
355 if (sizeZ > 0.) {sizeOfVoxelAlongZ = sizeZ <<
356 } 279 }
357 280
358 ////////////////////////////////////////////// << 281 void HadrontherapyDetectorConstruction::SetSecondScatteringFoilSize(G4double value)
359 void HadrontherapyDetectorConstruction::SetPha <<
360 { 282 {
361 phantomPosition = pos; << 283 beamLine -> SetSecondScatteringFoilXSize(value);
>> 284 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
362 } 285 }
363 286
364 ////////////////////////////////////////////// << 287 void HadrontherapyDetectorConstruction::SetOuterRadiusStopper(G4double value)
365 void HadrontherapyDetectorConstruction::SetDet <<
366 { 288 {
367 detectorToPhantomPosition = displ; << 289 beamLine -> SetOuterRadiusStopper(value);
>> 290 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
368 } 291 }
369 292
370 void HadrontherapyDetectorConstruction::SetVir << 293 void HadrontherapyDetectorConstruction::SetInnerRadiusFinalCollimator(G4double value)
371 { 294 {
372 << 295 beamLine -> SetInnerRadiusFinalCollimator(value);
373 VirtualLayerPosition = position; << 296 G4RunManager::GetRunManager() -> GeometryHasBeenModified();
374 physVirtualLayer->SetTranslation(VirtualLa <<
375 <<
376 } <<
377 ////////////////////////////////////////////// <<
378 void HadrontherapyDetectorConstruction::Update <<
379 { <<
380 /* <<
381 * Check parameters consistency <<
382 */ <<
383 ParametersCheck(); <<
384 <<
385 G4GeometryManager::GetInstance() -> OpenGe <<
386 if (phantom) <<
387 { <<
388 phantom -> SetXHalfLength(phantomSizeX <<
389 phantom -> SetYHalfLength(phantomSizeY <<
390 phantom -> SetZHalfLength(phantomSizeZ <<
391 <<
392 phantomPhysicalVolume -> SetTranslatio <<
393 } <<
394 else ConstructPhantom(); <<
395 <<
396 <<
397 // Get the center of the detector <<
398 SetDetectorPosition(); <<
399 if (detector) <<
400 { <<
401 <<
402 detector -> SetXHalfLength(detectorSiz <<
403 detector -> SetYHalfLength(detectorSiz <<
404 detector -> SetZHalfLength(detectorSiz <<
405 <<
406 detectorPhysicalVolume -> SetTranslati <<
407 } <<
408 else ConstructDetector(); <<
409 <<
410 //std::cout<<NewSource<<std::endl; <<
411 /*if(NewSource) <<
412 { <<
413 std::cout<<"via"<<std::endl; <<
414 }*/ <<
415 <<
416 <<
417 // std::cout<<"i"<<std::endl; <<
418 // std::cout<<VirtualLayerPosition<<std::e <<
419 // physVirtualLayer->SetTranslation(Virtua <<
420 <<
421 <<
422 <<
423 <<
424 <<
425 // Round to nearest integer number of voxe <<
426 <<
427 numberOfVoxelsAlongX = G4lrint(detectorSiz <<
428 sizeOfVoxelAlongX = ( detectorSizeX / numb <<
429 numberOfVoxelsAlongY = G4lrint(detectorSiz <<
430 sizeOfVoxelAlongY = ( detectorSizeY / numb <<
431 numberOfVoxelsAlongZ = G4lrint(detectorSiz <<
432 sizeOfVoxelAlongZ = ( detectorSizeZ / numb <<
433 PassiveProtonBeamLine *ppbl= (PassiveProto <<
434 <<
435 G4RunManager::GetRunManager()->GetUserDete <<
436 <<
437 HadrontherapyDetectorROGeometry* RO = (Had <<
438 <<
439 //Set parameters, either for the Construct <<
440 RO->Initialize(GetDetectorToWorldPosition( <<
441 detectorSizeX/2, <<
442 detectorSizeY/2, <<
443 detectorSizeZ/2, <<
444 numberOfVoxelsAlongX, <<
445 numberOfVoxelsAlongY, <<
446 numberOfVoxelsAlongZ); <<
447 <<
448 //This method below has an effect only if <<
449 RO->UpdateROGeometry(); <<
450 <<
451 <<
452 <<
453 volumeOfVoxel = sizeOfVoxelAlongX * sizeOf <<
454 massOfVoxel = detectorMaterial -> GetDensi <<
455 // This will clear the existing matrix (t <<
456 matrix = HadrontherapyMatrix::GetInstance( <<
457 <<
458 <<
459 <<
460 <<
461 <<
462 // Initialize RBE <<
463 HadrontherapyRBE::CreateInstance(numberOfV <<
464 <<
465 // Comment out the line below if let calcu <<
466 // Initialize LET with energy of primaries <<
467 if ( (let = HadrontherapyLet::GetInstance( <<
468 { <<
469 HadrontherapyLet::GetInstance() -> Ini <<
470 } <<
471 <<
472 <<
473 // Initialize analysis <<
474 // Inform the kernel about the new geometr <<
475 G4RunManager::GetRunManager() -> GeometryH <<
476 G4RunManager::GetRunManager() -> PhysicsHa <<
477 <<
478 PrintParameters(); <<
479 <<
480 // CheckOverlaps(); <<
481 } 297 }
482 298
483 ////////////////////////////////////////////// << 299 void HadrontherapyDetectorConstruction::SetRSMaterial(G4String materialChoice)
484 //Check of the geometry <<
485 ////////////////////////////////////////////// <<
486 void HadrontherapyDetectorConstruction::CheckO <<
487 { 300 {
488 G4PhysicalVolumeStore* thePVStore = G4Phys << 301 beamLine -> SetRSMaterial(materialChoice);
489 G4cout << thePVStore->size() << " physical <<
490 G4bool overlapFlag = false; <<
491 G4int res=1000; <<
492 G4double tol=0.; //tolerance <<
493 for (size_t i=0;i<thePVStore->size();i++) <<
494 { <<
495 //overlapFlag = (*thePVStore)[i]->Chec <<
496 overlapFlag = (*thePVStore)[i]->CheckO <<
497 if (overlapFlag) <<
498 G4cout << "Check: there are overlappin <<
499 } 302 }
500 303
501 ////////////////////////////////////////////// <<
502 void HadrontherapyDetectorConstruction::PrintP <<
503 { <<
504 <<
505 G4cout << "The (X,Y,Z) dimensions of the p <<
506 G4BestUnit( phantom -> GetXHalfLength()*2. <<
507 G4BestUnit( phantom -> GetYHalfLength()*2. <<
508 G4BestUnit( phantom -> GetZHalfLength()*2. <<
509 <<
510 G4cout << "The (X,Y,Z) dimensions of the d <<
511 G4BestUnit( detector -> GetXHalfLength()*2 <<
512 G4BestUnit( detector -> GetYHalfLength()*2 <<
513 G4BestUnit( detector -> GetZHalfLength()*2 <<
514 <<
515 G4cout << "Displacement between Phantom an <<
516 G4cout << "DX= "<< G4BestUnit(phantomPosit <<
517 "DY= "<< G4BestUnit(phantomPosition.getY() <<
518 "DZ= "<< G4BestUnit(phantomPosition.getZ() <<
519 <<
520 G4cout << "The (X,Y,Z) sizes of the Voxels <<
521 G4BestUnit(sizeOfVoxelAlongX, "Length") < <<
522 G4BestUnit(sizeOfVoxelAlongY, "Length") < <<
523 G4BestUnit(sizeOfVoxelAlongZ, "Length") << <<
524 <<
525 G4cout << "The number of Voxels along (X,Y <<
526 numberOfVoxelsAlongX << ',' << <<
527 numberOfVoxelsAlongY <<',' << <<
528 numberOfVoxelsAlongZ << ')' << G4endl; <<
529 } <<
530 304
531 305
532 306