| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // G4VScoringMesh
27 // -------------------------------------------
28
29 #include "G4VScoringMesh.hh"
30 #include "G4THitsMap.hh"
31 #include "G4SystemOfUnits.hh"
32 #include "G4VPhysicalVolume.hh"
33 #include "G4MultiFunctionalDetector.hh"
34 #include "G4VPrimitiveScorer.hh"
35 #include "G4VSDFilter.hh"
36 #include "G4SDManager.hh"
37
38 G4VScoringMesh::G4VScoringMesh(const G4String&
39 : fWorldName(wName)
40 , fCurrentPS(nullptr)
41 , fConstructed(false)
42 , fActive(true)
43 , fShape(MeshShape::undefined)
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 {
57 G4SDManager::GetSDMpointer()->AddNewDetector
58
59 fSize[0] = fSize[1] = fSize[2] = 0.;
60 fAngle[0] = 0.0;
61 fAngle[1] = CLHEP::twop
62 fNSegment[0] = fNSegment[1] = fNSegment[2] =
63 fDivisionAxisNames[0] = fDivisionAxisNames[1
64 }
65
66 void G4VScoringMesh::ResetScore()
67 {
68 if(verboseLevel > 9)
69 G4cout << "G4VScoringMesh::ResetScore() is
70 for(const auto& mp : fMap)
71 {
72 if(verboseLevel > 9)
73 G4cout << "G4VScoringMesh::ResetScore()"
74 mp.second->clear();
75 }
76 }
77
78 void G4VScoringMesh::SetSize(G4double size[3])
79 {
80 if(!sizeIsSet)
81 {
82 sizeIsSet = true;
83 for(G4int i = 0; i < 3; ++i)
84 {
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()",
93 "DigiHitsUtilsScoreVScoringMes
94 }
95 }
96
97 G4ThreeVector G4VScoringMesh::GetSize() const
98 {
99 if(sizeIsSet)
100 return G4ThreeVector(fSize[0], fSize[1], f
101 return G4ThreeVector(0., 0., 0.);
102 }
103
104 void G4VScoringMesh::SetAngles(G4double startA
105 {
106 fAngle[0] = startAngle;
107 fAngle[1] = spanAngle;
108 }
109
110 void G4VScoringMesh::SetCenterPosition(G4doubl
111 {
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;
124 }
125 else
126 {
127 G4String message = " Number of bins has
128 message += " This method is ignored.";
129 G4Exception("G4VScoringMesh::SetNumberOfSe
130 "DigiHitsUtilsScoreVScoringMes
131 }
132 }
133
134 void G4VScoringMesh::GetNumberOfSegments(G4int
135 {
136 for(G4int i = 0; i < 3; ++i)
137 nSegment[i] = fNSegment[i];
138 }
139
140 void G4VScoringMesh::RotateX(G4double delta)
141 {
142 if(fRotationMatrix == nullptr)
143 fRotationMatrix = new G4RotationMatrix();
144 fRotationMatrix->rotateX(delta);
145 }
146
147 void G4VScoringMesh::RotateY(G4double delta)
148 {
149 if(fRotationMatrix == nullptr)
150 fRotationMatrix = new G4RotationMatrix();
151 fRotationMatrix->rotateY(delta);
152 }
153
154 void G4VScoringMesh::RotateZ(G4double delta)
155 {
156 if(fRotationMatrix == nullptr)
157 fRotationMatrix = new G4RotationMatrix();
158 fRotationMatrix->rotateZ(delta);
159 }
160
161 void G4VScoringMesh::SetPrimitiveScorer(G4VPri
162 {
163 if(!ReadyForQuantity())
164 {
165 G4cerr << "ERROR : G4VScoringMesh::SetPrim
166 << prs->GetName()
167 << " does not yet have mesh size or
168 << G4endl << "This Method is ignore
169 return;
170 }
171 if(verboseLevel > 0)
172 G4cout << "G4VScoringMesh::SetPrimitiveSco
173 << " is registered."
174 << " 3D size: (" << fNSegment[0] <<
175 << fNSegment[2] << ")" << G4endl;
176
177 prs->SetNijk(fNSegment[0], fNSegment[1], fNS
178 fCurrentPS = prs;
179 fMFD->RegisterPrimitive(prs);
180 auto map =
181 new G4THitsMap<G4StatDouble>(fWorldName, p
182 fMap[prs->GetName()] = map;
183 }
184
185 void G4VScoringMesh::SetFilter(G4VSDFilter* fi
186 {
187 if(fCurrentPS == nullptr)
188 {
189 G4cerr << "ERROR : G4VScoringMesh::SetSDFi
190 "defined first. This method is i
191 << G4endl;
192 return;
193 }
194 if(verboseLevel > 0)
195 G4cout << "G4VScoringMesh::SetFilter() : "
196 << " is set to " << fCurrentPS->Get
197
198 G4VSDFilter* oldFilter = fCurrentPS->GetFilt
199 if(oldFilter != nullptr)
200 {
201 G4cout << "WARNING : G4VScoringMesh::SetFi
202 << " is overwritten by " << filter-
203 }
204 fCurrentPS->SetFilter(filter);
205 }
206
207 void G4VScoringMesh::SetCurrentPrimitiveScorer
208 {
209 fCurrentPS = GetPrimitiveScorer(name);
210 if(fCurrentPS == nullptr)
211 {
212 G4cerr << "ERROR : G4VScoringMesh::SetCurr
213 "primitive scorer <"
214 << name << "> does not found." << G
215 }
216 }
217
218 G4bool G4VScoringMesh::FindPrimitiveScorer(con
219 {
220 const auto itr = fMap.find(psname);
221 return itr != fMap.cend();
222 }
223
224 G4String G4VScoringMesh::GetPSUnit(const G4Str
225 {
226 const auto itr = fMap.find(psname);
227 if(itr == fMap.cend())
228 {
229 return G4String("");
230 }
231
232 return GetPrimitiveScorer(psname)->GetUnit()
233 }
234
235 G4String G4VScoringMesh::GetCurrentPSUnit()
236 {
237 G4String unit = "";
238 if(fCurrentPS == nullptr)
239 {
240 G4String msg = "ERROR : G4VScoringMesh::Ge
241 msg += " Current primitive scorer is null.
242 G4cerr << msg << G4endl;
243 }
244 else
245 {
246 unit = fCurrentPS->GetUnit();
247 }
248 return unit;
249 }
250
251 void G4VScoringMesh::SetCurrentPSUnit(const G4
252 {
253 if(fCurrentPS == nullptr)
254 {
255 G4String msg = "ERROR : G4VScoringMesh::Ge
256 msg += " Current primitive scorer is null.
257 G4cerr << msg << G4endl;
258 }
259 else
260 {
261 fCurrentPS->SetUnit(unit);
262 }
263 }
264
265 G4double G4VScoringMesh::GetPSUnitValue(const
266 {
267 const auto itr = fMap.find(psname);
268 if(itr == fMap.cend())
269 {
270 return 1.;
271 }
272
273 return GetPrimitiveScorer(psname)->GetUnitVa
274 }
275
276 void G4VScoringMesh::GetDivisionAxisNames(G4St
277 {
278 for(G4int i = 0; i < 3; ++i)
279 divisionAxisNames[i] = fDivisionAxisNames[
280 }
281
282 G4VPrimitiveScorer* G4VScoringMesh::GetPrimiti
283 {
284 if(fMFD == nullptr)
285 return nullptr;
286
287 G4int nps = fMFD->GetNumberOfPrimitives();
288 for(G4int i = 0; i < nps; ++i)
289 {
290 G4VPrimitiveScorer* prs = fMFD->GetPrimiti
291 if(name == prs->GetName())
292 return prs;
293 }
294
295 return nullptr;
296 }
297
298 void G4VScoringMesh::List() const
299 {
300 G4cout << " # of segments: (" << fNSegment[0
301 << fNSegment[2] << ")" << G4endl;
302 G4cout << " displacement: (" << fCenterPosit
303 << fCenterPosition.y() / cm << ", " <
304 << ") [cm]" << G4endl;
305 if(fRotationMatrix != nullptr)
306 {
307 G4cout << " rotation matrix: " << fRotatio
308 << fRotationMatrix->xy() << " " <<
309 << " " << fRotatio
310 << fRotationMatrix->yy() << " " <<
311 << " " << fRotatio
312 << fRotationMatrix->zy() << " " <<
313 }
314
315 G4cout << " registered primitve scorers : "
316 G4int nps = fMFD->GetNumberOfPrimitives();
317 G4VPrimitiveScorer* prs;
318 for(G4int i = 0; i < nps; ++i)
319 {
320 prs = fMFD->GetPrimitive(i);
321 G4cout << " " << i << " " << prs->GetNa
322 if(prs->GetFilter() != nullptr)
323 G4cout << " with " << prs->GetFilte
324 G4cout << G4endl;
325 }
326 }
327
328 void G4VScoringMesh::Dump()
329 {
330 G4cout << "scoring mesh name: " << fWorldNam
331 G4cout << "# of G4THitsMap : " << fMap.size(
332 for(const auto& mp : fMap)
333 {
334 G4cout << "[" << mp.first << "]" << G4endl
335 mp.second->PrintAllHits();
336 }
337 G4cout << G4endl;
338 }
339
340 void G4VScoringMesh::DrawMesh(const G4String&
341 G4VScoreColorMap
342 {
343 fDrawPSName = psName;
344 const auto fMapItr = fMap.find(psName);
345 if(fMapItr != fMap.cend())
346 {
347 fDrawUnit = GetPSUnit(psName);
348 fDrawUnitValue = GetPSUnitValue(psName);
349 Draw(fMapItr->second, colorMap, axflg);
350 }
351 else
352 {
353 G4cerr << "Scorer <" << psName << "> is no
354 << G4endl;
355 }
356 }
357
358 void G4VScoringMesh::DrawMesh(const G4String&
359 G4int iColumn, G
360 {
361 fDrawPSName = psName;
362 const auto fMapItr = fMap.find(psName);
363 if(fMapItr != fMap.cend())
364 {
365 fDrawUnit = GetPSUnit(psName);
366 fDrawUnitValue = GetPSUnitValue(psName);
367 DrawColumn(fMapItr->second, colorMap, idxP
368 }
369 else
370 {
371 G4cerr << "Scorer <" << psName << "> is no
372 << G4endl;
373 }
374 }
375
376 void G4VScoringMesh::Accumulate(G4THitsMap<G4d
377 {
378 G4String psName = map->GetName();
379 const auto fMapItr = fMap.find(psName);
380 if (fMapItr != fMap.cend()) { *(fMapItr->se
381
382 if(verboseLevel > 9)
383 {
384 G4cout << G4endl;
385 G4cout << "G4VScoringMesh::Accumulate()" <
386 G4cout << " PS name : " << psName << G4en
387 if(fMapItr == fMap.cend())
388 {
389 G4cout << " " << psName << " was not fo
390 }
391 else
392 {
393 G4cout << " map size : " << map->GetSiz
394 map->PrintAllHits();
395 }
396 G4cout << G4endl;
397 }
398 }
399
400 void G4VScoringMesh::Accumulate(G4THitsMap<G4S
401 {
402 G4String psName = map->GetName();
403 const auto fMapItr = fMap.find(psName);
404 if (fMapItr != fMap.cend()) { *(fMapItr->sec
405
406 if(verboseLevel > 9)
407 {
408 G4cout << G4endl;
409 G4cout << "G4VScoringMesh::Accumulate()" <
410 G4cout << " PS name : " << psName << G4en
411 if(fMapItr == fMap.cend())
412 {
413 G4cout << " " << psName << " was not fo
414 }
415 else
416 {
417 G4cout << " map size : " << map->GetSiz
418 map->PrintAllHits();
419 }
420 G4cout << G4endl;
421 }
422 }
423
424 void G4VScoringMesh::Construct(G4VPhysicalVolu
425 {
426 if(fConstructed)
427 {
428 if(fGeometryHasBeenDestroyed)
429 {
430 SetupGeometry(fWorldPhys);
431 fGeometryHasBeenDestroyed = false;
432 }
433 if(verboseLevel > 0)
434 G4cout << fWorldName << " --- All quanti
435 ResetScore();
436 }
437 else
438 {
439 fConstructed = true;
440 SetupGeometry(fWorldPhys);
441 }
442 }
443
444 void G4VScoringMesh::WorkerConstruct(G4VPhysic
445 {
446 if(fConstructed)
447 {
448 if(fGeometryHasBeenDestroyed)
449 {
450 fMeshElementLogical->SetSensitiveDetecto
451 fGeometryHasBeenDestroyed = false;
452 }
453
454 if(verboseLevel > 0)
455 G4cout << fWorldPhys->GetName() << " ---
456 << G4endl;
457 ResetScore();
458 }
459 else
460 {
461 fConstructed = true;
462 fMeshElementLogical->SetSensitiveDetector(
463 }
464 }
465
466 void G4VScoringMesh::Merge(const G4VScoringMes
467 {
468 const MeshScoreMap scMap = scMesh->GetScoreM
469
470 auto fMapItr = fMap.cbegin();
471 auto mapItr = scMap.cbegin();
472 for(; fMapItr != fMap.cend(); ++fMapItr)
473 {
474 if(verboseLevel > 9)
475 G4cout << "G4VScoringMesh::Merge()" << f
476 *(fMapItr->second) += *(mapItr->second);
477 ++mapItr;
478 }
479 }
480