| 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 #ifndef HadrontherapyDetectorConstruction_H 29 #ifndef HadrontherapyDetectorConstruction_H
30 #define HadrontherapyDetectorConstruction_H 1 30 #define HadrontherapyDetectorConstruction_H 1
31 31
32 #include "G4Box.hh" 32 #include "G4Box.hh"
33 #include "globals.hh" 33 #include "globals.hh"
34 #include "G4VisAttributes.hh" 34 #include "G4VisAttributes.hh"
35 #include "G4LogicalVolume.hh" 35 #include "G4LogicalVolume.hh"
36 #include "G4UnitsTable.hh" 36 #include "G4UnitsTable.hh"
37 #include "HadrontherapyDetectorROGeometry.hh" 37 #include "HadrontherapyDetectorROGeometry.hh"
38 38
39 class G4VPhysicalVolume; 39 class G4VPhysicalVolume;
40 class G4LogicalVolume; 40 class G4LogicalVolume;
41 class G4PVPlacement; 41 class G4PVPlacement;
42 class HadrontherapyDetectorROGeometry; 42 class HadrontherapyDetectorROGeometry;
43 class HadrontherapyDetectorMessenger; 43 class HadrontherapyDetectorMessenger;
44 class HadrontherapyDetectorSD; 44 class HadrontherapyDetectorSD;
45 class HadrontherapyMatrix; 45 class HadrontherapyMatrix;
46 class HadrontherapyLet; 46 class HadrontherapyLet;
47 47
48 class HadrontherapyDetectorConstruction 48 class HadrontherapyDetectorConstruction
49 { 49 {
50 public: 50 public:
51 51
52 HadrontherapyDetectorConstruction(G4VPhysi 52 HadrontherapyDetectorConstruction(G4VPhysicalVolume*);
53 53
54 ~HadrontherapyDetectorConstruction(); 54 ~HadrontherapyDetectorConstruction();
55 55
56 public: 56 public:
57 static HadrontherapyDetectorConstruction* 57 static HadrontherapyDetectorConstruction* GetInstance();
58 void InitializeDetectorROGeometry(Hadronth 58 void InitializeDetectorROGeometry(HadrontherapyDetectorROGeometry*,
59 G4ThreeV 59 G4ThreeVector detectorToWorldPosition);
60 G4VPhysicalVolume* motherPhys; 60 G4VPhysicalVolume* motherPhys;
61 HadrontherapyDetectorSD* detectorS 61 HadrontherapyDetectorSD* detectorSD; // Pointer to sensitive detector
62 62
63 ////////////////////////// 63 //////////////////////////
64 void VirtualLayer(G4bool Varbool); 64 void VirtualLayer(G4bool Varbool);
65 G4bool NewSource; 65 G4bool NewSource;
66 void SetVirtualLayerPosition(G4ThreeVector 66 void SetVirtualLayerPosition(G4ThreeVector);
67 G4ThreeVector VirtualLayerPosition; 67 G4ThreeVector VirtualLayerPosition;
68 68
69 ////////////////////////// 69 //////////////////////////
70 private: 70 private:
71 71
72 void ConstructPhantom(); 72 void ConstructPhantom();
73 void ConstructDetector(); 73 void ConstructDetector();
74 void ParametersCheck(); 74 void ParametersCheck();
75 void CheckOverlaps(); 75 void CheckOverlaps();
76 76
77 public: 77 public:
78 // Get detector position relative to WORLD 78 // Get detector position relative to WORLD
79 inline G4ThreeVector GetDetectorToWorldPos 79 inline G4ThreeVector GetDetectorToWorldPosition()
80 { 80 {
81 return phantomPosition + detectorPosit 81 return phantomPosition + detectorPosition;
82 } 82 }
83 ////////////////////////////////////////// 83 /////////////////////////////////////////////////////////////////////////////
84 // Get displacement between phantom and de 84 // Get displacement between phantom and detector by detector position (center of), phantom (center of) and detector sizes
85 inline G4ThreeVector GetDetectorToPhantomP 85 inline G4ThreeVector GetDetectorToPhantomPosition()
86 { 86 {
87 return G4ThreeVector(phantomSizeX/2 - 87 return G4ThreeVector(phantomSizeX/2 - detectorSizeX/2 + detectorPosition.getX(),
88 phantomSizeY/2 - 88 phantomSizeY/2 - detectorSizeY/2 + detectorPosition.getY(),
89 phantomSizeZ/2 - 89 phantomSizeZ/2 - detectorSizeZ/2 + detectorPosition.getZ()
90 ); 90 );
91 } 91 }
92 92
93 ////////////////////////////////////////// 93 /////////////////////////////////////////////////////////////////////////////
94 // Calculate (and set) detector position b 94 // Calculate (and set) detector position by displacement, phantom and detector sizes
95 inline void SetDetectorPosition() 95 inline void SetDetectorPosition()
96 { 96 {
97 // Adjust detector position 97 // Adjust detector position
98 detectorPosition.setX(detectorToPhanto 98 detectorPosition.setX(detectorToPhantomPosition.getX() - phantomSizeX/2 + detectorSizeX/2);
99 detectorPosition.setY(detectorToPhanto 99 detectorPosition.setY(detectorToPhantomPosition.getY() - phantomSizeY/2 + detectorSizeY/2);
100 detectorPosition.setZ(detectorToPhanto 100 detectorPosition.setZ(detectorToPhantomPosition.getZ() - phantomSizeZ/2 + detectorSizeZ/2);
101 101
102 102
103 } 103 }
104 ////////////////////////////////////////// 104 /////////////////////////////////////////////////////////////////////////////
105 // Check whether detector is inside phanto 105 // Check whether detector is inside phantom
106 inline bool IsInside(G4double detectorX, 106 inline bool IsInside(G4double detectorX,
107 G4double detectorY, 107 G4double detectorY,
108 G4double detectorZ, 108 G4double detectorZ,
109 G4double phantomX, 109 G4double phantomX,
110 G4double phantomY, 110 G4double phantomY,
111 G4double phantomZ, 111 G4double phantomZ,
112 G4ThreeVector pos) 112 G4ThreeVector pos)
113 { 113 {
114 // Dimensions check... X Y and Z 114 // Dimensions check... X Y and Z
115 // Firstly check what dimension we are 115 // Firstly check what dimension we are modifying
116 { 116 {
117 if (detectorX > phantomX) 117 if (detectorX > phantomX)
118 { 118 {
119 G4cout << "Error: Detector X d 119 G4cout << "Error: Detector X dimension must be smaller or equal to the correspondent of the phantom" << G4endl;
120 return false; 120 return false;
121 } 121 }
122 if ( (phantomX - detectorX) < pos. 122 if ( (phantomX - detectorX) < pos.getX())
123 { 123 {
124 G4cout << "Error: X dimension 124 G4cout << "Error: X dimension doesn't fit with detector to phantom relative position" << G4endl;
125 return false; 125 return false;
126 } 126 }
127 } 127 }
128 128
129 { 129 {
130 if (detectorY > phantomY) 130 if (detectorY > phantomY)
131 { 131 {
132 G4cout << "Error: Detector Y d 132 G4cout << "Error: Detector Y dimension must be smaller or equal to the correspondent of the phantom" << G4endl;
133 return false; 133 return false;
134 } 134 }
135 if ( (phantomY - detectorY) < pos. 135 if ( (phantomY - detectorY) < pos.getY())
136 { 136 {
137 G4cout << "Error: Y dimension 137 G4cout << "Error: Y dimension doesn't fit with detector to phantom relative position" << G4endl;
138 return false; 138 return false;
139 } 139 }
140 } 140 }
141 141
142 { 142 {
143 if (detectorZ > phantomZ) 143 if (detectorZ > phantomZ)
144 { 144 {
145 G4cout << "Error: Detector Z d 145 G4cout << "Error: Detector Z dimension must be smaller or equal to the correspondent of the phantom" << G4endl;
146 return false; 146 return false;
147 } 147 }
148 if ( (phantomZ - detectorZ) < pos. 148 if ( (phantomZ - detectorZ) < pos.getZ())
149 { 149 {
150 G4cout << "Error: Z dimension 150 G4cout << "Error: Z dimension doesn't fit with detector to phantom relative position" << G4endl;
151 return false; 151 return false;
152 } 152 }
153 } 153 }
154 154
155 return true; 155 return true;
156 } 156 }
157 ////////////////////////////////////////// 157 /////////////////////////////////////////////////////////////////////////////
158 158
159 G4bool SetPhantomMaterial(G4String materi 159 G4bool SetPhantomMaterial(G4String material);
160 void SetVoxelSize(G4double sizeX, G4double 160 void SetVoxelSize(G4double sizeX, G4double sizeY, G4double sizeZ);
161 void SetDetectorSize(G4double sizeX, G4dou 161 void SetDetectorSize(G4double sizeX, G4double sizeY, G4double sizeZ);
162 void SetPhantomSize(G4double sizeX, G4doub 162 void SetPhantomSize(G4double sizeX, G4double sizeY, G4double sizeZ);
163 void SetPhantomPosition(G4ThreeVector); 163 void SetPhantomPosition(G4ThreeVector);
164 void SetDetectorToPhantomPosition(G4ThreeV 164 void SetDetectorToPhantomPosition(G4ThreeVector DetectorToPhantomPosition);
165 void UpdateGeometry(); 165 void UpdateGeometry();
166 void PrintParameters(); 166 void PrintParameters();
167 G4LogicalVolume* GetDetectorLogicalVolume( 167 G4LogicalVolume* GetDetectorLogicalVolume(){ return detectorLogicalVolume;}
168 168
169 private: 169 private:
170 static HadrontherapyDetectorConstruction* 170 static HadrontherapyDetectorConstruction* instance;
171 HadrontherapyDetectorMessenger* detectorMe 171 HadrontherapyDetectorMessenger* detectorMessenger;
172 172
173 G4VisAttributes* skyBlue; 173 G4VisAttributes* skyBlue;
174 G4VisAttributes* red; 174 G4VisAttributes* red;
175 175
176 HadrontherapyDetectorROGeometry* detectorR 176 HadrontherapyDetectorROGeometry* detectorROGeometry; // Pointer to ROGeometry
177 HadrontherapyMatrix* matrix; 177 HadrontherapyMatrix* matrix;
178 HadrontherapyLet* let; 178 HadrontherapyLet* let;
179 179
180 G4Box *phantom , *detector; 180 G4Box *phantom , *detector;
181 G4LogicalVolume *phantomLogicalVolume, *de 181 G4LogicalVolume *phantomLogicalVolume, *detectorLogicalVolume;
182 G4VPhysicalVolume *phantomPhysicalVolume, 182 G4VPhysicalVolume *phantomPhysicalVolume, *detectorPhysicalVolume;
183 183
184 G4Box* solidVirtualLayer; 184 G4Box* solidVirtualLayer;
185 G4LogicalVolume* logicVirtualLayer; 185 G4LogicalVolume* logicVirtualLayer;
186 G4VPhysicalVolume* physVirtualLayer; 186 G4VPhysicalVolume* physVirtualLayer;
187 187
188 G4double phantomSizeX; 188 G4double phantomSizeX;
189 G4double phantomSizeY; 189 G4double phantomSizeY;
190 G4double phantomSizeZ; 190 G4double phantomSizeZ;
191 191
192 G4double detectorSizeX; 192 G4double detectorSizeX;
193 G4double detectorSizeY; 193 G4double detectorSizeY;
194 G4double detectorSizeZ; 194 G4double detectorSizeZ;
195 195
196 G4ThreeVector phantomPosition, detectorPos 196 G4ThreeVector phantomPosition, detectorPosition, detectorToPhantomPosition; // phantom center, detector center, detector to phantom relative position
197 197
198 G4double sizeOfVoxelAlongX; 198 G4double sizeOfVoxelAlongX;
199 G4double sizeOfVoxelAlongY; 199 G4double sizeOfVoxelAlongY;
200 G4double sizeOfVoxelAlongZ; 200 G4double sizeOfVoxelAlongZ;
201 201
202 G4int numberOfVoxelsAlongX; 202 G4int numberOfVoxelsAlongX;
203 G4int numberOfVoxelsAlongY; 203 G4int numberOfVoxelsAlongY;
204 G4int numberOfVoxelsAlongZ; 204 G4int numberOfVoxelsAlongZ;
205 205
206 G4double volumeOfVoxel, massOfVoxel; 206 G4double volumeOfVoxel, massOfVoxel;
207 207
208 G4Material *phantomMaterial, *detectorMate 208 G4Material *phantomMaterial, *detectorMaterial;
209 G4Region* aRegion; 209 G4Region* aRegion;
210 }; 210 };
211 #endif 211 #endif
212 212