Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4ScoringBox.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id$
28//
29
30#include "G4ScoringBox.hh"
31
32#include "G4SystemOfUnits.hh"
33#include "G4Box.hh"
34#include "G4LogicalVolume.hh"
35#include "G4VPhysicalVolume.hh"
36#include "G4PVPlacement.hh"
37#include "G4PVReplica.hh"
38#include "G4PVDivision.hh"
39#include "G4VisAttributes.hh"
40#include "G4VVisManager.hh"
41#include "G4VScoreColorMap.hh"
42
43#include "G4MultiFunctionalDetector.hh"
44#include "G4SDParticleFilter.hh"
45#include "G4VPrimitiveScorer.hh"
46
47#include "G4ScoringManager.hh"
48
49#include <map>
50#include <fstream>
51
52G4ScoringBox::G4ScoringBox(G4String wName)
53 :G4VScoringMesh(wName), fSegmentDirection(-1),
54 fMeshElementLogical(0)
55{
56 fShape = boxMesh;
57 fDivisionAxisNames[0] = "X";
58 fDivisionAxisNames[1] = "Y";
59 fDivisionAxisNames[2] = "Z";
60}
61
62G4ScoringBox::~G4ScoringBox()
63{
64}
65
66void G4ScoringBox::Construct(G4VPhysicalVolume* fWorldPhys)
67{
68 if(fConstructed) {
69
70 if(verboseLevel > 0)
71 G4cout << fWorldPhys->GetName() << " --- All quantities are reset." << G4endl;
72 ResetScore();
73
74 } else {
75 fConstructed = true;
76 SetupGeometry(fWorldPhys);
77 }
78}
79
80
81
82void G4ScoringBox::SetupGeometry(G4VPhysicalVolume * fWorldPhys) {
83
84 if(verboseLevel > 9) G4cout << "G4ScoringBox::SetupGeometry() ..." << G4endl;
85
86 // World
87 G4VPhysicalVolume * scoringWorld = fWorldPhys;
88 G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume();
89
90 // Scoring Mesh
91 if(verboseLevel > 9) G4cout << fWorldName << G4endl;
92 G4String boxName = fWorldName;
93
94 if(verboseLevel > 9) G4cout << fSize[0] << ", " << fSize[1] << ", " << fSize[2] << G4endl;
95 G4VSolid * boxSolid = new G4Box(boxName+"0", fSize[0], fSize[1], fSize[2]);
96 G4LogicalVolume * boxLogical = new G4LogicalVolume(boxSolid, 0, boxName);
97 new G4PVPlacement(fRotationMatrix, fCenterPosition,
98 boxLogical, boxName+"0", worldLogical, false, 0);
99
100 //G4double fsegment[3][3];
101 //G4int segOrder[3];
102 //GetSegmentOrder(fSegmentDirection, fNSegment, segOrder, fsegment);
103 //EAxis axis[3] = {kXAxis, kYAxis, kZAxis};
104
105 G4String layerName[2] = {boxName + "1", boxName + "2"};
106 G4VSolid * layerSolid[2];
107 G4LogicalVolume * layerLogical[2];
108
109 //-- fisrt nested layer (replicated to x direction)
110 if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
111 layerSolid[0] = new G4Box(layerName[0],
112 fSize[0]/fNSegment[0],
113 fSize[1],
114 fSize[2]);
115 layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
116 if(fNSegment[0] > 1) {
117 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to x direction" << G4endl;
118 if(G4ScoringManager::GetReplicaLevel()>0)
119 {
120 new G4PVReplica(layerName[0], layerLogical[0], boxLogical, kXAxis,
121 fNSegment[0], fSize[0]/fNSegment[0]*2.);
122 }
123 else
124 {
125 new G4PVDivision(layerName[0], layerLogical[0], boxLogical, kXAxis,
126 fNSegment[0], 0.);
127 }
128 } else if(fNSegment[0] == 1) {
129 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
130 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], boxLogical, false, 0);
131 } else
132 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
133 << fNSegment[0] << ") "
134 << "in placement of the first nested layer." << G4endl;
135
136 if(verboseLevel > 9) {
137 G4cout << fSize[0]/fNSegment[0] << ", "
138 << fSize[1] << ", "
139 << fSize[2] << G4endl;
140 G4cout << layerName[0] << ": kXAxis, "
141 << fNSegment[0] << ", "
142 << 2.*fSize[0]/fNSegment[0] << G4endl;
143 }
144
145 // second nested layer (replicated to y direction)
146 if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
147 layerSolid[1] = new G4Box(layerName[1],
148 fSize[0]/fNSegment[0],
149 fSize[1]/fNSegment[1],
150 fSize[2]);
151 layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
152 if(fNSegment[1] > 1) {
153 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to y direction" << G4endl;
154 if(G4ScoringManager::GetReplicaLevel()>1)
155 {
156 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
157 fNSegment[1], fSize[1]/fNSegment[1]*2.);
158 }
159 else
160 {
161 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
162 fNSegment[1], 0.);
163 }
164 } else if(fNSegment[1] == 1) {
165 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
166 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
167 } else
168 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
169 << fNSegment[1] << ") "
170 << "in placement of the second nested layer." << G4endl;
171
172 if(verboseLevel > 9) {
173 G4cout << fSize[0]/fNSegment[0] << ", "
174 << fSize[1]/fNSegment[1] << ", "
175 << fSize[2] << G4endl;
176 G4cout << layerName[1] << ": kYAxis, "
177 << fNSegment[1] << ", "
178 << 2.*fSize[1]/fNSegment[1] << G4endl;
179 }
180
181 // mesh elements (replicated to z direction)
182 if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
183 G4String elementName = boxName +"3";
184 G4VSolid * elementSolid = new G4Box(elementName,
185 fSize[0]/fNSegment[0],
186 fSize[1]/fNSegment[1],
187 fSize[2]/fNSegment[2]);
188 fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
189 if(fNSegment[2] > 1) {
190 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to z direction" << G4endl;
191
192 if(G4ScoringManager::GetReplicaLevel()>2)
193 {
194 new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
195 fNSegment[2], 2.*fSize[2]/fNSegment[2]);
196 }
197 else
198 {
199 new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
200 fNSegment[2], 0.);
201 }
202 } else if(fNSegment[2] == 1) {
203 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
204 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
205 } else
206 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : "
207 << "invalid parameter (" << fNSegment[2] << ") "
208 << "in mesh element placement." << G4endl;
209
210 if(verboseLevel > 9) {
211 G4cout << fSize[0]/fNSegment[0] << ", "
212 << fSize[1]/fNSegment[1] << ", "
213 << fSize[2]/fNSegment[2] << G4endl;
214 G4cout << elementName << ": kZAxis, "
215 << fNSegment[2] << ", "
216 << 2.*fSize[2]/fNSegment[2] << G4endl;
217 }
218
219
220 // set the sensitive detector
221 fMeshElementLogical->SetSensitiveDetector(fMFD);
222
223
224 // vis. attributes
225 G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
226 visatt->SetVisibility(false);
227 layerLogical[0]->SetVisAttributes(visatt);
228 layerLogical[1]->SetVisAttributes(visatt);
229 visatt->SetVisibility(true);
230 fMeshElementLogical->SetVisAttributes(visatt);
231}
232
233
234void G4ScoringBox::List() const {
235 G4cout << "G4ScoringBox : " << fWorldName << " --- Shape: Box mesh" << G4endl;
236 G4cout << " Size (x, y, z): ("
237 << fSize[0]/cm << ", "
238 << fSize[1]/cm << ", "
239 << fSize[2]/cm << ") [cm]"
240 << G4endl;
241
242 G4VScoringMesh::List();
243}
244
245void G4ScoringBox::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
246
247 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
248 if(pVisManager) {
249
250 // cell vectors
251 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z]
252 std::vector<double> ez;
253 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.);
254 std::vector<std::vector<double> > eyz;
255 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez);
256 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz);
257
258 std::vector<std::vector<double> > xycell; // xycell[X][Y]
259 std::vector<double> ey;
260 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.);
261 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey);
262
263 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z]
264 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez);
265
266 std::vector<std::vector<double> > xzcell; // xzcell[X][Z]
267 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
268
269 // projections
270 G4int q[3];
271 std::map<G4int, G4double*>::iterator itr = map->begin();
272 for(; itr != map->end(); itr++) {
273 GetXYZ(itr->first, q);
274
275 xycell[q[0]][q[1]] += *(itr->second)/fDrawUnitValue;
276 yzcell[q[1]][q[2]] += *(itr->second)/fDrawUnitValue;
277 xzcell[q[0]][q[2]] += *(itr->second)/fDrawUnitValue;
278 }
279
280 // search max. & min. values in each slice
281 G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
282 G4double xymax = 0., yzmax = 0., xzmax = 0.;
283 for(int x = 0; x < fNSegment[0]; x++) {
284 for(int y = 0; y < fNSegment[1]; y++) {
285 if(xymin > xycell[x][y]) xymin = xycell[x][y];
286 if(xymax < xycell[x][y]) xymax = xycell[x][y];
287 }
288 for(int z = 0; z < fNSegment[2]; z++) {
289 if(xzmin > xzcell[x][z]) xzmin = xzcell[x][z];
290 if(xzmax < xzcell[x][z]) xzmax = xzcell[x][z];
291 }
292 }
293 for(int y = 0; y < fNSegment[1]; y++) {
294 for(int z = 0; z < fNSegment[2]; z++) {
295 if(yzmin > yzcell[y][z]) yzmin = yzcell[y][z];
296 if(yzmax < yzcell[y][z]) yzmax = yzcell[y][z];
297 }
298 }
299
300
301 G4VisAttributes att;
302 att.SetForceSolid(true);
303 att.SetForceAuxEdgeVisible(true);
304
305 G4Scale3D scale;
306 if(axflg/100==1) {
307 // xy plane
308 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xymin ,xymax); }
309 G4ThreeVector zhalf(0., 0., fSize[2]/fNSegment[2]*0.98);
310 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]*0.01);
311 for(int x = 0; x < fNSegment[0]; x++) {
312 for(int y = 0; y < fNSegment[1]; y++) {
313 G4ThreeVector pos(GetReplicaPosition(x, y, 0) - zhalf);
314 G4ThreeVector pos2(GetReplicaPosition(x, y, fNSegment[2]-1) + zhalf);
315 G4Transform3D trans, trans2;
316 if(fRotationMatrix) {
317 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
318 trans = G4Translate3D(fCenterPosition)*trans;
319 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
320 trans2 = G4Translate3D(fCenterPosition)*trans2;
321 } else {
322 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
323 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
324 }
325 G4double c[4];
326 colorMap->GetMapColor(xycell[x][y], c);
327 att.SetColour(c[0], c[1], c[2]);//, c[3]);
328 pVisManager->Draw(xyplate, att, trans);
329 pVisManager->Draw(xyplate, att, trans2);
330
331 }
332 }
333 }
334 axflg = axflg%100;
335 if(axflg/10==1) {
336 // yz plane
337 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(yzmin, yzmax); }
338 G4ThreeVector xhalf(fSize[0]/fNSegment[0]*0.98, 0., 0.);
339 G4Box yzplate("yz", fSize[0]/fNSegment[0]*0.01, fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
340 for(int y = 0; y < fNSegment[1]; y++) {
341 for(int z = 0; z < fNSegment[2]; z++) {
342 G4ThreeVector pos(GetReplicaPosition(0, y, z) - xhalf);
343 G4ThreeVector pos2(GetReplicaPosition(fNSegment[0]-1, y, z) + xhalf);
344 G4Transform3D trans, trans2;
345 if(fRotationMatrix) {
346 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
347 trans = G4Translate3D(fCenterPosition)*trans;
348 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
349 trans2 = G4Translate3D(fCenterPosition)*trans2;
350 } else {
351 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
352 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
353 }
354 G4double c[4];
355 colorMap->GetMapColor(yzcell[y][z], c);
356 att.SetColour(c[0], c[1], c[2]);//, c[3]);
357 pVisManager->Draw(yzplate, att, trans);
358 pVisManager->Draw(yzplate, att, trans2);
359
360 }
361 }
362 }
363 axflg = axflg%10;
364 if(axflg==1) {
365 // xz plane
366 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xzmin,xzmax); }
367 G4ThreeVector yhalf(0., fSize[1]/fNSegment[1]*0.98, 0.);
368 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1]*0.01, fSize[2]/fNSegment[2]);
369 for(int x = 0; x < fNSegment[0]; x++) {
370 for(int z = 0; z < fNSegment[2]; z++) {
371 G4ThreeVector pos(GetReplicaPosition(x, 0, z) - yhalf);
372 G4ThreeVector pos2(GetReplicaPosition(x, fNSegment[1]-1, z) + yhalf);
373 G4Transform3D trans, trans2;
374 if(fRotationMatrix) {
375 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
376 trans = G4Translate3D(fCenterPosition)*trans;
377 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
378 trans2 = G4Translate3D(fCenterPosition)*trans2;
379 } else {
380 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
381 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
382 }
383 G4double c[4];
384 colorMap->GetMapColor(xzcell[x][z], c);
385 att.SetColour(c[0], c[1], c[2]);//, c[3]);
386 pVisManager->Draw(xzplate, att, trans);
387 pVisManager->Draw(xzplate, att, trans2);
388
389 }
390 }
391 }
392 }
393 colorMap->SetPSUnit(fDrawUnit);
394 colorMap->SetPSName(fDrawPSName);
395 colorMap->DrawColorChart();
396}
397
398G4ThreeVector G4ScoringBox::GetReplicaPosition(G4int x, G4int y, G4int z) {
399
400 G4ThreeVector width(fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
401 G4ThreeVector pos(-fSize[0] + 2*(x+0.5)*width.x(),
402 -fSize[1] + 2*(y+0.5)*width.y(),
403 -fSize[2] + 2*(z+0.5)*width.z());
404
405 return pos;
406}
407
408void G4ScoringBox::GetXYZ(G4int index, G4int q[3]) const {
409
410 q[0] = index/(fNSegment[2]*fNSegment[1]);
411 q[1] = (index - q[0]*fNSegment[2]*fNSegment[1])/fNSegment[2];
412 q[2] = index - q[1]*fNSegment[2] - q[0]*fNSegment[2]*fNSegment[1];
413
414}
415
416G4int G4ScoringBox::GetIndex(G4int x, G4int y, G4int z) const {
417 return x + y*fNSegment[0] + z*fNSegment[0]*fNSegment[1];
418}
419
420void G4ScoringBox::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap,
421 G4int idxProj, G4int idxColumn)
422{
423 if(idxColumn<0 || idxColumn>=fNSegment[idxProj])
424 {
425 G4cerr << "ERROR : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[idxProj]-1 <<
426 "]. Method ignored." << G4endl;
427 return;
428 }
429 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
430 if(pVisManager) {
431
432 // cell vectors
433 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z]
434 std::vector<double> ez;
435 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.);
436 std::vector<std::vector<double> > eyz;
437 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez);
438 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz);
439
440 std::vector<std::vector<double> > xycell; // xycell[X][Y]
441 std::vector<double> ey;
442 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.);
443 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey);
444
445 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z]
446 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez);
447
448 std::vector<std::vector<double> > xzcell; // xzcell[X][Z]
449 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
450
451 // projections
452 G4int q[3];
453 std::map<G4int, G4double*>::iterator itr = map->begin();
454 for(; itr != map->end(); itr++) {
455 GetXYZ(itr->first, q);
456
457 if(idxProj == 0 && q[2] == idxColumn) { // xy plane
458 xycell[q[0]][q[1]] += *(itr->second)/fDrawUnitValue;
459 }
460 if(idxProj == 1 && q[0] == idxColumn) { // yz plane
461 yzcell[q[1]][q[2]] += *(itr->second)/fDrawUnitValue;
462 }
463 if(idxProj == 2 && q[1] == idxColumn) { // zx plane
464 xzcell[q[0]][q[2]] += *(itr->second)/fDrawUnitValue;
465 }
466 }
467
468 // search max. & min. values in each slice
469 G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
470 G4double xymax = 0., yzmax = 0., xzmax = 0.;
471 for(int x = 0; x < fNSegment[0]; x++) {
472 for(int y = 0; y < fNSegment[1]; y++) {
473 if(xymin > xycell[x][y]) xymin = xycell[x][y];
474 if(xymax < xycell[x][y]) xymax = xycell[x][y];
475 }
476 for(int z = 0; z < fNSegment[2]; z++) {
477 if(xzmin > xzcell[x][z]) xzmin = xzcell[x][z];
478 if(xzmax < xzcell[x][z]) xzmax = xzcell[x][z];
479 }
480 }
481 for(int y = 0; y < fNSegment[1]; y++) {
482 for(int z = 0; z < fNSegment[2]; z++) {
483 if(yzmin > yzcell[y][z]) yzmin = yzcell[y][z];
484 if(yzmax < yzcell[y][z]) yzmax = yzcell[y][z];
485 }
486 }
487
488
489 G4VisAttributes att;
490 att.SetForceSolid(true);
491 att.SetForceAuxEdgeVisible(true);
492
493
494 G4Scale3D scale;
495 // xy plane
496 if(idxProj == 0) {
497 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xymin,xymax); }
498 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
499 for(int x = 0; x < fNSegment[0]; x++) {
500 for(int y = 0; y < fNSegment[1]; y++) {
501 G4ThreeVector pos(GetReplicaPosition(x, y, idxColumn));
502 G4Transform3D trans;
503 if(fRotationMatrix) {
504 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
505 trans = G4Translate3D(fCenterPosition)*trans;
506 } else {
507 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
508 }
509 G4double c[4];
510 colorMap->GetMapColor(xycell[x][y], c);
511 att.SetColour(c[0], c[1], c[2]);//, c[3]);
512 pVisManager->Draw(xyplate, att, trans);
513
514 }
515 }
516 } else
517 // yz plane
518 if(idxProj == 1) {
519 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(yzmin,yzmax); }
520 G4Box yzplate("yz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
521 for(int y = 0; y < fNSegment[1]; y++) {
522 for(int z = 0; z < fNSegment[2]; z++) {
523 G4ThreeVector pos(GetReplicaPosition(idxColumn, y, z));
524 G4Transform3D trans;
525 if(fRotationMatrix) {
526 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
527 trans = G4Translate3D(fCenterPosition)*trans;
528 } else {
529 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
530 }
531 G4double c[4];
532 colorMap->GetMapColor(yzcell[y][z], c);
533 att.SetColour(c[0], c[1], c[2]);//, c[3]);
534 pVisManager->Draw(yzplate, att, trans);
535 }
536 }
537 } else
538 // xz plane
539 if(idxProj == 2) {
540 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xzmin,xzmax);}
541 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
542 for(int x = 0; x < fNSegment[0]; x++) {
543 for(int z = 0; z < fNSegment[2]; z++) {
544 G4ThreeVector pos(GetReplicaPosition(x, idxColumn, z));
545 G4Transform3D trans;
546 if(fRotationMatrix) {
547 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
548 trans = G4Translate3D(fCenterPosition)*trans;
549 } else {
550 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
551 }
552 G4double c[4];
553 colorMap->GetMapColor(xzcell[x][z], c);
554 att.SetColour(c[0], c[1], c[2]);//, c[3]);
555 pVisManager->Draw(xzplate, att, trans);
556 }
557 }
558 }
559 }
560
561 colorMap->SetPSUnit(fDrawUnit);
562 colorMap->SetPSName(fDrawPSName);
563 colorMap->DrawColorChart();
564}
565
566
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42
G4Translate3D
HepGeom::Translate3D G4Translate3D
Definition: G4Transform3D.hh:42
G4Rotate3D
HepGeom::Rotate3D G4Rotate3D
Definition: G4Transform3D.hh:37
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
boxMesh
@ boxMesh
Definition: G4VScoringMesh.hh:45
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4cout
G4DLLIMPORT std::ostream G4cout
G4Box
Definition: G4Box.hh:55
G4LogicalVolume::SetVisAttributes
void SetVisAttributes(const G4VisAttributes *pVA)
G4LogicalVolume::SetSensitiveDetector
void SetSensitiveDetector(G4VSensitiveDetector *pSDetector)
G4ScoringBox::Construct
void Construct(G4VPhysicalVolume *fWorldPhys)
Definition: G4ScoringBox.cc:66
G4ScoringBox::Draw
void Draw(std::map< G4int, G4double * > *map, G4VScoreColorMap *colorMap, G4int axflg=111)
Definition: G4ScoringBox.cc:245
G4ScoringBox::List
void List() const
Definition: G4ScoringBox.cc:234
G4ScoringBox::G4ScoringBox
G4ScoringBox(G4String wName)
Definition: G4ScoringBox.cc:52
G4ScoringBox::DrawColumn
void DrawColumn(std::map< G4int, G4double * > *map, G4VScoreColorMap *colorMap, G4int idxProj, G4int idxColumn)
Definition: G4ScoringBox.cc:420
G4ScoringManager::GetReplicaLevel
static G4int GetReplicaLevel()
Definition: G4ScoringManager.cc:80
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VScoreColorMap::DrawColorChart
virtual void DrawColorChart(G4int nPoint=5)
Definition: G4VScoreColorMap.cc:49
G4VScoreColorMap::IfFloatMinMax
G4bool IfFloatMinMax() const
Definition: G4VScoreColorMap.hh:51
G4VScoreColorMap::SetMinMax
void SetMinMax(G4double minVal, G4double maxVal)
Definition: G4VScoreColorMap.hh:53
G4VScoreColorMap::SetPSUnit
void SetPSUnit(G4String &unit)
Definition: G4VScoreColorMap.hh:77
G4VScoreColorMap::GetMapColor
virtual void GetMapColor(G4double val, G4double color[4])=0
G4VScoreColorMap::SetPSName
void SetPSName(G4String &psName)
Definition: G4VScoreColorMap.hh:78
G4VScoringMesh::fRotationMatrix
G4RotationMatrix * fRotationMatrix
Definition: G4VScoringMesh.hh:168
G4VScoringMesh::List
virtual void List() const
Definition: G4VScoringMesh.cc:233
G4VScoringMesh::fDrawUnitValue
G4double fDrawUnitValue
Definition: G4VScoringMesh.hh:180
G4VScoringMesh::fDrawPSName
G4String fDrawPSName
Definition: G4VScoringMesh.hh:181
G4VScoringMesh::fMFD
G4MultiFunctionalDetector * fMFD
Definition: G4VScoringMesh.hh:172
G4VScoringMesh::fDivisionAxisNames
G4String fDivisionAxisNames[3]
Definition: G4VScoringMesh.hh:183
G4VScoringMesh::fSize
G4double fSize[3]
Definition: G4VScoringMesh.hh:166
G4VScoringMesh::fCenterPosition
G4ThreeVector fCenterPosition
Definition: G4VScoringMesh.hh:167
G4VVisManager::GetConcreteInstance
static G4VVisManager * GetConcreteInstance()
Definition: G4VVisManager.cc:39
G4VVisManager::Draw
virtual void Draw(const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())=0
G4VisAttributes::SetForceAuxEdgeVisible
void SetForceAuxEdgeVisible(G4bool)
G4VisAttributes::SetVisibility
void SetVisibility(G4bool)
G4VisAttributes::SetColour
void SetColour(const G4Colour &)
G4VisAttributes::SetForceSolid
void SetForceSolid(G4bool)
HepGeom::Transform3D::inverse
Transform3D inverse() const
Definition: Transform3D.cc:142
kYAxis
@ kYAxis
Definition: geomdefs.hh:54
kXAxis
@ kXAxis
Definition: geomdefs.hh:54
kZAxis
@ kZAxis
Definition: geomdefs.hh:54
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83