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

Last change on this file since 1202 was 998, checked in by garnier, 15 years ago

fichiers oublies
File size: 20.0 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.6 2008/08/29 02:50:05 akimura Exp $
28// GEANT4 tag $Name: geant4-09-02-ref-02 $
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 "G4PVParameterised.hh"
41#include "G4VisAttributes.hh"
42//#include "G4ScoringCylinderParameterisation.hh"
43#include "G4VVisManager.hh"
44#include "G4VScoreColorMap.hh"
45
46#include "G4SDManager.hh"
47#include "G4MultiFunctionalDetector.hh"
48#include "G4SDParticleFilter.hh"
49#include "G4VPrimitiveScorer.hh"
50#include "G4PSEnergyDeposit.hh"
51#include "G4PSTrackLength.hh"
52#include "G4PSNofStep.hh"
53#include "G4ScoringManager.hh"
54
55
56G4ScoringCylinder::G4ScoringCylinder(G4String wName)
57  :G4VScoringMesh(wName), fSegmentDirection(-1), 
58   fMeshElementLogical(0)
59{
60  fShape = cylinderMesh;
61}
62
63G4ScoringCylinder::~G4ScoringCylinder()
64{
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;
94
95  if(verboseLevel > 9) G4cout << 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
107  G4String layerName[2] = {tubsName + "1",  tubsName + "2"};
108  G4VSolid * layerSolid[2]; 
109  G4LogicalVolume * layerLogical[2];
110
111  //-- fisrt nested layer (replicated along r direction)
112  if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
113  layerSolid[0] = new G4Tubs(layerName[0],
114                             0.,
115                             fSize[0]/fNSegment[0],
116                             fSize[1],
117                             0., twopi*rad);
118  layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
119  if(fNSegment[0] > 1) {
120    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction" << G4endl;
121    G4double r = fSize[0]/fNSegment[0];
122    //if(G4ScoringManager::GetReplicaLevel()>0) {
123    if(false) { // always use G4PVDivision
124      if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
125      new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kRho,
126                      fNSegment[0], r, 0.);
127    } else {
128      if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
129      new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kRho,
130                       fNSegment[0], 0.);
131    }
132  } else if(fNSegment[0] == 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[0] << ") "
138           << "in placement of the first nested layer." << G4endl;
139  }
140
141  if(verboseLevel > 9) {
142    G4cout << fSize[0] << ", "
143           << fSize[1] 
144           << G4endl;
145    G4cout << layerName[0] << ": kRho, "
146           << fNSegment[0] << ", "
147           << fSize[0]/fNSegment[0] << G4endl;
148  }
149
150  // second nested layer (replicated along z direction)
151  if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
152  layerSolid[1] = new G4Tubs(layerName[1],
153                             0.,
154                             fSize[0],///fNSegment[0],
155                             fSize[1]/fNSegment[1],
156                             0., twopi*rad);
157  layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
158  if(fNSegment[1] > 1)  {
159    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction" << G4endl;
160    G4double width = fSize[1]/fNSegment[1]*2.;
161    //if(G4ScoringManager::GetReplicaLevel()>1) {
162    if(false) { // always use G4PVDivision
163      if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
164      new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kZAxis,
165                      fNSegment[1], width);
166    } else {
167      if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
168      new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kZAxis,
169                       fNSegment[1], 0.);
170    }
171  } else if(fNSegment[1] == 1) {
172    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
173    new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
174  } else
175    G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
176           << fNSegment[1] << ") "
177           << "in placement of the second nested layer." << G4endl;
178
179  if(verboseLevel > 9) {
180    G4cout << fSize[0]/fNSegment[0] << ", "
181           << fSize[1]/fNSegment[1] << G4endl;
182    G4cout << layerName[1] << ": kZAxis, "
183           << fNSegment[1] << ", "
184           << fSize[1]/fNSegment[1] << G4endl;
185  }
186
187
188  // mesh elements
189  if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
190  G4String elementName = tubsName +"3";
191  G4VSolid * elementSolid = new G4Tubs(elementName,
192                                       0.,
193                                       fSize[0],//fNSegment[0],
194                                       fSize[1]/fNSegment[1],
195                                       0., twopi*rad/fNSegment[2]);
196  fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
197  if(fNSegment[2] > 1) {
198
199    /*
200    if(fSegmentPositions.size() > 0) {
201      G4double motherDims[3] ={fSize[0]/fsegParam[2][0],
202                               fSize[1]/fsegParam[2][1],
203                               fSize[2]/fsegParam[2][2]};
204      G4int nelement = fSegmentPositions.size() + 1;
205      //G4ScoringCylinderParameterisation * param =
206      G4VPVParameterisation * param =
207        new G4ScoringCylinderParameterisation(axis[2], motherDims, fSegmentPositions);
208      new G4PVParameterised(elementName,
209                            fMeshElementLogical,
210                            layerLogical[1],
211                            axis[2],
212                            nelement,
213                            param);
214    } else {
215    */
216    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction" << G4endl;
217
218    G4double angle = twopi*rad/fNSegment[2];
219    //if(G4ScoringManager::GetReplicaLevel()>2) {
220    if(false) { // always use G4PVDivision
221      if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
222      new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kPhi,
223                        fNSegment[2], angle, 0.);
224    } else {
225      if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
226      new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kPhi,
227                       fNSegment[2], 0.);
228    }
229    //}
230  } else if(fNSegment[2] == 1) {
231    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
232    new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
233  } else {
234    G4cerr << "G4ScoringCylinder::SetupGeometry() : "
235           << "invalid parameter (" << fNSegment[2] << ") "
236           << "in mesh element placement." << G4endl;
237  }
238
239  if(verboseLevel > 9) {
240    G4cout << fSize[0]/fNSegment[0] << ", "
241           << fSize[1]/fNSegment[1] << G4endl;
242    G4cout << elementName << ": kPhi, "
243           << fNSegment[2] << G4endl;
244  }
245
246  // set the sensitive detector
247  fMeshElementLogical->SetSensitiveDetector(fMFD);
248 
249
250  // vis. attributes
251  G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.1));
252  visatt->SetVisibility(true);
253  //layerLogical[0]->SetVisAttributes(visatt);
254  //layerLogical[1]->SetVisAttributes(visatt);
255  visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.01));
256  //visatt->SetForceSolid(true);
257  fMeshElementLogical->SetVisAttributes(visatt);
258}
259
260void G4ScoringCylinder::List() const {
261  G4cout << "G4ScoringCylinder : " << fWorldName << " --- Shape: Cylindrical mesh" << G4endl;
262
263  G4cout << " Size (R, Dz): ("
264         << fSize[0]/cm << ", "
265         << fSize[1]/cm << ") [cm]"
266         << G4endl;
267
268  G4VScoringMesh::List();
269}
270
271
272void G4ScoringCylinder::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
273
274
275  G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
276  if(pVisManager) {
277   
278    // cell vectors
279    std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
280    std::vector<double> ephi;
281    for(int phi = 0; phi < fNSegment[2]; phi++) ephi.push_back(0.);
282    std::vector<std::vector<double> > ezphi;
283    for(int z = 0; z < fNSegment[1]; z++) ezphi.push_back(ephi);
284    for(int r = 0; r < fNSegment[0]; r++) cell.push_back(ezphi);
285
286    std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
287    std::vector<double> ez;
288    for(int z = 0; z < fNSegment[1]; z++) ez.push_back(0.);
289    for(int r = 0; r < fNSegment[0]; r++) rzcell.push_back(ez);
290
291    std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
292    for(int z = 0; z < fNSegment[1]; z++) zphicell.push_back(ephi);
293
294    std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
295    for(int r = 0; r < fNSegment[0]; r++) rphicell.push_back(ephi);
296
297    // search max. values
298    G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
299    G4double rzmax = 0., zphimax = 0., rphimax = 0.;
300    G4int q[3];
301    std::map<G4int, G4double*>::iterator itr = map->begin();
302    for(; itr != map->end(); itr++) {
303      GetRZPhi(itr->first, q);
304
305      rzcell[q[0]][q[1]] += *(itr->second);
306      if(rzmin > rzcell[q[0]][q[1]]) rzmin = rzcell[q[0]][q[1]];
307      if(rzmax < rzcell[q[0]][q[1]]) rzmax = rzcell[q[0]][q[1]];
308
309      zphicell[q[1]][q[2]] += *(itr->second);
310      if(zphimin > zphicell[q[1]][q[2]]) zphimin = zphicell[q[1]][q[2]];
311      if(zphimax < zphicell[q[1]][q[2]]) zphimax = zphicell[q[1]][q[2]];
312
313      rphicell[q[0]][q[2]] += *(itr->second);
314      if(rphimin > rphicell[q[0]][q[2]]) rphimin = rphicell[q[0]][q[2]];
315      if(rphimax < rphicell[q[0]][q[2]]) rphimax = rphicell[q[0]][q[2]];
316    } 
317   
318    G4VisAttributes att;
319    att.SetForceSolid(true);
320    att.SetForceAuxEdgeVisible(true);
321
322
323    G4Scale3D scale;
324    if(axflg/100==1) {
325      // rz plane
326    }
327    axflg = axflg%100;
328    if(axflg/10==1) {
329      // z-phi plane
330      if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin, zphimax); }
331
332      G4double zhalf = fSize[1]/fNSegment[1];
333      for(int phi = 0; phi < fNSegment[2]; phi++) {
334        for(int z = 0; z < fNSegment[1]; z++) {
335
336          G4double angle = twopi/fNSegment[2]*phi;
337          G4double dphi = twopi/fNSegment[2];
338          G4Tubs cylinder("z-phi", fSize[0]*0.99, fSize[0], zhalf,
339                          angle, dphi*0.99999);
340          /*
341          G4cout << ">>>> "
342                 << fSize[1]/fNSegment[1]/2. << " : "
343                 << angle << " - " << angle + dphi
344                 << G4endl;
345          */
346
347          G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[1]*(1 + 2.*z));
348          G4Transform3D trans;
349          if(fRotationMatrix) {
350            trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
351            trans = G4Translate3D(fCenterPosition)*trans;
352          } else {
353            trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
354          }
355          G4double c[4];
356          colorMap->GetMapColor(zphicell[z][phi], c);
357          att.SetColour(c[0], c[1], c[2]);//, c[3]);
358          /*
359          G4cout << "   " << c[0] << ", "
360                 << c[1] << ", " << c[2] << G4endl;
361          */
362          pVisManager->Draw(cylinder, att, trans);
363        }
364      }
365    }
366    axflg = axflg%10;
367    if(axflg==1) {
368      // r-phi plane
369      if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin, rphimax); }
370
371      G4double rsize = fSize[0]/fNSegment[0];
372      for(int phi = 0; phi < fNSegment[2]; phi++) {
373        for(int r = 0; r < fNSegment[0]; r++) {
374
375          G4double rs[2] = {rsize*r, rsize*(r+1)};
376          G4double angle = twopi/fNSegment[2]*phi;
377          G4double dphi = twopi/fNSegment[2];
378          G4Tubs cylinder("z-phi", rs[0], rs[1], 0.001,
379                          angle, dphi*0.99999);
380          /*
381          G4cout << ">>>> "
382                 << rs[0] << " - " << rs[1] << " : "
383                 << angle << " - " << angle + dphi
384                 << G4endl;
385          */
386
387          G4ThreeVector zposn(0., 0., -fSize[1]);
388          G4ThreeVector zposp(0., 0.,  fSize[1]);
389          G4Transform3D transn, transp;
390          if(fRotationMatrix) {
391            transn = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposn);
392            transn = G4Translate3D(fCenterPosition)*transn;
393            transp = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposp);
394            transp = G4Translate3D(fCenterPosition)*transp;
395          } else {
396            transn = G4Translate3D(zposn)*G4Translate3D(fCenterPosition);
397            transp = G4Translate3D(zposp)*G4Translate3D(fCenterPosition);
398          }
399          G4double c[4];
400          colorMap->GetMapColor(rphicell[r][phi], c);
401          att.SetColour(c[0], c[1], c[2]);//, c[3]);
402          /*
403          G4cout << "   " << c[0] << ", "
404                 << c[1] << ", " << c[2] << G4endl;
405          */
406          pVisManager->Draw(cylinder, att, transn);
407          pVisManager->Draw(cylinder, att, transp);
408        }
409      }
410    }
411    colorMap->DrawColorChart();
412  }
413}
414
415void G4ScoringCylinder::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, 
416                                   G4int idxProj, G4int idxColumn) 
417{
418
419  if(idxColumn<0 || idxColumn>=fNSegment[idxProj])
420  {
421    G4cerr << "ERROR : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[idxProj]-1 <<
422    "]. Method ignored." << G4endl;
423    return;
424  }
425  G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
426  if(pVisManager) {
427   
428    // cell vectors
429    std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
430    std::vector<double> ephi;
431    for(int phi = 0; phi < fNSegment[2]; phi++) ephi.push_back(0.);
432    std::vector<std::vector<double> > ezphi;
433    for(int z = 0; z < fNSegment[1]; z++) ezphi.push_back(ephi);
434    for(int r = 0; r < fNSegment[0]; r++) cell.push_back(ezphi);
435
436    std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
437    std::vector<double> ez;
438    for(int z = 0; z < fNSegment[1]; z++) ez.push_back(0.);
439    for(int r = 0; r < fNSegment[0]; r++) rzcell.push_back(ez);
440
441    std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
442    for(int z = 0; z < fNSegment[1]; z++) zphicell.push_back(ephi);
443
444    std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
445    for(int r = 0; r < fNSegment[0]; r++) rphicell.push_back(ephi);
446
447    // search max. values
448    G4double rzmax = 0., zphimax = 0., rphimax = 0.;
449    G4int q[3];
450    std::map<G4int, G4double*>::iterator itr = map->begin();
451    for(; itr != map->end(); itr++) {
452      GetRZPhi(itr->first, q);
453
454      if(idxProj == 0 && q[0] == idxColumn) { // zphi plane
455        zphicell[q[1]][q[2]] += *(itr->second);
456        if(zphimax < zphicell[q[1]][q[2]]) zphimax = zphicell[q[1]][q[2]];
457      }
458      if(idxProj == 1 && q[1] == idxColumn) { // rphi plane
459        rphicell[q[0]][q[2]] += *(itr->second);
460        if(rphimax < rphicell[q[0]][q[2]]) rphimax = rphicell[q[0]][q[2]];
461      }
462      if(idxProj == 2 && q[2] == idxColumn) { // rz plane
463        rzcell[q[0]][q[1]] += *(itr->second); 
464        if(rzmax < rzcell[q[0]][q[1]]) rzmax = rzcell[q[0]][q[1]];
465      }
466    } 
467
468    G4VisAttributes att;
469    att.SetForceSolid(true);
470    att.SetForceAuxEdgeVisible(true);
471
472
473    G4Scale3D scale;
474    // r-phi plane
475    if(idxProj == 0) {
476      if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,zphimax); }
477
478      G4double zhalf = fSize[1]/fNSegment[1];
479      G4double rsize[2] = {fSize[0]/fNSegment[0]*idxColumn,
480                           fSize[0]/fNSegment[0]*(idxColumn+1)};
481      for(int phi = 0; phi < fNSegment[2]; phi++) {
482        for(int z = 0; z < fNSegment[1]; z++) {
483
484          G4double angle = twopi/fNSegment[2]*phi*radian;
485          G4double dphi = twopi/fNSegment[2]*radian;
486          G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf,
487                          angle, dphi*0.99999);
488
489          G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[1]*(1 + 2.*z));
490          G4Transform3D trans;
491          if(fRotationMatrix) {
492            trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
493            trans = G4Translate3D(fCenterPosition)*trans;
494          } else {
495            trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
496          }
497          G4double c[4];
498          colorMap->GetMapColor(zphicell[z][phi], c);
499          att.SetColour(c[0], c[1], c[2]);//, c[3]);
500          pVisManager->Draw(cylinder, att, trans);
501        }
502      }
503
504      // r-phi plane
505    } else if(idxProj == 1) {
506      if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,rphimax); }
507
508      G4double rsize = fSize[0]/fNSegment[0];
509      for(int phi = 0; phi < fNSegment[2]; phi++) {
510        for(int r = 0; r < fNSegment[0]; r++) {
511
512          G4double rs[2] = {rsize*r, rsize*(r+1)};
513          G4double angle = twopi/fNSegment[2]*phi*radian;
514          G4double dz = fSize[1]/fNSegment[1];
515          G4double dphi = twopi/fNSegment[2]*radian;
516          G4Tubs cylinder("r-phi", rs[0], rs[1], dz,
517                          angle, dphi*0.99999);
518          G4ThreeVector zpos(0., 0.,
519                             -fSize[1]+fSize[1]/fNSegment[1]*(idxColumn*2+1));
520          G4Transform3D trans;
521          if(fRotationMatrix) {
522            trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
523            trans = G4Translate3D(fCenterPosition)*trans;
524          } else {
525            trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
526          }
527          G4double c[4];
528          colorMap->GetMapColor(rphicell[r][phi], c);
529          att.SetColour(c[0], c[1], c[2]);//, c[3]);
530          pVisManager->Draw(cylinder, att, trans);
531        }
532      }
533
534      // r-z plane
535    } else if(idxProj == 2) {
536      if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,rzmax); }
537
538      G4double rsize = fSize[0]/fNSegment[0];
539      G4double zhalf = fSize[1]/fNSegment[1];
540      G4double angle = twopi/fNSegment[2]*idxColumn*radian;
541      G4double dphi = twopi/fNSegment[2]*radian;
542      for(int z = 0; z < fNSegment[1]; z++) {
543        for(int r = 0; r < fNSegment[0]; r++) {
544
545          G4double rs[2] = {rsize*r, rsize*(r+1)};
546          G4Tubs cylinder("z-phi", rs[0], rs[1], zhalf,
547                          angle, dphi);
548
549          G4ThreeVector zpos(0., 0.,
550                             -fSize[1]+fSize[1]/fNSegment[1]*(2.*z+1));
551          G4Transform3D trans;
552          if(fRotationMatrix) {
553            trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
554            trans = G4Translate3D(fCenterPosition)*trans;
555          } else {
556            trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
557          }
558          G4double c[4];
559          colorMap->GetMapColor(rzcell[r][z], c);
560          att.SetColour(c[0], c[1], c[2]);//, c[3]);
561          pVisManager->Draw(cylinder, att, trans);
562        }
563      }
564    }
565  }
566
567  colorMap->DrawColorChart();
568
569}
570
571void G4ScoringCylinder::GetRZPhi(G4int index, G4int q[3]) const {
572
573  q[0] = index/(fNSegment[2]*fNSegment[1]);
574  q[1] = (index - q[0]*fNSegment[2]*fNSegment[1])/fNSegment[2];
575  q[2] = index - q[1]*fNSegment[2] - q[0]*fNSegment[2]*fNSegment[1];
576
577}
Note: See TracBrowser for help on using the repository browser.