| 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 << 26 //
>> 27 //
>> 28 // ---------------------------------------------------------------------
>> 29 // Modifications
>> 30 // 17-Apr-2012 T.Aso SetSize() and SetNumberOfSegments() is not allowed
>> 31 // to call twice in same geometrical mesh. Add warning
>> 32 // message to notify.
>> 33 //
27 // ------------------------------------------- 34 // ---------------------------------------------------------------------
28 35
29 #include "G4VScoringMesh.hh" 36 #include "G4VScoringMesh.hh"
30 #include "G4THitsMap.hh" 37 #include "G4THitsMap.hh"
31 #include "G4SystemOfUnits.hh" 38 #include "G4SystemOfUnits.hh"
32 #include "G4VPhysicalVolume.hh" 39 #include "G4VPhysicalVolume.hh"
33 #include "G4MultiFunctionalDetector.hh" 40 #include "G4MultiFunctionalDetector.hh"
34 #include "G4VPrimitiveScorer.hh" 41 #include "G4VPrimitiveScorer.hh"
35 #include "G4VSDFilter.hh" 42 #include "G4VSDFilter.hh"
36 #include "G4SDManager.hh" 43 #include "G4SDManager.hh"
37 44
38 G4VScoringMesh::G4VScoringMesh(const G4String& 45 G4VScoringMesh::G4VScoringMesh(const G4String& wName)
39 : fWorldName(wName) << 46 : fWorldName(wName),fCurrentPS(nullptr),fConstructed(false),fActive(true),fShape(undefinedMesh),
40 , fCurrentPS(nullptr) << 47 fRotationMatrix(nullptr), fMFD(new G4MultiFunctionalDetector(wName)),
41 , fConstructed(false) << 48 verboseLevel(0),sizeIsSet(false),nMeshIsSet(false),
42 , fActive(true) << 49 fDrawUnit(""), fDrawUnitValue(1.), fMeshElementLogical(nullptr),
43 , fShape(MeshShape::undefined) << 50 fParallelWorldProcess(nullptr), fGeometryHasBeenDestroyed(false)
44 , fRotationMatrix(nullptr) <<
45 , fMFD(new G4MultiFunctionalDetector(wName)) <<
46 , verboseLevel(0) <<
47 , sizeIsSet(false) <<
48 , nMeshIsSet(false) <<
49 , fDrawUnit("") <<
50 , fDrawUnitValue(1.) <<
51 , fMeshElementLogical(nullptr) <<
52 , fParallelWorldProcess(nullptr) <<
53 , fGeometryHasBeenDestroyed(false) <<
54 , copyNumberLevel(0) <<
55 , layeredMassFlg(false) <<
56 { 51 {
57 G4SDManager::GetSDMpointer()->AddNewDetector 52 G4SDManager::GetSDMpointer()->AddNewDetector(fMFD);
58 53
59 fSize[0] = fSize[1] = fSize[2] = 0.; 54 fSize[0] = fSize[1] = fSize[2] = 0.;
60 fAngle[0] = 0.0; <<
61 fAngle[1] = CLHEP::twop <<
62 fNSegment[0] = fNSegment[1] = fNSegment[2] = 55 fNSegment[0] = fNSegment[1] = fNSegment[2] = 1;
63 fDivisionAxisNames[0] = fDivisionAxisNames[1 56 fDivisionAxisNames[0] = fDivisionAxisNames[1] = fDivisionAxisNames[2] = "";
64 } 57 }
65 58
66 void G4VScoringMesh::ResetScore() << 59 G4VScoringMesh::~G4VScoringMesh() {
67 { << 60 ;
68 if(verboseLevel > 9) << 61 }
69 G4cout << "G4VScoringMesh::ResetScore() is << 62
70 for(const auto& mp : fMap) << 63 void G4VScoringMesh::ResetScore() {
>> 64 if(verboseLevel > 9) G4cout << "G4VScoringMesh::ResetScore() is called." << G4endl;
>> 65 for(auto mp : fMap)
71 { 66 {
72 if(verboseLevel > 9) << 67 if(verboseLevel > 9) G4cout << "G4VScoringMesh::ResetScore()" << mp.first << G4endl;
73 G4cout << "G4VScoringMesh::ResetScore()" <<
74 mp.second->clear(); 68 mp.second->clear();
75 } 69 }
76 } 70 }
77 71
78 void G4VScoringMesh::SetSize(G4double size[3]) << 72 void G4VScoringMesh::SetSize(G4double size[3]) {
79 { << 73 if ( !sizeIsSet ){
80 if(!sizeIsSet) << 74 for(int i = 0; i < 3; i++) fSize[i] = size[i];
81 { <<
82 sizeIsSet = true; 75 sizeIsSet = true;
83 for(G4int i = 0; i < 3; ++i) << 76 }else{
84 { << 77 G4String message = " The size of scoring mesh can not be changed.";
85 fSize[i] = size[i]; <<
86 } <<
87 } <<
88 else <<
89 { <<
90 G4String message = " Mesh size has alrea <<
91 message += " This method is ignored."; <<
92 G4Exception("G4VScoringMesh::SetSize()", 78 G4Exception("G4VScoringMesh::SetSize()",
93 "DigiHitsUtilsScoreVScoringMes << 79 "DigiHitsUtilsScoreVScoringMesh000", JustWarning,
>> 80 message);
94 } 81 }
95 } 82 }
96 << 83 G4ThreeVector G4VScoringMesh::GetSize() const {
97 G4ThreeVector G4VScoringMesh::GetSize() const <<
98 { <<
99 if(sizeIsSet) 84 if(sizeIsSet)
100 return G4ThreeVector(fSize[0], fSize[1], f 85 return G4ThreeVector(fSize[0], fSize[1], fSize[2]);
101 return G4ThreeVector(0., 0., 0.); << 86 else
>> 87 return G4ThreeVector(0., 0., 0.);
102 } 88 }
103 << 89 void G4VScoringMesh::SetCenterPosition(G4double centerPosition[3]) {
104 void G4VScoringMesh::SetAngles(G4double startA << 90 fCenterPosition = G4ThreeVector(centerPosition[0], centerPosition[1], centerPosition[2]);
105 { <<
106 fAngle[0] = startAngle; <<
107 fAngle[1] = spanAngle; <<
108 } 91 }
109 << 92 void G4VScoringMesh::SetNumberOfSegments(G4int nSegment[3]) {
110 void G4VScoringMesh::SetCenterPosition(G4doubl << 93 if ( !nMeshIsSet ){
111 { << 94 for(int i = 0; i < 3; i++) fNSegment[i] = nSegment[i];
112 fCenterPosition = <<
113 G4ThreeVector(centerPosition[0], centerPos <<
114 } <<
115 <<
116 void G4VScoringMesh::SetNumberOfSegments(G4int <<
117 { <<
118 if(!nMeshIsSet || fShape == MeshShape::realW <<
119 fShape == MeshShape::probe) <<
120 { <<
121 for(G4int i = 0; i < 3; ++i) <<
122 fNSegment[i] = nSegment[i]; <<
123 nMeshIsSet = true; 95 nMeshIsSet = true;
124 } << 96 } else {
125 else << 97 G4String message = " The size of scoring segments can not be changed.";
126 { <<
127 G4String message = " Number of bins has <<
128 message += " This method is ignored."; <<
129 G4Exception("G4VScoringMesh::SetNumberOfSe 98 G4Exception("G4VScoringMesh::SetNumberOfSegments()",
130 "DigiHitsUtilsScoreVScoringMes << 99 "DigiHitsUtilsScoreVScoringMesh000", JustWarning,
>> 100 message);
131 } 101 }
132 } 102 }
133 << 103 void G4VScoringMesh::GetNumberOfSegments(G4int nSegment[3]) {
134 void G4VScoringMesh::GetNumberOfSegments(G4int << 104 for(int i = 0; i < 3; i++) nSegment[i] = fNSegment[i];
135 { <<
136 for(G4int i = 0; i < 3; ++i) <<
137 nSegment[i] = fNSegment[i]; <<
138 } 105 }
139 << 106 void G4VScoringMesh::RotateX(G4double delta) {
140 void G4VScoringMesh::RotateX(G4double delta) << 107 if(!fRotationMatrix) fRotationMatrix = new G4RotationMatrix();
141 { <<
142 if(fRotationMatrix == nullptr) <<
143 fRotationMatrix = new G4RotationMatrix(); <<
144 fRotationMatrix->rotateX(delta); 108 fRotationMatrix->rotateX(delta);
145 } 109 }
146 110
147 void G4VScoringMesh::RotateY(G4double delta) << 111 void G4VScoringMesh::RotateY(G4double delta) {
148 { << 112 if(!fRotationMatrix) fRotationMatrix = new G4RotationMatrix();
149 if(fRotationMatrix == nullptr) <<
150 fRotationMatrix = new G4RotationMatrix(); <<
151 fRotationMatrix->rotateY(delta); 113 fRotationMatrix->rotateY(delta);
152 } 114 }
153 115
154 void G4VScoringMesh::RotateZ(G4double delta) << 116 void G4VScoringMesh::RotateZ(G4double delta) {
155 { << 117 if(!fRotationMatrix) fRotationMatrix = new G4RotationMatrix();
156 if(fRotationMatrix == nullptr) <<
157 fRotationMatrix = new G4RotationMatrix(); <<
158 fRotationMatrix->rotateZ(delta); 118 fRotationMatrix->rotateZ(delta);
159 } 119 }
160 120
161 void G4VScoringMesh::SetPrimitiveScorer(G4VPri << 121 void G4VScoringMesh::SetPrimitiveScorer(G4VPrimitiveScorer * prs) {
162 { << 122
163 if(!ReadyForQuantity()) 123 if(!ReadyForQuantity())
164 { 124 {
165 G4cerr << "ERROR : G4VScoringMesh::SetPrim 125 G4cerr << "ERROR : G4VScoringMesh::SetPrimitiveScorer() : "
166 << prs->GetName() << 126 << prs->GetName()
167 << " does not yet have mesh size or << 127 << " does not yet have mesh size or number of bins. Set them first." << G4endl
168 << G4endl << "This Method is ignore << 128 << "This Method is ignored." << G4endl;
169 return; 129 return;
170 } 130 }
171 if(verboseLevel > 0) << 131 if(verboseLevel > 0) G4cout << "G4VScoringMesh::SetPrimitiveScorer() : "
172 G4cout << "G4VScoringMesh::SetPrimitiveSco << 132 << prs->GetName() << " is registered."
173 << " is registered." << 133 << " 3D size: ("
174 << " 3D size: (" << fNSegment[0] << << 134 << fNSegment[0] << ", "
175 << fNSegment[2] << ")" << G4endl; << 135 << fNSegment[1] << ", "
>> 136 << fNSegment[2] << ")" << G4endl;
176 137
177 prs->SetNijk(fNSegment[0], fNSegment[1], fNS 138 prs->SetNijk(fNSegment[0], fNSegment[1], fNSegment[2]);
178 fCurrentPS = prs; 139 fCurrentPS = prs;
179 fMFD->RegisterPrimitive(prs); 140 fMFD->RegisterPrimitive(prs);
180 auto map = << 141 G4THitsMap<G4StatDouble> * map = new G4THitsMap<G4StatDouble>(fWorldName, prs->GetName());
181 new G4THitsMap<G4StatDouble>(fWorldName, p <<
182 fMap[prs->GetName()] = map; 142 fMap[prs->GetName()] = map;
183 } 143 }
184 144
185 void G4VScoringMesh::SetFilter(G4VSDFilter* fi << 145 void G4VScoringMesh::SetFilter(G4VSDFilter * filter) {
186 { << 146
187 if(fCurrentPS == nullptr) << 147 if(!fCurrentPS) {
188 { << 148 G4cerr << "ERROR : G4VScoringMesh::SetSDFilter() : a quantity must be defined first. This method is ignored." << G4endl;
189 G4cerr << "ERROR : G4VScoringMesh::SetSDFi <<
190 "defined first. This method is i <<
191 << G4endl; <<
192 return; 149 return;
193 } 150 }
194 if(verboseLevel > 0) << 151 if(verboseLevel > 0) G4cout << "G4VScoringMesh::SetFilter() : "
195 G4cout << "G4VScoringMesh::SetFilter() : " << 152 << filter->GetName()
196 << " is set to " << fCurrentPS->Get << 153 << " is set to "
>> 154 << fCurrentPS->GetName() << G4endl;
197 155
198 G4VSDFilter* oldFilter = fCurrentPS->GetFilt 156 G4VSDFilter* oldFilter = fCurrentPS->GetFilter();
199 if(oldFilter != nullptr) << 157 if(oldFilter)
200 { 158 {
201 G4cout << "WARNING : G4VScoringMesh::SetFi << 159 G4cout << "WARNING : G4VScoringMesh::SetFilter() : " << oldFilter->GetName()
202 << " is overwritten by " << filter- 160 << " is overwritten by " << filter->GetName() << G4endl;
203 } 161 }
204 fCurrentPS->SetFilter(filter); 162 fCurrentPS->SetFilter(filter);
205 } 163 }
206 164
207 void G4VScoringMesh::SetCurrentPrimitiveScorer << 165 void G4VScoringMesh::SetCurrentPrimitiveScorer(const G4String & name) {
208 { <<
209 fCurrentPS = GetPrimitiveScorer(name); 166 fCurrentPS = GetPrimitiveScorer(name);
210 if(fCurrentPS == nullptr) << 167 if(!fCurrentPS) {
211 { << 168 G4cerr << "ERROR : G4VScoringMesh::SetCurrentPrimitiveScorer() : The primitive scorer <"
212 G4cerr << "ERROR : G4VScoringMesh::SetCurr << 169 << name << "> does not found." << G4endl;
213 "primitive scorer <" <<
214 << name << "> does not found." << G <<
215 } 170 }
216 } 171 }
217 172
218 G4bool G4VScoringMesh::FindPrimitiveScorer(con << 173 G4bool G4VScoringMesh::FindPrimitiveScorer(const G4String & psname) {
219 { << 174 MeshScoreMap::iterator itr = fMap.find(psname);
220 const auto itr = fMap.find(psname); << 175 if(itr == fMap.end()) return false;
221 return itr != fMap.cend(); << 176 return true;
222 } 177 }
223 178
224 G4String G4VScoringMesh::GetPSUnit(const G4Str << 179 G4String G4VScoringMesh::GetPSUnit(const G4String & psname) {
225 { << 180 MeshScoreMap::iterator itr = fMap.find(psname);
226 const auto itr = fMap.find(psname); << 181 if(itr == fMap.end()) {
227 if(itr == fMap.cend()) <<
228 { <<
229 return G4String(""); 182 return G4String("");
>> 183 } else {
>> 184 return GetPrimitiveScorer(psname)->GetUnit();
230 } 185 }
231 <<
232 return GetPrimitiveScorer(psname)->GetUnit() <<
233 } 186 }
234 187
235 G4String G4VScoringMesh::GetCurrentPSUnit() << 188 G4String G4VScoringMesh::GetCurrentPSUnit(){
236 { <<
237 G4String unit = ""; 189 G4String unit = "";
238 if(fCurrentPS == nullptr) << 190 if(!fCurrentPS) {
239 { << 191 G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
240 G4String msg = "ERROR : G4VScoringMesh::Ge << 192 msg += " Current primitive scorer is null.";
241 msg += " Current primitive scorer is null. << 193 G4cerr << msg << G4endl;
242 G4cerr << msg << G4endl; << 194 }else{
243 } << 195 unit = fCurrentPS->GetUnit();
244 else <<
245 { <<
246 unit = fCurrentPS->GetUnit(); <<
247 } 196 }
248 return unit; 197 return unit;
249 } 198 }
250 199
251 void G4VScoringMesh::SetCurrentPSUnit(const G4 << 200 void G4VScoringMesh::SetCurrentPSUnit(const G4String& unit){
252 { << 201 if(!fCurrentPS) {
253 if(fCurrentPS == nullptr) << 202 G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
254 { << 203 msg += " Current primitive scorer is null.";
255 G4String msg = "ERROR : G4VScoringMesh::Ge << 204 G4cerr << msg << G4endl;
256 msg += " Current primitive scorer is null. << 205 }else{
257 G4cerr << msg << G4endl; << 206 fCurrentPS->SetUnit(unit);
258 } <<
259 else <<
260 { <<
261 fCurrentPS->SetUnit(unit); <<
262 } 207 }
263 } 208 }
264 209
265 G4double G4VScoringMesh::GetPSUnitValue(const << 210 G4double G4VScoringMesh::GetPSUnitValue(const G4String & psname) {
266 { << 211 MeshScoreMap::iterator itr = fMap.find(psname);
267 const auto itr = fMap.find(psname); << 212 if(itr == fMap.end()) {
268 if(itr == fMap.cend()) <<
269 { <<
270 return 1.; 213 return 1.;
>> 214 } else {
>> 215 return GetPrimitiveScorer(psname)->GetUnitValue();
271 } 216 }
272 <<
273 return GetPrimitiveScorer(psname)->GetUnitVa <<
274 } 217 }
275 218
276 void G4VScoringMesh::GetDivisionAxisNames(G4St << 219 void G4VScoringMesh::GetDivisionAxisNames(G4String divisionAxisNames[3]) {
277 { << 220 for(int i = 0; i < 3; i++) divisionAxisNames[i] = fDivisionAxisNames[i];
278 for(G4int i = 0; i < 3; ++i) <<
279 divisionAxisNames[i] = fDivisionAxisNames[ <<
280 } 221 }
281 222
282 G4VPrimitiveScorer* G4VScoringMesh::GetPrimiti << 223 G4VPrimitiveScorer * G4VScoringMesh::GetPrimitiveScorer(const G4String & name) {
283 { << 224 if(!fMFD) return nullptr;
284 if(fMFD == nullptr) <<
285 return nullptr; <<
286 225
287 G4int nps = fMFD->GetNumberOfPrimitives(); 226 G4int nps = fMFD->GetNumberOfPrimitives();
288 for(G4int i = 0; i < nps; ++i) << 227 for(G4int i = 0; i < nps; i++) {
289 { << 228 G4VPrimitiveScorer * prs = fMFD->GetPrimitive(i);
290 G4VPrimitiveScorer* prs = fMFD->GetPrimiti << 229 if(name == prs->GetName()) return prs;
291 if(name == prs->GetName()) <<
292 return prs; <<
293 } 230 }
294 231
295 return nullptr; 232 return nullptr;
296 } 233 }
>> 234 void G4VScoringMesh::List() const {
297 235
298 void G4VScoringMesh::List() const << 236 G4cout << " # of segments: ("
299 { << 237 << fNSegment[0] << ", "
300 G4cout << " # of segments: (" << fNSegment[0 << 238 << fNSegment[1] << ", "
301 << fNSegment[2] << ")" << G4endl; << 239 << fNSegment[2] << ")"
302 G4cout << " displacement: (" << fCenterPosit << 240 << G4endl;
303 << fCenterPosition.y() / cm << ", " < << 241 G4cout << " displacement: ("
304 << ") [cm]" << G4endl; << 242 << fCenterPosition.x()/cm << ", "
305 if(fRotationMatrix != nullptr) << 243 << fCenterPosition.y()/cm << ", "
306 { << 244 << fCenterPosition.z()/cm << ") [cm]"
307 G4cout << " rotation matrix: " << fRotatio << 245 << G4endl;
308 << fRotationMatrix->xy() << " " << << 246 if(fRotationMatrix != 0) {
309 << " " << fRotatio << 247 G4cout << " rotation matrix: "
310 << fRotationMatrix->yy() << " " << << 248 << fRotationMatrix->xx() << " "
311 << " " << fRotatio << 249 << fRotationMatrix->xy() << " "
312 << fRotationMatrix->zy() << " " << << 250 << fRotationMatrix->xz() << G4endl
>> 251 << " "
>> 252 << fRotationMatrix->yx() << " "
>> 253 << fRotationMatrix->yy() << " "
>> 254 << fRotationMatrix->yz() << G4endl
>> 255 << " "
>> 256 << fRotationMatrix->zx() << " "
>> 257 << fRotationMatrix->zy() << " "
>> 258 << fRotationMatrix->zz() << G4endl;
313 } 259 }
314 260
>> 261
315 G4cout << " registered primitve scorers : " 262 G4cout << " registered primitve scorers : " << G4endl;
316 G4int nps = fMFD->GetNumberOfPrimitives(); 263 G4int nps = fMFD->GetNumberOfPrimitives();
317 G4VPrimitiveScorer* prs; << 264 G4VPrimitiveScorer * prs;
318 for(G4int i = 0; i < nps; ++i) << 265 for(int i = 0; i < nps; i++) {
319 { <<
320 prs = fMFD->GetPrimitive(i); 266 prs = fMFD->GetPrimitive(i);
321 G4cout << " " << i << " " << prs->GetNa 267 G4cout << " " << i << " " << prs->GetName();
322 if(prs->GetFilter() != nullptr) << 268 if(prs->GetFilter() != 0) G4cout << " with " << prs->GetFilter()->GetName();
323 G4cout << " with " << prs->GetFilte <<
324 G4cout << G4endl; 269 G4cout << G4endl;
325 } 270 }
326 } 271 }
327 272
328 void G4VScoringMesh::Dump() << 273 void G4VScoringMesh::Dump() {
329 { <<
330 G4cout << "scoring mesh name: " << fWorldNam 274 G4cout << "scoring mesh name: " << fWorldName << G4endl;
331 G4cout << "# of G4THitsMap : " << fMap.size( 275 G4cout << "# of G4THitsMap : " << fMap.size() << G4endl;
332 for(const auto& mp : fMap) << 276 for(auto mp : fMap)
333 { 277 {
334 G4cout << "[" << mp.first << "]" << G4endl 278 G4cout << "[" << mp.first << "]" << G4endl;
335 mp.second->PrintAllHits(); 279 mp.second->PrintAllHits();
336 } 280 }
337 G4cout << G4endl; 281 G4cout << G4endl;
>> 282
338 } 283 }
339 284
340 void G4VScoringMesh::DrawMesh(const G4String& << 285
341 G4VScoreColorMap << 286 void G4VScoringMesh::DrawMesh(const G4String& psName,G4VScoreColorMap* colorMap,G4int axflg)
342 { 287 {
343 fDrawPSName = psName; 288 fDrawPSName = psName;
344 const auto fMapItr = fMap.find(psName); << 289 MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
345 if(fMapItr != fMap.cend()) << 290 if(fMapItr!=fMap.end()) {
346 { << 291 fDrawUnit = GetPSUnit(psName);
347 fDrawUnit = GetPSUnit(psName); <<
348 fDrawUnitValue = GetPSUnitValue(psName); 292 fDrawUnitValue = GetPSUnitValue(psName);
349 Draw(fMapItr->second, colorMap, axflg); << 293 Draw(fMapItr->second, colorMap,axflg);
350 } << 294 } else {
351 else << 295 G4cerr << "Scorer <" << psName << "> is not defined. Method ignored." << G4endl;
352 { <<
353 G4cerr << "Scorer <" << psName << "> is no <<
354 << G4endl; <<
355 } 296 }
356 } 297 }
357 298
358 void G4VScoringMesh::DrawMesh(const G4String& << 299 void G4VScoringMesh::DrawMesh(const G4String& psName,G4int idxPlane,G4int iColumn,G4VScoreColorMap* colorMap)
359 G4int iColumn, G <<
360 { 300 {
361 fDrawPSName = psName; 301 fDrawPSName = psName;
362 const auto fMapItr = fMap.find(psName); << 302 MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
363 if(fMapItr != fMap.cend()) << 303 if(fMapItr!=fMap.end()) {
364 { << 304 fDrawUnit = GetPSUnit(psName);
365 fDrawUnit = GetPSUnit(psName); <<
366 fDrawUnitValue = GetPSUnitValue(psName); 305 fDrawUnitValue = GetPSUnitValue(psName);
367 DrawColumn(fMapItr->second, colorMap, idxP << 306 DrawColumn(fMapItr->second,colorMap,idxPlane,iColumn);
368 } << 307 } else {
369 else << 308 G4cerr << "Scorer <" << psName << "> is not defined. Method ignored." << G4endl;
370 { <<
371 G4cerr << "Scorer <" << psName << "> is no <<
372 << G4endl; <<
373 } 309 }
374 } 310 }
375 311
376 void G4VScoringMesh::Accumulate(G4THitsMap<G4d << 312 void G4VScoringMesh::Accumulate(G4THitsMap<G4double> * map)
377 { 313 {
378 G4String psName = map->GetName(); 314 G4String psName = map->GetName();
379 const auto fMapItr = fMap.find(psName); << 315 MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
380 if (fMapItr != fMap.cend()) { *(fMapItr->se << 316 *(fMapItr->second) += *map;
381 317
382 if(verboseLevel > 9) << 318 if(verboseLevel > 9) {
383 { <<
384 G4cout << G4endl; 319 G4cout << G4endl;
385 G4cout << "G4VScoringMesh::Accumulate()" < 320 G4cout << "G4VScoringMesh::Accumulate()" << G4endl;
386 G4cout << " PS name : " << psName << G4en 321 G4cout << " PS name : " << psName << G4endl;
387 if(fMapItr == fMap.cend()) << 322 if(fMapItr == fMap.end()) {
388 { <<
389 G4cout << " " << psName << " was not fo 323 G4cout << " " << psName << " was not found." << G4endl;
390 } << 324 } else {
391 else <<
392 { <<
393 G4cout << " map size : " << map->GetSiz 325 G4cout << " map size : " << map->GetSize() << G4endl;
394 map->PrintAllHits(); 326 map->PrintAllHits();
395 } 327 }
396 G4cout << G4endl; 328 G4cout << G4endl;
397 } 329 }
398 } 330 }
399 331
400 void G4VScoringMesh::Accumulate(G4THitsMap<G4S << 332 void G4VScoringMesh::Accumulate(G4THitsMap<G4StatDouble> * map)
401 { 333 {
402 G4String psName = map->GetName(); 334 G4String psName = map->GetName();
403 const auto fMapItr = fMap.find(psName); << 335 MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
404 if (fMapItr != fMap.cend()) { *(fMapItr->sec << 336 *(fMapItr->second) += *map;
405 337
406 if(verboseLevel > 9) << 338 if(verboseLevel > 9) {
407 { <<
408 G4cout << G4endl; 339 G4cout << G4endl;
409 G4cout << "G4VScoringMesh::Accumulate()" < 340 G4cout << "G4VScoringMesh::Accumulate()" << G4endl;
410 G4cout << " PS name : " << psName << G4en 341 G4cout << " PS name : " << psName << G4endl;
411 if(fMapItr == fMap.cend()) << 342 if(fMapItr == fMap.end()) {
412 { <<
413 G4cout << " " << psName << " was not fo 343 G4cout << " " << psName << " was not found." << G4endl;
414 } << 344 } else {
415 else <<
416 { <<
417 G4cout << " map size : " << map->GetSiz 345 G4cout << " map size : " << map->GetSize() << G4endl;
418 map->PrintAllHits(); 346 map->PrintAllHits();
419 } 347 }
420 G4cout << G4endl; 348 G4cout << G4endl;
421 } 349 }
422 } 350 }
423 351
424 void G4VScoringMesh::Construct(G4VPhysicalVolu 352 void G4VScoringMesh::Construct(G4VPhysicalVolume* fWorldPhys)
425 { 353 {
426 if(fConstructed) << 354 if(fConstructed) {
427 { << 355 if(fGeometryHasBeenDestroyed) {
428 if(fGeometryHasBeenDestroyed) <<
429 { <<
430 SetupGeometry(fWorldPhys); 356 SetupGeometry(fWorldPhys);
431 fGeometryHasBeenDestroyed = false; 357 fGeometryHasBeenDestroyed = false;
432 } 358 }
433 if(verboseLevel > 0) 359 if(verboseLevel > 0)
434 G4cout << fWorldName << " --- All quanti << 360 G4cout << fWorldPhys->GetName() << " --- All quantities are reset."
>> 361 << G4endl;
435 ResetScore(); 362 ResetScore();
436 } 363 }
437 else << 364 else {
438 { <<
439 fConstructed = true; 365 fConstructed = true;
440 SetupGeometry(fWorldPhys); 366 SetupGeometry(fWorldPhys);
441 } 367 }
442 } 368 }
443 369
444 void G4VScoringMesh::WorkerConstruct(G4VPhysic 370 void G4VScoringMesh::WorkerConstruct(G4VPhysicalVolume* fWorldPhys)
445 { 371 {
446 if(fConstructed) << 372 if(fConstructed) {
447 { << 373 if(fGeometryHasBeenDestroyed) {
448 if(fGeometryHasBeenDestroyed) <<
449 { <<
450 fMeshElementLogical->SetSensitiveDetecto 374 fMeshElementLogical->SetSensitiveDetector(fMFD);
451 fGeometryHasBeenDestroyed = false; 375 fGeometryHasBeenDestroyed = false;
452 } 376 }
453 377
454 if(verboseLevel > 0) 378 if(verboseLevel > 0)
455 G4cout << fWorldPhys->GetName() << " --- << 379 G4cout << fWorldPhys->GetName() << " --- All quantities are reset." << G4endl;
456 << G4endl; <<
457 ResetScore(); 380 ResetScore();
458 } << 381
459 else << 382 } else {
460 { <<
461 fConstructed = true; 383 fConstructed = true;
462 fMeshElementLogical->SetSensitiveDetector( 384 fMeshElementLogical->SetSensitiveDetector(fMFD);
463 } 385 }
464 } 386 }
465 387
466 void G4VScoringMesh::Merge(const G4VScoringMes << 388 void G4VScoringMesh::Merge(const G4VScoringMesh * scMesh)
467 { 389 {
468 const MeshScoreMap scMap = scMesh->GetScoreM 390 const MeshScoreMap scMap = scMesh->GetScoreMap();
469 391
470 auto fMapItr = fMap.cbegin(); << 392 MeshScoreMap::const_iterator fMapItr = fMap.begin();
471 auto mapItr = scMap.cbegin(); << 393 MeshScoreMap::const_iterator mapItr = scMap.begin();
472 for(; fMapItr != fMap.cend(); ++fMapItr) << 394 for(; fMapItr != fMap.end(); fMapItr++) {
473 { << 395 if(verboseLevel > 9) G4cout << "G4VScoringMesh::Merge()" << fMapItr->first << G4endl;
474 if(verboseLevel > 9) <<
475 G4cout << "G4VScoringMesh::Merge()" << f <<
476 *(fMapItr->second) += *(mapItr->second); 396 *(fMapItr->second) += *(mapItr->second);
477 ++mapItr; << 397 mapItr++;
478 } 398 }
479 } 399 }
>> 400
480 401