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