| 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
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(0),fConstructed(false),fActive(true),
40 , fCurrentPS(nullptr) << 48 fRotationMatrix(0), fMFD(new G4MultiFunctionalDetector(wName)),
41 , fConstructed(false) << 49 verboseLevel(0),sizeIsSet(false),nMeshIsSet(false),
42 , fActive(true) << 50 fDrawUnit(""), fDrawUnitValue(1.)
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 { 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 <<
70 for(const auto& mp : fMap) <<
71 { <<
72 if(verboseLevel > 9) <<
73 G4cout << "G4VScoringMesh::ResetScore()" <<
74 mp.second->clear(); <<
75 } <<
76 } 62 }
77 63
78 void G4VScoringMesh::SetSize(G4double size[3]) << 64 void G4VScoringMesh::ResetScore() {
79 { << 65 if(verboseLevel > 9) G4cout << "G4VScoringMesh::ResetScore() is called." << G4endl;
80 if(!sizeIsSet) << 66 std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.begin();
81 { << 67 for(; itr != fMap.end(); itr++) {
82 sizeIsSet = true; << 68 if(verboseLevel > 9) G4cout << "G4VScoringMesh::ResetScore()" << itr->first << G4endl;
83 for(G4int i = 0; i < 3; ++i) << 69 itr->second->clear();
84 { <<
85 fSize[i] = size[i]; <<
86 } <<
87 } 70 }
88 else << 71 }
89 { << 72 void G4VScoringMesh::SetSize(G4double size[3]) {
90 G4String message = " Mesh size has alrea << 73 if ( !sizeIsSet ){
91 message += " This method is ignored."; << 74 for(int i = 0; i < 3; i++) fSize[i] = size[i];
>> 75 sizeIsSet = true;
>> 76 }else{
>> 77 G4String message = " The size of scoring mesh can not be changed.";
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
102 } << 87 return G4ThreeVector(0., 0., 0.);
103 <<
104 void G4VScoringMesh::SetAngles(G4double startA <<
105 { <<
106 fAngle[0] = startAngle; <<
107 fAngle[1] = spanAngle; <<
108 } 88 }
109 << 89 void G4VScoringMesh::SetCenterPosition(G4double centerPosition[3]) {
110 void G4VScoringMesh::SetCenterPosition(G4doubl << 90 fCenterPosition = G4ThreeVector(centerPosition[0], centerPosition[1], centerPosition[2]);
111 { <<
112 fCenterPosition = <<
113 G4ThreeVector(centerPosition[0], centerPos <<
114 } 91 }
115 << 92 void G4VScoringMesh::SetNumberOfSegments(G4int nSegment[3]) {
116 void G4VScoringMesh::SetNumberOfSegments(G4int << 93 if ( !nMeshIsSet ){
117 { << 94 for(int i = 0; i < 3; i++) fNSegment[i] = nSegment[i];
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 == 0) 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 == 0) 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 == 0) 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 * ps) {
162 { << 122
163 if(!ReadyForQuantity()) 123 if(!ReadyForQuantity())
164 { 124 {
165 G4cerr << "ERROR : G4VScoringMesh::SetPrim << 125 G4cerr << "ERROR : G4VScoringMesh::SetPrimitiveScorer() : " << ps->GetName()
166 << prs->GetName() << 126 << " does not yet have mesh size or number of bins. Set them first." << G4endl
167 << " does not yet have mesh size or << 127 << "This Method is ignored." << G4endl;
168 << G4endl << "This Method is ignore <<
169 return; 128 return;
170 } 129 }
171 if(verboseLevel > 0) << 130 if(verboseLevel > 0) G4cout << "G4VScoringMesh::SetPrimitiveScorer() : "
172 G4cout << "G4VScoringMesh::SetPrimitiveSco << 131 << ps->GetName() << " is registered."
173 << " is registered." << 132 << " 3D size: ("
174 << " 3D size: (" << fNSegment[0] << << 133 << fNSegment[0] << ", "
175 << fNSegment[2] << ")" << G4endl; << 134 << fNSegment[1] << ", "
176 << 135 << fNSegment[2] << ")" << G4endl;
177 prs->SetNijk(fNSegment[0], fNSegment[1], fNS << 136
178 fCurrentPS = prs; << 137 ps->SetNijk(fNSegment[0], fNSegment[1], fNSegment[2]);
179 fMFD->RegisterPrimitive(prs); << 138 fCurrentPS = ps;
180 auto map = << 139 fMFD->RegisterPrimitive(ps);
181 new G4THitsMap<G4StatDouble>(fWorldName, p << 140 G4THitsMap<G4double> * map = new G4THitsMap<G4double>(fWorldName, ps->GetName());
182 fMap[prs->GetName()] = map; << 141 fMap[ps->GetName()] = map;
183 } 142 }
184 143
185 void G4VScoringMesh::SetFilter(G4VSDFilter* fi << 144 void G4VScoringMesh::SetFilter(G4VSDFilter * filter) {
186 { << 145
187 if(fCurrentPS == nullptr) << 146 if(fCurrentPS == 0) {
188 { << 147 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; 148 return;
193 } 149 }
194 if(verboseLevel > 0) << 150 if(verboseLevel > 0) G4cout << "G4VScoringMesh::SetFilter() : "
195 G4cout << "G4VScoringMesh::SetFilter() : " << 151 << filter->GetName()
196 << " is set to " << fCurrentPS->Get << 152 << " is set to "
>> 153 << fCurrentPS->GetName() << G4endl;
197 154
198 G4VSDFilter* oldFilter = fCurrentPS->GetFilt 155 G4VSDFilter* oldFilter = fCurrentPS->GetFilter();
199 if(oldFilter != nullptr) << 156 if(oldFilter)
200 { 157 {
201 G4cout << "WARNING : G4VScoringMesh::SetFi << 158 G4cout << "WARNING : G4VScoringMesh::SetFilter() : " << oldFilter->GetName()
202 << " is overwritten by " << filter- 159 << " is overwritten by " << filter->GetName() << G4endl;
203 } 160 }
204 fCurrentPS->SetFilter(filter); 161 fCurrentPS->SetFilter(filter);
205 } 162 }
206 163
207 void G4VScoringMesh::SetCurrentPrimitiveScorer << 164 void G4VScoringMesh::SetCurrentPrimitiveScorer(const G4String & name) {
208 { <<
209 fCurrentPS = GetPrimitiveScorer(name); 165 fCurrentPS = GetPrimitiveScorer(name);
210 if(fCurrentPS == nullptr) << 166 if(fCurrentPS == 0) {
211 { << 167 G4cerr << "ERROR : G4VScoringMesh::SetCurrentPrimitiveScorer() : The primitive scorer <"
212 G4cerr << "ERROR : G4VScoringMesh::SetCurr << 168 << name << "> does not found." << G4endl;
213 "primitive scorer <" <<
214 << name << "> does not found." << G <<
215 } 169 }
216 } 170 }
217 171
218 G4bool G4VScoringMesh::FindPrimitiveScorer(con << 172 G4bool G4VScoringMesh::FindPrimitiveScorer(const G4String & psname) {
219 { << 173 std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.find(psname);;
220 const auto itr = fMap.find(psname); << 174 if(itr == fMap.end()) return false;
221 return itr != fMap.cend(); << 175 return true;
222 } 176 }
223 177
224 G4String G4VScoringMesh::GetPSUnit(const G4Str << 178 G4String G4VScoringMesh::GetPSUnit(const G4String & psname) {
225 { << 179 std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.find(psname);;
226 const auto itr = fMap.find(psname); << 180 if(itr == fMap.end()) {
227 if(itr == fMap.cend()) <<
228 { <<
229 return G4String(""); 181 return G4String("");
>> 182 } else {
>> 183 return GetPrimitiveScorer(psname)->GetUnit();
230 } 184 }
231 <<
232 return GetPrimitiveScorer(psname)->GetUnit() <<
233 } 185 }
234 186
235 G4String G4VScoringMesh::GetCurrentPSUnit() << 187 G4String G4VScoringMesh::GetCurrentPSUnit(){
236 { << 188 G4String unit = "";
237 G4String unit = ""; << 189 if(fCurrentPS == 0) {
238 if(fCurrentPS == nullptr) << 190 G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
239 { << 191 msg += " Current primitive scorer is null.";
240 G4String msg = "ERROR : G4VScoringMesh::Ge << 192 G4cerr << msg << G4endl;
241 msg += " Current primitive scorer is null. << 193 }else{
242 G4cerr << msg << G4endl; << 194 unit = fCurrentPS->GetUnit();
243 } <<
244 else <<
245 { <<
246 unit = fCurrentPS->GetUnit(); <<
247 } 195 }
248 return unit; 196 return unit;
249 } 197 }
250 198
251 void G4VScoringMesh::SetCurrentPSUnit(const G4 << 199 void G4VScoringMesh::SetCurrentPSUnit(const G4String& unit){
252 { << 200 if(fCurrentPS == 0) {
253 if(fCurrentPS == nullptr) << 201 G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
254 { << 202 msg += " Current primitive scorer is null.";
255 G4String msg = "ERROR : G4VScoringMesh::Ge << 203 G4cerr << msg << G4endl;
256 msg += " Current primitive scorer is null. << 204 }else{
257 G4cerr << msg << G4endl; << 205 fCurrentPS->SetUnit(unit);
258 } <<
259 else <<
260 { <<
261 fCurrentPS->SetUnit(unit); <<
262 } 206 }
263 } 207 }
264 208
265 G4double G4VScoringMesh::GetPSUnitValue(const << 209 G4double G4VScoringMesh::GetPSUnitValue(const G4String & psname) {
266 { << 210 std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.find(psname);;
267 const auto itr = fMap.find(psname); << 211 if(itr == fMap.end()) {
268 if(itr == fMap.cend()) <<
269 { <<
270 return 1.; 212 return 1.;
>> 213 } else {
>> 214 return GetPrimitiveScorer(psname)->GetUnitValue();
271 } 215 }
272 <<
273 return GetPrimitiveScorer(psname)->GetUnitVa <<
274 } 216 }
275 217
276 void G4VScoringMesh::GetDivisionAxisNames(G4St << 218 void G4VScoringMesh::GetDivisionAxisNames(G4String divisionAxisNames[3]) {
277 { << 219 for(int i = 0; i < 3; i++) divisionAxisNames[i] = fDivisionAxisNames[i];
278 for(G4int i = 0; i < 3; ++i) <<
279 divisionAxisNames[i] = fDivisionAxisNames[ <<
280 } 220 }
281 221
282 G4VPrimitiveScorer* G4VScoringMesh::GetPrimiti << 222 G4VPrimitiveScorer * G4VScoringMesh::GetPrimitiveScorer(const G4String & name) {
283 { << 223 if(fMFD == 0) return 0;
284 if(fMFD == nullptr) <<
285 return nullptr; <<
286 224
287 G4int nps = fMFD->GetNumberOfPrimitives(); 225 G4int nps = fMFD->GetNumberOfPrimitives();
288 for(G4int i = 0; i < nps; ++i) << 226 for(G4int i = 0; i < nps; i++) {
289 { << 227 G4VPrimitiveScorer * ps = fMFD->GetPrimitive(i);
290 G4VPrimitiveScorer* prs = fMFD->GetPrimiti << 228 if(name == ps->GetName()) return ps;
291 if(name == prs->GetName()) << 229 }
292 return prs; << 230
>> 231 return 0;
>> 232 }
>> 233 void G4VScoringMesh::List() const {
>> 234
>> 235 G4cout << " # of segments: ("
>> 236 << fNSegment[0] << ", "
>> 237 << fNSegment[1] << ", "
>> 238 << fNSegment[2] << ")"
>> 239 << G4endl;
>> 240 G4cout << " displacement: ("
>> 241 << fCenterPosition.x()/cm << ", "
>> 242 << fCenterPosition.y()/cm << ", "
>> 243 << fCenterPosition.z()/cm << ") [cm]"
>> 244 << G4endl;
>> 245 if(fRotationMatrix != 0) {
>> 246 G4cout << " rotation matrix: "
>> 247 << fRotationMatrix->xx() << " "
>> 248 << fRotationMatrix->xy() << " "
>> 249 << fRotationMatrix->xz() << G4endl
>> 250 << " "
>> 251 << fRotationMatrix->yx() << " "
>> 252 << fRotationMatrix->yy() << " "
>> 253 << fRotationMatrix->yz() << G4endl
>> 254 << " "
>> 255 << fRotationMatrix->zx() << " "
>> 256 << fRotationMatrix->zy() << " "
>> 257 << fRotationMatrix->zz() << G4endl;
293 } 258 }
294 259
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 260
315 G4cout << " registered primitve scorers : " 261 G4cout << " registered primitve scorers : " << G4endl;
316 G4int nps = fMFD->GetNumberOfPrimitives(); 262 G4int nps = fMFD->GetNumberOfPrimitives();
317 G4VPrimitiveScorer* prs; << 263 G4VPrimitiveScorer * ps;
318 for(G4int i = 0; i < nps; ++i) << 264 for(int i = 0; i < nps; i++) {
319 { << 265 ps = fMFD->GetPrimitive(i);
320 prs = fMFD->GetPrimitive(i); << 266 G4cout << " " << i << " " << ps->GetName();
321 G4cout << " " << i << " " << prs->GetNa << 267 if(ps->GetFilter() != 0) G4cout << " with " << ps->GetFilter()->GetName();
322 if(prs->GetFilter() != nullptr) <<
323 G4cout << " with " << prs->GetFilte <<
324 G4cout << G4endl; 268 G4cout << G4endl;
325 } 269 }
>> 270
>> 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;
>> 276
331 G4cout << "# of G4THitsMap : " << fMap.size( 277 G4cout << "# of G4THitsMap : " << fMap.size() << G4endl;
332 for(const auto& mp : fMap) << 278 std::map<G4String, G4THitsMap<G4double>* >::iterator itr = fMap.begin();
333 { << 279 for(; itr != fMap.end(); itr++) {
334 G4cout << "[" << mp.first << "]" << G4endl << 280 G4cout << "[" << itr->first << "]" << G4endl;
335 mp.second->PrintAllHits(); << 281 itr->second->PrintAllHits();
336 } 282 }
337 G4cout << G4endl; 283 G4cout << G4endl;
>> 284
338 } 285 }
339 286
340 void G4VScoringMesh::DrawMesh(const G4String& << 287
341 G4VScoreColorMap << 288 void G4VScoringMesh::DrawMesh(const G4String& psName,G4VScoreColorMap* colorMap,G4int axflg)
342 { 289 {
343 fDrawPSName = psName; 290 fDrawPSName = psName;
344 const auto fMapItr = fMap.find(psName); << 291 std::map<G4String, G4THitsMap<G4double>* >::const_iterator fMapItr = fMap.find(psName);
345 if(fMapItr != fMap.cend()) << 292 if(fMapItr!=fMap.end()) {
346 { << 293 fDrawUnit = GetPSUnit(psName);
347 fDrawUnit = GetPSUnit(psName); <<
348 fDrawUnitValue = GetPSUnitValue(psName); 294 fDrawUnitValue = GetPSUnitValue(psName);
349 Draw(fMapItr->second, colorMap, axflg); << 295 Draw(fMapItr->second->GetMap(), colorMap,axflg);
350 } << 296 } else {
351 else << 297 G4cerr << "Scorer <" << psName << "> is not defined. Method ignored." << G4endl;
352 { <<
353 G4cerr << "Scorer <" << psName << "> is no <<
354 << G4endl; <<
355 } 298 }
356 } 299 }
357 300
358 void G4VScoringMesh::DrawMesh(const G4String& << 301 void G4VScoringMesh::DrawMesh(const G4String& psName,G4int idxPlane,G4int iColumn,G4VScoreColorMap* colorMap)
359 G4int iColumn, G <<
360 { 302 {
361 fDrawPSName = psName; 303 fDrawPSName = psName;
362 const auto fMapItr = fMap.find(psName); << 304 std::map<G4String, G4THitsMap<G4double>* >::const_iterator fMapItr = fMap.find(psName);
363 if(fMapItr != fMap.cend()) << 305 if(fMapItr!=fMap.end()) {
364 { << 306 fDrawUnit = GetPSUnit(psName);
365 fDrawUnit = GetPSUnit(psName); <<
366 fDrawUnitValue = GetPSUnitValue(psName); 307 fDrawUnitValue = GetPSUnitValue(psName);
367 DrawColumn(fMapItr->second, colorMap, idxP << 308 DrawColumn(fMapItr->second->GetMap(),colorMap,idxPlane,iColumn);
368 } << 309 } else {
369 else << 310 G4cerr << "Scorer <" << psName << "> is not defined. Method ignored." << G4endl;
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 } 311 }
398 } 312 }
399 313
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 314