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