Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4ScoringCylinder.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 "G4ScoringCylinder.hh"
31
32#include "G4PhysicalConstants.hh"
33#include "G4SystemOfUnits.hh"
34#include "G4VPhysicalVolume.hh"
35#include "G4Tubs.hh"
36#include "G4LogicalVolume.hh"
37#include "G4VPhysicalVolume.hh"
38#include "G4PVPlacement.hh"
39#include "G4PVReplica.hh"
40#include "G4PVDivision.hh"
41#include "G4VisAttributes.hh"
42#include "G4VVisManager.hh"
43#include "G4VScoreColorMap.hh"
44
45#include "G4SDManager.hh"
46#include "G4MultiFunctionalDetector.hh"
47#include "G4SDParticleFilter.hh"
48#include "G4VPrimitiveScorer.hh"
49#include "G4PSEnergyDeposit.hh"
50#include "G4PSTrackLength.hh"
51#include "G4PSNofStep.hh"
52#include "G4ScoringManager.hh"
53
54
55G4ScoringCylinder::G4ScoringCylinder(G4String wName)
56 :G4VScoringMesh(wName), fMeshElementLogical(0)
57{
58 fShape = cylinderMesh;
59
60 fDivisionAxisNames[0] = "Z";
61 fDivisionAxisNames[1] = "PHI";
62 fDivisionAxisNames[2] = "R";
63}
64
65G4ScoringCylinder::~G4ScoringCylinder()
66{;}
67
68void G4ScoringCylinder::Construct(G4VPhysicalVolume* fWorldPhys)
69{
70 if(fConstructed) {
71
72 if(verboseLevel > 0)
73 G4cout << fWorldPhys->GetName() << " --- All quantities are reset." << G4endl;
74 ResetScore();
75
76 } else {
77 fConstructed = true;
78 SetupGeometry(fWorldPhys);
79 }
80}
81
82
83
84void G4ScoringCylinder::SetupGeometry(G4VPhysicalVolume * fWorldPhys) {
85
86 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::SetupGeometry() ..." << G4endl;
87
88 // World
89 G4VPhysicalVolume * scoringWorld = fWorldPhys;
90 G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume();
91
92 // Scoring Mesh
93 if(verboseLevel > 9) G4cout << fWorldName << G4endl;
94 G4String tubsName = fWorldName+"_mesh";
95
96 if(verboseLevel > 9) G4cout << "R max., Dz =: " << fSize[0] << ", " << fSize[1] << G4endl;
97 G4VSolid * tubsSolid = new G4Tubs(tubsName+"0", // name
98 0., // R min
99 fSize[0], // R max
100 fSize[1], // Dz
101 0., // starting phi
102 twopi*rad); // segment phi
103 G4LogicalVolume * tubsLogical = new G4LogicalVolume(tubsSolid, 0, tubsName);
104 new G4PVPlacement(fRotationMatrix, fCenterPosition,
105 tubsLogical, tubsName+"0", worldLogical, false, 0);
106
107 if(verboseLevel > 9) G4cout << " # of segments : r, phi, z =: "
108 << fNSegment[IR] << ", " << fNSegment[IPHI] << ", " << fNSegment[IZ] << G4endl;
109
110 G4String layerName[2] = {tubsName + "1", tubsName + "2"};
111 G4VSolid * layerSolid[2];
112 G4LogicalVolume * layerLogical[2];
113
114 //-- fisrt nested layer (replicated along z direction)
115 if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
116 layerSolid[0] = new G4Tubs(layerName[0], // name
117 0., // inner radius
118 fSize[0], // outer radius
119 fSize[1]/fNSegment[IZ], // half len. in z
120 0., // starting phi angle
121 twopi*rad); // delta angle of the segment
122 layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
123 if(fNSegment[IZ] > 1) {
124 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction" << G4endl;
125 if(G4ScoringManager::GetReplicaLevel()>0) {
126 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
127 new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 2.*fSize[1]/fNSegment[IZ]);
128 } else {
129 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
130 new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 0.);
131 }
132 } else if(fNSegment[IZ] == 1) {
133 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
134 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], tubsLogical, false, 0);
135 } else {
136 G4cerr << "G4ScoringCylinder::SetupGeometry() : invalid parameter ("
137 << fNSegment[IZ] << ") "
138 << "in placement of the first nested layer." << G4endl;
139 }
140
141 // second nested layer (replicated along phi direction)
142 if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
143 layerSolid[1] = new G4Tubs(layerName[1],
144 0.,
145 fSize[0],
146 fSize[1]/fNSegment[IZ],
147 0.,
148 twopi*rad/fNSegment[IPHI]);
149 layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
150 if(fNSegment[IPHI] > 1) {
151 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction" << G4endl;
152 if(G4ScoringManager::GetReplicaLevel()>1) {
153 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
154 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kPhi,
155 fNSegment[IPHI], twopi*rad/fNSegment[IPHI]);
156 } else {
157 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
158 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kPhi, fNSegment[IPHI], 0.);
159 }
160 } else if(fNSegment[IPHI] == 1) {
161 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
162 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
163 } else
164 G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
165 << fNSegment[IPHI] << ") "
166 << "in placement of the second nested layer." << G4endl;
167
168 // mesh elements
169 if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
170 G4String elementName = tubsName +"3";
171 G4VSolid * elementSolid = new G4Tubs(elementName,
172 0.,
173 fSize[0]/fNSegment[IR],
174 fSize[1]/fNSegment[IZ],
175 0.,
176 twopi*rad/fNSegment[IPHI]);
177 fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
178 if(fNSegment[IR] > 1) {
179
180 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction" << G4endl;
181
182 if(G4ScoringManager::GetReplicaLevel()>2) {
183 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
184 new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kRho,
185 fNSegment[IR], fSize[0]/fNSegment[IR]);
186 } else {
187 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
188 new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kRho, fNSegment[IR], 0.);
189 }
190 } else if(fNSegment[IR] == 1) {
191 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
192 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
193 } else {
194 G4cerr << "G4ScoringCylinder::SetupGeometry() : "
195 << "invalid parameter (" << fNSegment[IR] << ") "
196 << "in mesh element placement." << G4endl;
197 }
198
199 // set the sensitive detector
200 fMeshElementLogical->SetSensitiveDetector(fMFD);
201
202
203 // vis. attributes
204 G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
205 visatt->SetVisibility(true);
206 layerLogical[0]->SetVisAttributes(visatt);
207 layerLogical[1]->SetVisAttributes(visatt);
208 visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.01));
209 //visatt->SetForceSolid(true);
210 fMeshElementLogical->SetVisAttributes(visatt);
211}
212
213void G4ScoringCylinder::List() const {
214 G4cout << "G4ScoringCylinder : " << fWorldName << " --- Shape: Cylindrical mesh" << G4endl;
215
216 G4cout << " Size (R, Dz): ("
217 << fSize[0]/cm << ", "
218 << fSize[1]/cm << ") [cm]"
219 << G4endl;
220
221 G4VScoringMesh::List();
222}
223
224
225void G4ScoringCylinder::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
226
227 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
228 if(pVisManager) {
229
230 // cell vectors
231 std::vector<double> ephi;
232 for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
233 //-
234 std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
235 for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
236 //-
237 std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
238 for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
239
240 // projections
241 G4int q[3];
242 std::map<G4int, G4double*>::iterator itr = map->begin();
243 for(; itr != map->end(); itr++) {
244 if(itr->first < 0) {
245 G4cout << itr->first << G4endl;
246 continue;
247 }
248 GetRZPhi(itr->first, q);
249
250 zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
251 rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
252 }
253
254 // search min./max. values
255 G4double zphimin = DBL_MAX, rphimin = DBL_MAX;
256 G4double zphimax = 0., rphimax = 0.;
257 for(int iphi = 0; iphi < fNSegment[IPHI]; iphi++) {
258 for(int iz = 0; iz < fNSegment[IZ]; iz++) {
259 if(zphimin > zphicell[iz][iphi]) zphimin = zphicell[iz][iphi];
260 if(zphimax < zphicell[iz][iphi]) zphimax = zphicell[iz][iphi];
261 }
262 for(int ir = 0; ir < fNSegment[IR]; ir++) {
263 if(rphimin > rphicell[ir][iphi]) rphimin = rphicell[ir][iphi];
264 if(rphimax < rphicell[ir][iphi]) rphimax = rphicell[ir][iphi];
265 }
266 }
267
268 G4VisAttributes att;
269 att.SetForceSolid(true);
270 att.SetForceAuxEdgeVisible(true);
271
272
273 G4Scale3D scale;
274 if(axflg/100==1) {
275 // rz plane
276 }
277 axflg = axflg%100;
278 if(axflg/10==1) {
279 // z-phi plane
280 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin, zphimax); }
281
282 G4double zhalf = fSize[1]/fNSegment[IZ];
283 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
284 for(int z = 0; z < fNSegment[IZ]; z++) {
285 //-
286 G4double angle = twopi/fNSegment[IPHI]*phi;
287 G4double dphi = twopi/fNSegment[IPHI];
288 G4Tubs cylinder("z-phi", // name
289 fSize[0]*0.99, fSize[0], // inner radius, outer radius
290 zhalf, // half length in z
291 angle, dphi*0.99999); // starting phi angle, delta angle
292 //-
293 G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
294 G4Transform3D trans;
295 if(fRotationMatrix) {
296 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
297 trans = G4Translate3D(fCenterPosition)*trans;
298 } else {
299 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
300 }
301 G4double c[4];
302 colorMap->GetMapColor(zphicell[z][phi], c);
303 att.SetColour(c[0], c[1], c[2]);//, c[3]);
304 //-
305 pVisManager->Draw(cylinder, att, trans);
306 }
307 }
308 }
309 axflg = axflg%10;
310 if(axflg==1) {
311 // r-phi plane
312 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin, rphimax); }
313
314 G4double rsize = fSize[0]/fNSegment[IR];
315 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
316 for(int r = 0; r < fNSegment[IR]; r++) {
317
318 G4double rs[2] = {rsize*r, rsize*(r+1)};
319 G4double angle = twopi/fNSegment[IPHI]*phi;
320 G4double dphi = twopi/fNSegment[IPHI];
321 G4Tubs cylinder("z-phi", rs[0], rs[1], 0.001,
322 angle, dphi*0.99999);
323 /*
324 G4cout << ">>>> "
325 << rs[0] << " - " << rs[1] << " : "
326 << angle << " - " << angle + dphi
327 << G4endl;
328 */
329
330 G4ThreeVector zposn(0., 0., -fSize[1]);
331 G4ThreeVector zposp(0., 0., fSize[1]);
332 G4Transform3D transn, transp;
333 if(fRotationMatrix) {
334 transn = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposn);
335 transn = G4Translate3D(fCenterPosition)*transn;
336 transp = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposp);
337 transp = G4Translate3D(fCenterPosition)*transp;
338 } else {
339 transn = G4Translate3D(zposn)*G4Translate3D(fCenterPosition);
340 transp = G4Translate3D(zposp)*G4Translate3D(fCenterPosition);
341 }
342 G4double c[4];
343 colorMap->GetMapColor(rphicell[r][phi], c);
344 att.SetColour(c[0], c[1], c[2]);//, c[3]);
345 /*
346 G4cout << " " << c[0] << ", "
347 << c[1] << ", " << c[2] << G4endl;
348 */
349 pVisManager->Draw(cylinder, att, transn);
350 pVisManager->Draw(cylinder, att, transp);
351 }
352 }
353 }
354
355 colorMap->SetPSUnit(fDrawUnit);
356 colorMap->SetPSName(fDrawPSName);
357 colorMap->DrawColorChart();
358
359 }
360}
361
362void G4ScoringCylinder::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap,
363 G4int idxProj, G4int idxColumn)
364{
365 G4int projAxis = 0;
366 switch(idxProj) {
367 case 0:
368 projAxis = IR;
369 break;
370 case 1:
371 projAxis = IZ;
372 break;
373 case 2:
374 projAxis = IPHI;
375 break;
376 }
377
378 if(idxColumn<0 || idxColumn>=fNSegment[projAxis])
379 {
380 G4cerr << "Warning : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[projAxis]-1 <<
381 "]. Method ignored." << G4endl;
382 return;
383 }
384 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
385 if(pVisManager) {
386
387 // cell vectors
388 std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
389 std::vector<double> ephi;
390 for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
391 std::vector<std::vector<double> > ezphi;
392 for(int z = 0; z < fNSegment[IZ]; z++) ezphi.push_back(ephi);
393 for(int r = 0; r < fNSegment[IR]; r++) cell.push_back(ezphi);
394
395 std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
396 std::vector<double> ez;
397 for(int z = 0; z < fNSegment[IZ]; z++) ez.push_back(0.);
398 for(int r = 0; r < fNSegment[IR]; r++) rzcell.push_back(ez);
399
400 std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
401 for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
402
403 std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
404 for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
405
406 // projections
407 G4int q[3];
408 std::map<G4int, G4double*>::iterator itr = map->begin();
409 for(; itr != map->end(); itr++) {
410 if(itr->first < 0) {
411 G4cout << itr->first << G4endl;
412 continue;
413 }
414 GetRZPhi(itr->first, q);
415
416 if(projAxis == IR && q[IR] == idxColumn) { // zphi plane
417 zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
418 }
419 if(projAxis == IZ && q[IZ] == idxColumn) { // rphi plane
420 rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
421 }
422 if(projAxis == IPHI && q[IPHI] == idxColumn) { // rz plane
423 rzcell[q[IR]][q[IZ]] += *(itr->second)/fDrawUnitValue;
424 }
425 }
426
427 // search min./max. values
428 G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
429 G4double rzmax = 0., zphimax = 0., rphimax = 0.;
430 for(int r = 0; r < fNSegment[IR]; r++) {
431 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
432 if(rphimin > rphicell[r][phi]) rphimin = rphicell[r][phi];
433 if(rphimax < rphicell[r][phi]) rphimax = rphicell[r][phi];
434 }
435 for(int z = 0; z < fNSegment[IZ]; z++) {
436 if(rzmin > rzcell[r][z]) rzmin = rzcell[r][z];
437 if(rzmax < rzcell[r][z]) rzmax = rzcell[r][z];
438 }
439 }
440 for(int z = 0; z < fNSegment[IZ]; z++) {
441 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
442 if(zphimin > zphicell[z][phi]) zphimin = zphicell[z][phi];
443 if(zphimax < zphicell[z][phi]) zphimax = zphicell[z][phi];
444 }
445 }
446
447
448 G4VisAttributes att;
449 att.SetForceSolid(true);
450 att.SetForceAuxEdgeVisible(true);
451
452
453 G4Scale3D scale;
454 // z-phi plane
455 if(projAxis == IR) {
456 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin,zphimax); }
457
458 G4double zhalf = fSize[1]/fNSegment[IZ];
459 G4double rsize[2] = {fSize[0]/fNSegment[IR]*idxColumn,
460 fSize[0]/fNSegment[IR]*(idxColumn+1)};
461 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
462 for(int z = 0; z < fNSegment[IZ]; z++) {
463
464 G4double angle = twopi/fNSegment[IPHI]*phi*radian;
465 G4double dphi = twopi/fNSegment[IPHI]*radian;
466 G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf,
467 angle, dphi*0.99999);
468
469 G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
470 G4Transform3D trans;
471 if(fRotationMatrix) {
472 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
473 trans = G4Translate3D(fCenterPosition)*trans;
474 } else {
475 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
476 }
477 G4double c[4];
478 colorMap->GetMapColor(zphicell[z][phi], c);
479 att.SetColour(c[0], c[1], c[2]);//, c[3]);
480 pVisManager->Draw(cylinder, att, trans);
481 }
482 }
483
484 // r-phi plane
485 } else if(projAxis == IZ) {
486 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin,rphimax); }
487
488 G4double rsize = fSize[0]/fNSegment[IR];
489 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
490 for(int r = 0; r < fNSegment[IR]; r++) {
491
492 G4double rs[2] = {rsize*r, rsize*(r+1)};
493 G4double angle = twopi/fNSegment[IPHI]*phi*radian;
494 G4double dz = fSize[1]/fNSegment[IZ];
495 G4double dphi = twopi/fNSegment[IPHI]*radian;
496 G4Tubs cylinder("r-phi", rs[0], rs[1], dz,
497 angle, dphi*0.99999);
498 G4ThreeVector zpos(0., 0.,
499 -fSize[1]+fSize[1]/fNSegment[IZ]*(idxColumn*2+1));
500 G4Transform3D trans;
501 if(fRotationMatrix) {
502 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
503 trans = G4Translate3D(fCenterPosition)*trans;
504 } else {
505 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
506 }
507 G4double c[4];
508 colorMap->GetMapColor(rphicell[r][phi], c);
509 att.SetColour(c[0], c[1], c[2]);//, c[3]);
510 pVisManager->Draw(cylinder, att, trans);
511 }
512 }
513
514 // r-z plane
515 } else if(projAxis == IPHI) {
516 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rzmin,rzmax); }
517
518 G4double rsize = fSize[0]/fNSegment[IR];
519 G4double zhalf = fSize[1]/fNSegment[IZ];
520 G4double angle = twopi/fNSegment[IPHI]*idxColumn*radian;
521 G4double dphi = twopi/fNSegment[IPHI]*radian;
522 for(int z = 0; z < fNSegment[IZ]; z++) {
523 for(int r = 0; r < fNSegment[IR]; r++) {
524
525 G4double rs[2] = {rsize*r, rsize*(r+1)};
526 G4Tubs cylinder("z-phi", rs[0], rs[1], zhalf,
527 angle, dphi);
528
529 G4ThreeVector zpos(0., 0.,
530 -fSize[1]+fSize[1]/fNSegment[IZ]*(2.*z+1));
531 G4Transform3D trans;
532 if(fRotationMatrix) {
533 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
534 trans = G4Translate3D(fCenterPosition)*trans;
535 } else {
536 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
537 }
538 G4double c[4];
539 colorMap->GetMapColor(rzcell[r][z], c);
540 att.SetColour(c[0], c[1], c[2]);//, c[3]);
541 pVisManager->Draw(cylinder, att, trans);
542 }
543 }
544 }
545 }
546
547 colorMap->SetPSUnit(fDrawUnit);
548 colorMap->SetPSName(fDrawPSName);
549 colorMap->DrawColorChart();
550
551}
552
553void G4ScoringCylinder::GetRZPhi(G4int index, G4int q[3]) const {
554 // index = k + j * k-size + i * jk-plane-size
555
556 // nested : z -> phi -> r
557 G4int i = IZ;
558 G4int j = IPHI;
559 G4int k = IR;
560 G4int jk = fNSegment[j]*fNSegment[k];
561 q[i] = index/jk;
562 q[j] = (index - q[i]*jk)/fNSegment[k];
563 q[k] = index - q[j]*fNSegment[k] - q[i]*jk;
564}
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
cylinderMesh
@ cylinderMesh
Definition: G4VScoringMesh.hh:45
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4cout
G4DLLIMPORT std::ostream G4cout
G4LogicalVolume::SetVisAttributes
void SetVisAttributes(const G4VisAttributes *pVA)
G4LogicalVolume::SetSensitiveDetector
void SetSensitiveDetector(G4VSensitiveDetector *pSDetector)
G4ScoringCylinder::GetRZPhi
void GetRZPhi(G4int index, G4int q[3]) const
Definition: G4ScoringCylinder.cc:553
G4ScoringCylinder::DrawColumn
virtual void DrawColumn(std::map< G4int, G4double * > *map, G4VScoreColorMap *colorMap, G4int idxProj, G4int idxColumn)
Definition: G4ScoringCylinder.cc:362
G4ScoringCylinder::Construct
virtual void Construct(G4VPhysicalVolume *fWorldPhys)
Definition: G4ScoringCylinder.cc:68
G4ScoringCylinder::Draw
virtual void Draw(std::map< G4int, G4double * > *map, G4VScoreColorMap *colorMap, G4int axflg=111)
Definition: G4ScoringCylinder.cc:225
G4ScoringCylinder::List
virtual void List() const
Definition: G4ScoringCylinder.cc:213
G4ScoringCylinder::G4ScoringCylinder
G4ScoringCylinder(G4String wName)
Definition: G4ScoringCylinder.cc:55
G4ScoringManager::GetReplicaLevel
static G4int GetReplicaLevel()
Definition: G4ScoringManager.cc:80
G4Tubs
Definition: G4Tubs.hh:77
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
kPhi
@ kPhi
Definition: geomdefs.hh:54
kZAxis
@ kZAxis
Definition: geomdefs.hh:54
kRho
@ kRho
Definition: geomdefs.hh:54
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83