source: trunk/source/digits_hits/utils/src/G4ScoringCylinder.cc@ 1347

Last change on this file since 1347 was 1340, checked in by garnier, 15 years ago

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