| 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 // G4VScoringMesh <<
27 // 26 //
28 // Class description: <<
29 // 27 //
30 // This class represents a multi-functional de << 28
31 // command-based scorer for parallel world sco <<
32 // parallel world mesh geometry <<
33 // <<
34 // Author: Makoto Asai <<
35 // ------------------------------------------- <<
36 #ifndef G4VScoringMesh_h 29 #ifndef G4VScoringMesh_h
37 #define G4VScoringMesh_h 1 30 #define G4VScoringMesh_h 1
38 31
39 #include "globals.hh" 32 #include "globals.hh"
40 #include "G4THitsMap.hh" 33 #include "G4THitsMap.hh"
41 #include "G4RotationMatrix.hh" 34 #include "G4RotationMatrix.hh"
42 #include "G4StatDouble.hh" 35 #include "G4StatDouble.hh"
43 36
44 #include <map> <<
45 <<
46 class G4VPhysicalVolume; 37 class G4VPhysicalVolume;
47 class G4LogicalVolume; 38 class G4LogicalVolume;
48 class G4MultiFunctionalDetector; 39 class G4MultiFunctionalDetector;
49 class G4VPrimitiveScorer; 40 class G4VPrimitiveScorer;
50 class G4VSDFilter; 41 class G4VSDFilter;
51 class G4VScoreColorMap; 42 class G4VScoreColorMap;
52 class G4ParallelWorldProcess; 43 class G4ParallelWorldProcess;
53 44
>> 45 #include <map>
>> 46
>> 47 // class description:
>> 48 //
>> 49 // This class represents a multi-functional detector to be used by
>> 50 // command-based scorer For parallel world scorer, this class creates a
>> 51 // parallel world mesh geometry
>> 52 //
>> 53
54 class G4VScoringMesh 54 class G4VScoringMesh
55 { 55 {
56 public: 56 public:
57 enum class MeshShape 57 enum class MeshShape
58 { 58 {
59 box, 59 box,
60 cylinder, 60 cylinder,
61 sphere, 61 sphere,
62 realWorldLogVol, 62 realWorldLogVol,
63 probe, 63 probe,
64 undefined = -1 64 undefined = -1
65 }; 65 };
66 using EventScore = G4THitsMap<G4double>; 66 using EventScore = G4THitsMap<G4double>;
67 using RunScore = G4THitsMap<G4StatDouble 67 using RunScore = G4THitsMap<G4StatDouble>;
68 using MeshScoreMap = std::map<G4String, RunS 68 using MeshScoreMap = std::map<G4String, RunScore*>;
69 69
70 public: 70 public:
71 <<
72 G4VScoringMesh(const G4String& wName); 71 G4VScoringMesh(const G4String& wName);
73 virtual ~G4VScoringMesh() = default; 72 virtual ~G4VScoringMesh() = default;
74 73
>> 74 public: // with description
75 virtual void Construct(G4VPhysicalVolume* fW 75 virtual void Construct(G4VPhysicalVolume* fWorldPhys);
76 virtual void WorkerConstruct(G4VPhysicalVolu 76 virtual void WorkerConstruct(G4VPhysicalVolume* fWorldPhys);
77 77
78 // list infomration of this mesh 78 // list infomration of this mesh
79 virtual void List() const; 79 virtual void List() const;
80 80
81 // get the world name 81 // get the world name
82 // If this ScoringMesh is for parallel world 82 // If this ScoringMesh is for parallel world, it returns the name of the
83 // parallel world If this ScoringMesh is for 83 // parallel world If this ScoringMesh is for real world logical volume, it
84 // returns name of logical volume 84 // returns name of logical volume
85 inline const G4String& GetWorldName() const 85 inline const G4String& GetWorldName() const { return fWorldName; }
86 // get whether this mesh is active or not 86 // get whether this mesh is active or not
87 inline G4bool IsActive() const { return fAct 87 inline G4bool IsActive() const { return fActive; }
88 // set an activity of this mesh 88 // set an activity of this mesh
89 inline void Activate(G4bool vl = true) { fAc 89 inline void Activate(G4bool vl = true) { fActive = vl; }
90 // get the shape of this mesh 90 // get the shape of this mesh
91 inline MeshShape GetShape() const { return f 91 inline MeshShape GetShape() const { return fShape; }
92 // accumulate hits in a registered primitive 92 // accumulate hits in a registered primitive scorer
93 void Accumulate(G4THitsMap<G4double>* map); 93 void Accumulate(G4THitsMap<G4double>* map);
94 void Accumulate(G4THitsMap<G4StatDouble>* ma 94 void Accumulate(G4THitsMap<G4StatDouble>* map);
95 // merge same kind of meshes 95 // merge same kind of meshes
96 void Merge(const G4VScoringMesh* scMesh); 96 void Merge(const G4VScoringMesh* scMesh);
97 // dump information of primitive socrers reg 97 // dump information of primitive socrers registered in this mesh
98 void Dump(); 98 void Dump();
99 // draw a projected quantity on a current vi 99 // draw a projected quantity on a current viewer
100 void DrawMesh(const G4String& psName, G4VSco 100 void DrawMesh(const G4String& psName, G4VScoreColorMap* colorMap,
101 G4int axflg = 111); 101 G4int axflg = 111);
102 // draw a column of a quantity on a current 102 // draw a column of a quantity on a current viewer
103 void DrawMesh(const G4String& psName, G4int 103 void DrawMesh(const G4String& psName, G4int idxPlane, G4int iColumn,
104 G4VScoreColorMap* colorMap); 104 G4VScoreColorMap* colorMap);
105 // draw a projected quantity on a current vi 105 // draw a projected quantity on a current viewer
106 virtual void Draw(RunScore* map, G4VScoreCol 106 virtual void Draw(RunScore* map, G4VScoreColorMap* colorMap,
107 G4int axflg = 111) = 0; 107 G4int axflg = 111) = 0;
108 // draw a column of a quantity on a current 108 // draw a column of a quantity on a current viewer
109 virtual void DrawColumn(RunScore* map, G4VSc 109 virtual void DrawColumn(RunScore* map, G4VScoreColorMap* colorMap,
110 G4int idxProj, G4int 110 G4int idxProj, G4int idxColumn) = 0;
111 // reset registered primitive scorers 111 // reset registered primitive scorers
112 void ResetScore(); 112 void ResetScore();
113 113
114 // Following set/get methods make sense only 114 // Following set/get methods make sense only for parallel world scoring mesh
115 // set size of this mesh 115 // set size of this mesh
116 void SetSize(G4double size[3]); 116 void SetSize(G4double size[3]);
117 // get size of this mesh 117 // get size of this mesh
118 G4ThreeVector GetSize() const; 118 G4ThreeVector GetSize() const;
119 // set starting and span angles (used only f 119 // set starting and span angles (used only for tube segment)
120 void SetAngles(G4double, G4double); 120 void SetAngles(G4double, G4double);
121 // get angles (used only for tube segment) 121 // get angles (used only for tube segment)
122 inline G4double GetStartAngle() const { retu 122 inline G4double GetStartAngle() const { return fAngle[0]; }
123 inline G4double GetAngleSpan() const { retur 123 inline G4double GetAngleSpan() const { return fAngle[1]; }
124 // set position of center of this mesh 124 // set position of center of this mesh
125 void SetCenterPosition(G4double centerPositi 125 void SetCenterPosition(G4double centerPosition[3]);
126 // get position of center of this mesh 126 // get position of center of this mesh
127 G4ThreeVector GetTranslation() const { retur 127 G4ThreeVector GetTranslation() const { return fCenterPosition; }
128 // set a rotation angle around the x axis 128 // set a rotation angle around the x axis
129 void RotateX(G4double delta); 129 void RotateX(G4double delta);
130 // set a rotation angle around the y axis 130 // set a rotation angle around the y axis
131 void RotateY(G4double delta); 131 void RotateY(G4double delta);
132 // set a rotation angle around the z axis 132 // set a rotation angle around the z axis
133 void RotateZ(G4double delta); 133 void RotateZ(G4double delta);
134 // get a rotation matrix 134 // get a rotation matrix
135 inline G4RotationMatrix GetRotationMatrix() << 135 G4RotationMatrix GetRotationMatrix() const
136 { 136 {
137 if(fRotationMatrix != nullptr) 137 if(fRotationMatrix != nullptr)
138 return *fRotationMatrix; 138 return *fRotationMatrix;
139 return G4RotationMatrix::IDENTITY; 139 return G4RotationMatrix::IDENTITY;
140 } 140 }
141 141
142 // set number of segments of this mesh 142 // set number of segments of this mesh
143 void SetNumberOfSegments(G4int nSegment[3]); 143 void SetNumberOfSegments(G4int nSegment[3]);
144 // get number of segments of this mesh 144 // get number of segments of this mesh
145 void GetNumberOfSegments(G4int nSegment[3]); 145 void GetNumberOfSegments(G4int nSegment[3]);
146 146
147 // register a primitive scorer to the MFD & 147 // register a primitive scorer to the MFD & set it to the current primitive
148 // scorer 148 // scorer
149 void SetPrimitiveScorer(G4VPrimitiveScorer* 149 void SetPrimitiveScorer(G4VPrimitiveScorer* ps);
150 // register a filter to a current primtive s 150 // register a filter to a current primtive scorer
151 void SetFilter(G4VSDFilter* filter); 151 void SetFilter(G4VSDFilter* filter);
152 // set a primitive scorer to the current one 152 // set a primitive scorer to the current one by the name
153 void SetCurrentPrimitiveScorer(const G4Strin 153 void SetCurrentPrimitiveScorer(const G4String& name);
154 // find registered primitive scorer by the n 154 // find registered primitive scorer by the name
155 G4bool FindPrimitiveScorer(const G4String& p 155 G4bool FindPrimitiveScorer(const G4String& psname);
156 // get whether current primitive scorer is s 156 // get whether current primitive scorer is set or not
157 inline G4bool IsCurrentPrimitiveScorerNull() << 157 G4bool IsCurrentPrimitiveScorerNull()
158 { 158 {
159 return fCurrentPS == nullptr; 159 return fCurrentPS == nullptr;
160 } 160 }
161 // get unit of primitive scorer by the name 161 // get unit of primitive scorer by the name
162 G4String GetPSUnit(const G4String& psname); 162 G4String GetPSUnit(const G4String& psname);
163 // get unit of current primitive scorer 163 // get unit of current primitive scorer
164 G4String GetCurrentPSUnit(); 164 G4String GetCurrentPSUnit();
165 // set unit of current primitive scorer 165 // set unit of current primitive scorer
166 void SetCurrentPSUnit(const G4String& unit); 166 void SetCurrentPSUnit(const G4String& unit);
167 // get unit value of primitive scorer by the 167 // get unit value of primitive scorer by the name
168 G4double GetPSUnitValue(const G4String& psna 168 G4double GetPSUnitValue(const G4String& psname);
169 // set PS name to be drawn 169 // set PS name to be drawn
170 inline void SetDrawPSName(const G4String& ps << 170 void SetDrawPSName(const G4String& psname) { fDrawPSName = psname; }
171 171
172 // get axis names of the hierarchical divisi 172 // get axis names of the hierarchical division in the divided order
173 void GetDivisionAxisNames(G4String divisionA 173 void GetDivisionAxisNames(G4String divisionAxisNames[3]);
174 174
175 // set current primitive scorer to NULL 175 // set current primitive scorer to NULL
176 void SetNullToCurrentPrimitiveScorer() { fCu 176 void SetNullToCurrentPrimitiveScorer() { fCurrentPS = nullptr; }
177 // set verbose level 177 // set verbose level
178 inline void SetVerboseLevel(G4int vl) { verb 178 inline void SetVerboseLevel(G4int vl) { verboseLevel = vl; }
179 // get the primitive scorer map 179 // get the primitive scorer map
180 inline MeshScoreMap GetScoreMap() const { re 180 inline MeshScoreMap GetScoreMap() const { return fMap; }
181 // get whether this mesh setup has been read 181 // get whether this mesh setup has been ready
182 inline G4bool ReadyForQuantity() const { ret 182 inline G4bool ReadyForQuantity() const { return (sizeIsSet && nMeshIsSet); }
183 183
184 // protected: 184 // protected:
185 // get registered primitive socrer by the na 185 // get registered primitive socrer by the name
186 G4VPrimitiveScorer* GetPrimitiveScorer(const 186 G4VPrimitiveScorer* GetPrimitiveScorer(const G4String& name);
187 187
188 inline void SetMeshElementLogical(G4LogicalV 188 inline void SetMeshElementLogical(G4LogicalVolume* val)
189 { 189 {
190 fMeshElementLogical = val; 190 fMeshElementLogical = val;
191 } 191 }
192 inline G4LogicalVolume* GetMeshElementLogica 192 inline G4LogicalVolume* GetMeshElementLogical() const
193 { 193 {
194 return fMeshElementLogical; 194 return fMeshElementLogical;
195 } 195 }
196 196
197 inline void SetParallelWorldProcess(G4Parall 197 inline void SetParallelWorldProcess(G4ParallelWorldProcess* proc)
198 { 198 {
199 fParallelWorldProcess = proc; 199 fParallelWorldProcess = proc;
200 } 200 }
201 inline G4ParallelWorldProcess* GetParallelWo 201 inline G4ParallelWorldProcess* GetParallelWorldProcess() const
202 { 202 {
203 return fParallelWorldProcess; 203 return fParallelWorldProcess;
204 } 204 }
205 inline void GeometryHasBeenDestroyed() 205 inline void GeometryHasBeenDestroyed()
206 { 206 {
207 fGeometryHasBeenDestroyed = true; 207 fGeometryHasBeenDestroyed = true;
208 fMeshElementLogical = nullptr; 208 fMeshElementLogical = nullptr;
209 } 209 }
210 210
211 // Geometry hirarchy level (bottom = 0) to b 211 // Geometry hirarchy level (bottom = 0) to be used as the copy number
212 // This is used only for real-world scorer 212 // This is used only for real-world scorer
213 inline void SetCopyNumberLevel(G4int val) { 213 inline void SetCopyNumberLevel(G4int val) { copyNumberLevel = val; }
214 inline G4int GetCopyNumberLevel() const { re 214 inline G4int GetCopyNumberLevel() const { return copyNumberLevel; }
215 215
216 inline G4bool LayeredMassFlg() { return laye << 216 G4bool LayeredMassFlg() { return layeredMassFlg; }
217 217
218 protected: 218 protected:
219 <<
220 // a pure virtual function to construct this 219 // a pure virtual function to construct this mesh geometry
221 virtual void SetupGeometry(G4VPhysicalVolume 220 virtual void SetupGeometry(G4VPhysicalVolume* fWorldPhys) = 0;
222 221
223 protected: 222 protected:
224 <<
225 G4String fWorldName; 223 G4String fWorldName;
226 G4VPrimitiveScorer* fCurrentPS; 224 G4VPrimitiveScorer* fCurrentPS;
227 G4bool fConstructed; 225 G4bool fConstructed;
228 G4bool fActive; 226 G4bool fActive;
229 MeshShape fShape; 227 MeshShape fShape;
230 228
231 G4double fSize[3]; 229 G4double fSize[3];
232 G4double fAngle[2]; 230 G4double fAngle[2];
233 G4ThreeVector fCenterPosition; 231 G4ThreeVector fCenterPosition;
234 G4RotationMatrix* fRotationMatrix; 232 G4RotationMatrix* fRotationMatrix;
235 G4int fNSegment[3]; 233 G4int fNSegment[3];
236 234
237 MeshScoreMap fMap; 235 MeshScoreMap fMap;
238 G4MultiFunctionalDetector* fMFD; 236 G4MultiFunctionalDetector* fMFD;
239 237
240 G4int verboseLevel; 238 G4int verboseLevel;
241 239
242 G4bool sizeIsSet; 240 G4bool sizeIsSet;
243 G4bool nMeshIsSet; 241 G4bool nMeshIsSet;
244 242
245 G4String fDrawUnit; 243 G4String fDrawUnit;
246 G4double fDrawUnitValue; 244 G4double fDrawUnitValue;
247 G4String fDrawPSName; 245 G4String fDrawPSName;
248 246
249 G4String fDivisionAxisNames[3]; 247 G4String fDivisionAxisNames[3];
250 248
251 G4LogicalVolume* fMeshElementLogical; 249 G4LogicalVolume* fMeshElementLogical;
252 250
253 G4ParallelWorldProcess* fParallelWorldProces 251 G4ParallelWorldProcess* fParallelWorldProcess;
254 G4bool fGeometryHasBeenDestroyed; 252 G4bool fGeometryHasBeenDestroyed;
255 253
256 G4int copyNumberLevel; 254 G4int copyNumberLevel;
257 255
258 // This flag may be set to true for Probe sc 256 // This flag may be set to true for Probe scoring mesh.
259 // There is no public set method for this bo 257 // There is no public set method for this boolean flag, but it should be set
260 // to true through SetMaterial() method of P 258 // to true through SetMaterial() method of Probe scoring mesh.
261 G4bool layeredMassFlg; 259 G4bool layeredMassFlg;
262 }; 260 };
263 261
264 #endif 262 #endif
265 263