Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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