Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/digits_hits/utils/src/G4ScoringCylinder.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /digits_hits/utils/src/G4ScoringCylinder.cc (Version 11.3.0) and /digits_hits/utils/src/G4ScoringCylinder.cc (Version 10.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4ScoringCylinder                           <<  26 //
 27 // ------------------------------------------- <<  27 // $Id: G4ScoringCylinder.cc 68735 2013-04-05 09:49:13Z gcosmo $
                                                   >>  28 //
 28                                                    29 
 29 #include "G4ScoringCylinder.hh"                    30 #include "G4ScoringCylinder.hh"
 30                                                    31 
 31 #include "G4LogicalVolume.hh"                  << 
 32 #include "G4MultiFunctionalDetector.hh"        << 
 33 #include "G4PVDivision.hh"                     << 
 34 #include "G4PVPlacement.hh"                    << 
 35 #include "G4PVReplica.hh"                      << 
 36 #include "G4PhysicalConstants.hh"                  32 #include "G4PhysicalConstants.hh"
 37 #include "G4SDManager.hh"                      << 
 38 #include "G4ScoringManager.hh"                 << 
 39 #include "G4StatDouble.hh"                     << 
 40 #include "G4SystemOfUnits.hh"                      33 #include "G4SystemOfUnits.hh"
                                                   >>  34 #include "G4VPhysicalVolume.hh"
 41 #include "G4Tubs.hh"                               35 #include "G4Tubs.hh"
                                                   >>  36 #include "G4LogicalVolume.hh"
 42 #include "G4VPhysicalVolume.hh"                    37 #include "G4VPhysicalVolume.hh"
 43 #include "G4VPrimitiveScorer.hh"               <<  38 #include "G4PVPlacement.hh"
 44 #include "G4VScoreColorMap.hh"                 <<  39 #include "G4PVReplica.hh"
 45 #include "G4VVisManager.hh"                    <<  40 #include "G4PVDivision.hh"
 46 #include "G4VisAttributes.hh"                      41 #include "G4VisAttributes.hh"
                                                   >>  42 #include "G4VVisManager.hh"
                                                   >>  43 #include "G4VScoreColorMap.hh"
 47                                                    44 
 48 #include "G4LogicalVolumeStore.hh"             <<  45 #include "G4SDManager.hh"
 49 #include "G4Material.hh"                       <<  46 #include "G4MultiFunctionalDetector.hh"
 50 #include "G4PhysicalVolumeStore.hh"            <<  47 #include "G4SDParticleFilter.hh"
 51 #include "G4SolidStore.hh"                     <<  48 #include "G4VPrimitiveScorer.hh"
 52 #include "G4UnitsTable.hh"                     <<  49 #include "G4PSEnergyDeposit.hh"
 53 #include "G4VSensitiveDetector.hh"             <<  50 #include "G4PSTrackLength.hh"
 54 #include "G4VSolid.hh"                         <<  51 #include "G4PSNofStep.hh"
                                                   >>  52 #include "G4ScoringManager.hh"
 55                                                    53 
 56                                                    54 
 57 G4ScoringCylinder::G4ScoringCylinder(const G4S <<  55 G4ScoringCylinder::G4ScoringCylinder(G4String wName)
 58   : G4VScoringMesh(wName)                      <<  56   :G4VScoringMesh(wName)
 59 {                                                  57 {
 60   fShape = MeshShape::cylinder;                <<  58   fShape = cylinderMesh;
 61                                                    59 
 62   fDivisionAxisNames[0] = "Z";                     60   fDivisionAxisNames[0] = "Z";
 63   fDivisionAxisNames[1] = "PHI";                   61   fDivisionAxisNames[1] = "PHI";
 64   fDivisionAxisNames[2] = "R";                     62   fDivisionAxisNames[2] = "R";
 65 }                                                  63 }
 66                                                    64 
 67 void G4ScoringCylinder::SetupGeometry(G4VPhysi <<  65 G4ScoringCylinder::~G4ScoringCylinder()
                                                   >>  66 {;}
                                                   >>  67 
                                                   >>  68 void G4ScoringCylinder::Construct(G4VPhysicalVolume* fWorldPhys)
 68 {                                                  69 {
 69   if(verboseLevel > 9)                         <<  70   if(fConstructed) {
 70     G4cout << "G4ScoringCylinder::SetupGeometr <<  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 void G4ScoringCylinder::SetupGeometry(G4VPhysicalVolume * fWorldPhys) {
                                                   >>  83 
                                                   >>  84   if(verboseLevel > 9) G4cout << "G4ScoringCylinder::SetupGeometry() ..." << G4endl;
 71                                                    85 
 72   // World                                         86   // World
 73   G4VPhysicalVolume* scoringWorld = fWorldPhys <<  87   G4VPhysicalVolume * scoringWorld = fWorldPhys;
 74   G4LogicalVolume* worldLogical   = scoringWor <<  88   G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume();
 75                                                    89 
 76   // Scoring Mesh                                  90   // Scoring Mesh
 77   if(verboseLevel > 9)                         <<  91   if(verboseLevel > 9) G4cout << fWorldName << G4endl;
 78     G4cout << fWorldName << G4endl;            <<  92   G4String tubsName = fWorldName+"_mesh";
 79   G4String tubsName = fWorldName + "_mesh";    << 
 80                                                    93 
 81   if(verboseLevel > 9)                         <<  94   if(verboseLevel > 9) G4cout << "R max., Dz =: " << fSize[0] << ", " << fSize[1] << G4endl;
 82   {                                            <<  95   G4VSolid * tubsSolid = new G4Tubs(tubsName+"0", // name
 83     G4cout << "R min, R max., Dz =: " << fSize <<  96             0.,           // R min
 84                                       << ", "  <<  97             fSize[0],     // R max
 85   }                                            <<  98             fSize[1],     // Dz
 86   G4VSolid* tubsSolid          = new G4Tubs(tu <<  99             0.,           // starting phi
 87                                    fSize[0],   << 100                                     twopi*rad);   // segment phi
 88                                    fSize[1],   << 101   G4LogicalVolume *  tubsLogical = new G4LogicalVolume(tubsSolid, 0, tubsName);
 89                                    fSize[2],   << 102   new G4PVPlacement(fRotationMatrix, fCenterPosition,
 90                                    fAngle[0],  << 103         tubsLogical, tubsName+"0", worldLogical, false, 0);
 91                                    fAngle[1]); << 104 
 92   auto  tubsLogical = new G4LogicalVolume(tubs << 105   if(verboseLevel > 9) G4cout << " # of segments : r, phi, z =: "
 93   new G4PVPlacement(fRotationMatrix, fCenterPo << 106    << fNSegment[IR] << ", " << fNSegment[IPHI] << ", " << fNSegment[IZ] << G4endl;
 94                     tubsName + "0", worldLogic << 107 
 95                                                << 108   G4String layerName[2] = {tubsName + "1",  tubsName + "2"};
 96   if(verboseLevel > 9)                         << 109   G4VSolid * layerSolid[2]; 
 97     G4cout << " # of segments : r, phi, z =: " << 110   G4LogicalVolume * layerLogical[2];
 98            << fNSegment[IPHI] << ", " << fNSeg << 
 99                                                << 
100   G4String layerName[2] = { tubsName + "1", tu << 
101   G4VSolid* layerSolid[2];                     << 
102   G4LogicalVolume* layerLogical[2];            << 
103                                                   111 
104   //-- fisrt nested layer (replicated along z     112   //-- fisrt nested layer (replicated along z direction)
105   if(verboseLevel > 9)                         << 113   if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
106     G4cout << "layer 1 :" << G4endl;           << 114   layerSolid[0] = new G4Tubs(layerName[0],           // name
107   layerSolid[0]   = new G4Tubs(layerName[0],   << 115            0.,                     // inner radius
108                              fSize[0],         << 116            fSize[0],               // outer radius
109                              fSize[1],         << 117            fSize[1]/fNSegment[IZ], // half len. in z
110                              fSize[2] / fNSegm << 118            0.,                     // starting phi angle
111                              fAngle[0],        << 119            twopi*rad);             // delta angle of the segment
112                              fAngle[1]);  // d << 120   layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
113   layerLogical[0] = new G4LogicalVolume(layerS << 121   if(fNSegment[IZ] > 1) {
114   if(fNSegment[IZ] > 1)                        << 122     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction" << G4endl;
115   {                                            << 123     if(G4ScoringManager::GetReplicaLevel()>0) {
116     if(verboseLevel > 9)                       << 124       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
117       G4cout << "G4ScoringCylinder::Construct( << 125       new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 2.*fSize[1]/fNSegment[IZ]);
118              << G4endl;                        << 126     } else {
119     if(G4ScoringManager::GetReplicaLevel() > 0 << 127       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
120     {                                          << 128       new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 0.);
121       if(verboseLevel > 9)                     << 129     }
122         G4cout << "G4ScoringCylinder::Construc << 130   } else if(fNSegment[IZ] == 1) {
123       new G4PVReplica(layerName[0], layerLogic << 131     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
124                       fNSegment[IZ], 2. * fSiz << 132     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], tubsLogical, false, 0);
125     }                                          << 133   } else {
126     else                                       << 
127     {                                          << 
128       if(verboseLevel > 9)                     << 
129         G4cout << "G4ScoringCylinder::Construc << 
130       new G4PVDivision(layerName[0], layerLogi << 
131                        fNSegment[IZ], 0.);     << 
132     }                                          << 
133   }                                            << 
134   else if(fNSegment[IZ] == 1)                  << 
135   {                                            << 
136     if(verboseLevel > 9)                       << 
137       G4cout << "G4ScoringCylinder::Construct( << 
138     new G4PVPlacement(nullptr, G4ThreeVector(0 << 
139                       layerName[0], tubsLogica << 
140   }                                            << 
141   else                                         << 
142   {                                            << 
143     G4cerr << "G4ScoringCylinder::SetupGeometr    134     G4cerr << "G4ScoringCylinder::SetupGeometry() : invalid parameter ("
144            << fNSegment[IZ] << ") "            << 135      << fNSegment[IZ] << ") "
145            << "in placement of the first neste << 136      << "in placement of the first nested layer." << G4endl;
146   }                                               137   }
147                                                   138 
148   // second nested layer (replicated along phi    139   // second nested layer (replicated along phi direction)
149   if(verboseLevel > 9)                         << 140   if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
150     G4cout << "layer 2 :" << G4endl;           << 141   layerSolid[1] = new G4Tubs(layerName[1],
151   layerSolid[1] =                              << 142            0.,
152     new G4Tubs(layerName[1], fSize[0], fSize[1 << 143            fSize[0],
153                fAngle[0], fAngle[1] / fNSegmen << 144            fSize[1]/fNSegment[IZ],
154   layerLogical[1] = new G4LogicalVolume(layerS << 145            0.,
155   if(fNSegment[IPHI] > 1)                      << 146                              twopi*rad/fNSegment[IPHI]);
156   {                                            << 147   layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
157     if(verboseLevel > 9)                       << 148   if(fNSegment[IPHI] > 1)  {
158       G4cout << "G4ScoringCylinder::Construct( << 149     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction" << G4endl;
159              << G4endl;                        << 150     if(G4ScoringManager::GetReplicaLevel()>1) {
160     if(G4ScoringManager::GetReplicaLevel() > 1 << 151       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
161     {                                          << 
162       if(verboseLevel > 9)                     << 
163         G4cout << "G4ScoringCylinder::Construc << 
164       new G4PVReplica(layerName[1], layerLogic    152       new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kPhi,
165                       fNSegment[IPHI], fAngle[ << 153           fNSegment[IPHI], twopi*rad/fNSegment[IPHI]);
166     }                                          << 154     } else {
167     else                                       << 155       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
168     {                                          << 156       new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kPhi, fNSegment[IPHI], 0.);
169       if(verboseLevel > 9)                     << 157     }
170         G4cout << "G4ScoringCylinder::Construc << 158   } else if(fNSegment[IPHI] == 1) {
171       new G4PVDivision(layerName[1], layerLogi << 159     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
172                        fNSegment[IPHI], 0.);   << 160     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
173     }                                          << 161   } else
174   }                                            << 
175   else if(fNSegment[IPHI] == 1)                << 
176   {                                            << 
177     if(verboseLevel > 9)                       << 
178       G4cout << "G4ScoringCylinder::Construct( << 
179     new G4PVPlacement(nullptr, G4ThreeVector(0 << 
180                       layerName[1], layerLogic << 
181   }                                            << 
182   else                                         << 
183     G4cerr << "ERROR : G4ScoringCylinder::Setu    162     G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
184            << fNSegment[IPHI] << ") "          << 163      << fNSegment[IPHI] << ") "
185            << "in placement of the second nest << 164      << "in placement of the second nested layer." << G4endl;
186                                                   165 
187   // mesh elements                                166   // mesh elements
188   if(verboseLevel > 9)                         << 167   if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
189     G4cout << "mesh elements :" << G4endl;     << 168   G4String elementName = tubsName +"3";
190   G4String elementName   = tubsName + "3";     << 169   G4VSolid * elementSolid = new G4Tubs(elementName,
191   G4VSolid* elementSolid = new G4Tubs(         << 170                0.,
192     elementName, fSize[0], (fSize[1] - fSize[0 << 171                fSize[0]/fNSegment[IR],
193     fSize[2] / fNSegment[IZ], fAngle[0], fAngl << 172                fSize[1]/fNSegment[IZ],
194   fMeshElementLogical = new G4LogicalVolume(el << 173                0.,
195   if(fNSegment[IR] >= 1)                       << 174                                        twopi*rad/fNSegment[IPHI]);
196   {                                            << 175   fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
197     if(verboseLevel > 9)                       << 176   if(fNSegment[IR] > 1) {
198       G4cout << "G4ScoringCylinder::Construct( << 177 
199              << G4endl;                        << 178     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction" << G4endl;
200                                                << 179 
201     if(G4ScoringManager::GetReplicaLevel() > 2 << 180     if(G4ScoringManager::GetReplicaLevel()>2) {
202     {                                          << 181       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
203       if(verboseLevel > 9)                     << 
204         G4cout << "G4ScoringCylinder::Construc << 
205       new G4PVReplica(elementName, fMeshElemen    182       new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kRho,
206                       fNSegment[IR], (fSize[1] << 183       fNSegment[IR], fSize[0]/fNSegment[IR]);
207                       fSize[0]);               << 184     } else {
208     }                                          << 185       if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
209     else                                       << 186       new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kRho, fNSegment[IR], 0.);
210     {                                          << 187     }
211       if(verboseLevel > 9)                     << 188   } else if(fNSegment[IR] == 1) {
212         G4cout << "G4ScoringCylinder::Construc << 189     if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
213       new G4PVDivision(elementName, fMeshEleme << 190     new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
214                        fNSegment[IR], 0.);     << 191   } else {
215     }                                          << 
216   }                                            << 
217   else                                         << 
218   {                                            << 
219     G4cerr << "G4ScoringCylinder::SetupGeometr    192     G4cerr << "G4ScoringCylinder::SetupGeometry() : "
220            << "invalid parameter (" << fNSegme << 193      << "invalid parameter (" << fNSegment[IR] << ") "
221            << "in mesh element placement." <<  << 194      << "in mesh element placement." << G4endl;
222   }                                               195   }
223                                                   196 
224   // set the sensitive detector                   197   // set the sensitive detector
225   fMeshElementLogical->SetSensitiveDetector(fM    198   fMeshElementLogical->SetSensitiveDetector(fMFD);
                                                   >> 199   
226                                                   200 
227   // vis. attributes                              201   // vis. attributes
228   auto  visatt = new G4VisAttributes(G4Colour( << 202   G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
229   visatt->SetVisibility(true);                    203   visatt->SetVisibility(true);
230   layerLogical[0]->SetVisAttributes(visatt);      204   layerLogical[0]->SetVisAttributes(visatt);
231   layerLogical[1]->SetVisAttributes(visatt);      205   layerLogical[1]->SetVisAttributes(visatt);
232   visatt = new G4VisAttributes(G4Colour(.5, .5 << 206   visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.01));
233   // visatt->SetForceSolid(true);              << 207   //visatt->SetForceSolid(true);
234   fMeshElementLogical->SetVisAttributes(visatt    208   fMeshElementLogical->SetVisAttributes(visatt);
235                                                << 
236   if(verboseLevel > 9)                         << 
237     DumpVolumes();                             << 
238 }                                                 209 }
239                                                   210 
240 void G4ScoringCylinder::List() const           << 211 void G4ScoringCylinder::List() const {
241 {                                              << 212   G4cout << "G4ScoringCylinder : " << fWorldName << " --- Shape: Cylindrical mesh" << G4endl;
242   G4cout << "G4ScoringCylinder : " << fWorldNa << 
243          << " --- Shape: Cylindrical mesh" <<  << 
244                                                   213 
245   G4cout << " Size (Rmin, Rmax, Dz): (" << fSi << 214   G4cout << " Size (R, Dz): ("
246          << fSize[1] / cm << ", " << fSize[2]  << 215    << fSize[0]/cm << ", "
247   G4cout << " Angle (start, span): (" << fAngl << 216    << fSize[1]/cm << ") [cm]"
248          << fAngle[1] / deg << ") [deg]" << G4 << 217    << G4endl;
249                                                   218 
250   G4VScoringMesh::List();                         219   G4VScoringMesh::List();
251 }                                                 220 }
252                                                   221 
253 void G4ScoringCylinder::Draw(RunScore* map, G4 << 222 
254                              G4int axflg)      << 223 void G4ScoringCylinder::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
255 {                                              << 224 
256   G4VVisManager* pVisManager = G4VVisManager:: << 225   G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
257   if(pVisManager != nullptr)                   << 226   if(pVisManager) {
258   {                                            << 227     
259     // cell vectors                               228     // cell vectors
260     std::vector<G4double> ephi;                << 229     std::vector<double> ephi;
261     for(G4int phi = 0; phi < fNSegment[IPHI];  << 230     for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
262       ephi.push_back(0.);                      << 
263     //-                                           231     //-
264     std::vector<std::vector<G4double>> zphicel << 232     std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
265     for(G4int z = 0; z < fNSegment[IZ]; z++)   << 233     for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
266       zphicell.push_back(ephi);                << 
267     //-                                           234     //-
268     std::vector<std::vector<G4double>> rphicel << 235     std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
269     for(G4int r = 0; r < fNSegment[IR]; r++)   << 236     for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
270       rphicell.push_back(ephi);                << 
271                                                   237 
272     // projections                                238     // projections
273     G4int q[3];                                   239     G4int q[3];
274     auto itr = map->GetMap()->begin();         << 240     std::map<G4int, G4double*>::iterator itr = map->begin();
275     for(; itr != map->GetMap()->end(); itr++)  << 241     for(; itr != map->end(); itr++) {
276     {                                          << 242       if(itr->first < 0) {
277       if(itr->first < 0)                       << 243   G4cout << itr->first << G4endl;
278       {                                        << 244   continue;
279         G4cout << itr->first << G4endl;        << 
280         continue;                              << 
281       }                                           245       }
282       GetRZPhi(itr->first, q);                    246       GetRZPhi(itr->first, q);
283                                                   247 
284       zphicell[q[IZ]][q[IPHI]] += (itr->second << 248       zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
285       rphicell[q[IR]][q[IPHI]] += (itr->second << 249       rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
286     }                                          << 250     }  
287                                                << 251     
288     // search min./max. values                    252     // search min./max. values
289     G4double zphimin = DBL_MAX, rphimin = DBL_    253     G4double zphimin = DBL_MAX, rphimin = DBL_MAX;
290     G4double zphimax = 0., rphimax = 0.;          254     G4double zphimax = 0., rphimax = 0.;
291     for(G4int iphi = 0; iphi < fNSegment[IPHI] << 255     for(int iphi = 0; iphi < fNSegment[IPHI]; iphi++) {
292     {                                          << 256       for(int iz = 0; iz < fNSegment[IZ]; iz++) {
293       for(G4int iz = 0; iz < fNSegment[IZ]; iz << 257   if(zphimin > zphicell[iz][iphi]) zphimin = zphicell[iz][iphi];
294       {                                        << 258   if(zphimax < zphicell[iz][iphi]) zphimax = zphicell[iz][iphi];
295         if(zphimin > zphicell[iz][iphi])       << 259       }
296           zphimin = zphicell[iz][iphi];        << 260       for(int ir = 0; ir < fNSegment[IR]; ir++) {
297         if(zphimax < zphicell[iz][iphi])       << 261   if(rphimin > rphicell[ir][iphi]) rphimin = rphicell[ir][iphi];
298           zphimax = zphicell[iz][iphi];        << 262   if(rphimax < rphicell[ir][iphi]) rphimax = rphicell[ir][iphi];
299       }                                        << 
300       for(G4int ir = 0; ir < fNSegment[IR]; ir << 
301       {                                        << 
302         if(rphimin > rphicell[ir][iphi])       << 
303           rphimin = rphicell[ir][iphi];        << 
304         if(rphimax < rphicell[ir][iphi])       << 
305           rphimax = rphicell[ir][iphi];        << 
306       }                                           263       }
307     }                                             264     }
308                                                   265 
309     G4VisAttributes att;                          266     G4VisAttributes att;
310     att.SetForceSolid(true);                      267     att.SetForceSolid(true);
311     att.SetForceAuxEdgeVisible(true);             268     att.SetForceAuxEdgeVisible(true);
312                                                   269 
                                                   >> 270 
313     G4Scale3D scale;                              271     G4Scale3D scale;
314     if(axflg / 100 == 1)                       << 272     if(axflg/100==1) {
315     {                                          << 
316       // rz plane                                 273       // rz plane
317     }                                             274     }
318     axflg = axflg % 100;                       << 275     axflg = axflg%100;
319     if(axflg / 10 == 1)                        << 276     if(axflg/10==1) {
320     {                                          << 
321       pVisManager->BeginDraw();                << 
322                                                << 
323       // z-phi plane                              277       // z-phi plane
324       if(colorMap->IfFloatMinMax())            << 278       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin, zphimax); }
325       {                                        << 279 
326         colorMap->SetMinMax(zphimin, zphimax); << 280       G4double zhalf = fSize[1]/fNSegment[IZ];
327       }                                        << 281       for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
328                                                << 282   for(int z = 0; z < fNSegment[IZ]; z++) {
329       G4double zhalf = fSize[2] / fNSegment[IZ << 283     //-
330       for(G4int phi = 0; phi < fNSegment[IPHI] << 284     G4double angle = twopi/fNSegment[IPHI]*phi;
331       {                                        << 285     G4double dphi = twopi/fNSegment[IPHI];
332         for(G4int z = 0; z < fNSegment[IZ]; z+ << 286     G4Tubs cylinder("z-phi",                    // name
333         {                                      << 287         fSize[0]*0.99, fSize[0],  // inner radius, outer radius
334           //-                                  << 288         zhalf,                      // half length in z
335           G4double angle = fAngle[0] + fAngle[ << 289         angle, dphi*0.99999);       // starting phi angle, delta angle
336           G4double dphi  = fAngle[1] / fNSegme << 290     //-
337           G4Tubs cylinder(                     << 291     G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
338             "z-phi",                    // nam << 292     G4Transform3D trans;
339             fSize[1] * 0.99, fSize[1],  // inn << 293     if(fRotationMatrix) {
340             zhalf,                      // hal << 294       trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
341             angle, dphi * 0.99999);     // sta << 295       trans = G4Translate3D(fCenterPosition)*trans;
342           //-                                  << 296     } else {
343           G4ThreeVector zpos(                  << 297       trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
344             0., 0., -fSize[2] + fSize[2] / fNS << 298     }
345           G4Transform3D trans;                 << 299     G4double c[4];
346           if(fRotationMatrix != nullptr)       << 300     colorMap->GetMapColor(zphicell[z][phi], c);
347           {                                    << 301     att.SetColour(c[0], c[1], c[2]);//, c[3]);
348             trans =                            << 302     //-
349               G4Rotate3D(*fRotationMatrix).inv << 303     pVisManager->Draw(cylinder, att, trans);
350             trans = G4Translate3D(fCenterPosit << 304   }
351           }                                    << 
352           else                                 << 
353           {                                    << 
354             trans = G4Translate3D(zpos) * G4Tr << 
355           }                                    << 
356           G4double c[4];                       << 
357           colorMap->GetMapColor(zphicell[z][ph << 
358           att.SetColour(c[0], c[1], c[2]);  // << 
359           //-                                  << 
360           G4Polyhedron* poly = cylinder.GetPol << 
361           poly->Transform(trans);              << 
362           poly->SetVisAttributes(att);         << 
363           pVisManager->Draw(*poly);            << 
364         }                                      << 
365       }                                           305       }
366       pVisManager->EndDraw();                  << 
367     }                                             306     }
368     axflg = axflg % 10;                        << 307     axflg = axflg%10;
369     if(axflg == 1)                             << 308     if(axflg==1) {
370     {                                          << 
371       pVisManager->BeginDraw();                << 
372                                                << 
373       // r-phi plane                              309       // r-phi plane
374       if(colorMap->IfFloatMinMax())            << 310       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin, rphimax); }
375       {                                        << 
376         colorMap->SetMinMax(rphimin, rphimax); << 
377       }                                        << 
378                                                << 
379       G4double rsize = (fSize[1] - fSize[0]) / << 
380       for(G4int phi = 0; phi < fNSegment[IPHI] << 
381       {                                        << 
382         for(G4int r = 0; r < fNSegment[IR]; r+ << 
383         {                                      << 
384           G4double rs[2] = { fSize[0] + rsize  << 
385           G4double angle = fAngle[0] + fAngle[ << 
386           G4double dphi  = fAngle[1] / fNSegme << 
387           G4Tubs cylindern("z-phi", rs[0], rs[ << 
388           G4Tubs cylinderp = cylindern;        << 
389                                                << 
390           G4ThreeVector zposn(0., 0., -fSize[2 << 
391           G4ThreeVector zposp(0., 0., fSize[2] << 
392           G4Transform3D transn, transp;        << 
393           if(fRotationMatrix != nullptr)       << 
394           {                                    << 
395             transn =                           << 
396               G4Rotate3D(*fRotationMatrix).inv << 
397             transn = G4Translate3D(fCenterPosi << 
398             transp =                           << 
399               G4Rotate3D(*fRotationMatrix).inv << 
400             transp = G4Translate3D(fCenterPosi << 
401           }                                    << 
402           else                                 << 
403           {                                    << 
404             transn = G4Translate3D(zposn) * G4 << 
405             transp = G4Translate3D(zposp) * G4 << 
406           }                                    << 
407           G4double c[4];                       << 
408           colorMap->GetMapColor(rphicell[r][ph << 
409           att.SetColour(c[0], c[1], c[2]);  // << 
410                                                << 
411           G4Polyhedron* polyn = cylindern.GetP << 
412           polyn->Transform(transn);            << 
413           polyn->SetVisAttributes(att);        << 
414           pVisManager->Draw(*polyn);           << 
415                                                << 
416           G4Polyhedron* polyp = cylinderp.GetP << 
417           polyp->Transform(transp);            << 
418           polyp->SetVisAttributes(att);        << 
419           pVisManager->Draw(*polyp);           << 
420         }                                      << 
421       }                                        << 
422                                                   311 
423       pVisManager->EndDraw();                  << 312       G4double rsize = fSize[0]/fNSegment[IR];
                                                   >> 313       for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
                                                   >> 314   for(int r = 0; r < fNSegment[IR]; r++) {
                                                   >> 315 
                                                   >> 316     G4double rs[2] = {rsize*r, rsize*(r+1)};
                                                   >> 317     G4double angle = twopi/fNSegment[IPHI]*phi;
                                                   >> 318     G4double dphi = twopi/fNSegment[IPHI];
                                                   >> 319     G4Tubs cylinder("z-phi", rs[0], rs[1], 0.001,
                                                   >> 320         angle, dphi*0.99999);
                                                   >> 321     /*
                                                   >> 322     G4cout << ">>>> "
                                                   >> 323      << rs[0] << " - " << rs[1] << " : "
                                                   >> 324      << angle << " - " << angle + dphi
                                                   >> 325      << G4endl;
                                                   >> 326     */
                                                   >> 327 
                                                   >> 328     G4ThreeVector zposn(0., 0., -fSize[1]);
                                                   >> 329     G4ThreeVector zposp(0., 0.,  fSize[1]);
                                                   >> 330     G4Transform3D transn, transp;
                                                   >> 331     if(fRotationMatrix) {
                                                   >> 332       transn = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposn);
                                                   >> 333       transn = G4Translate3D(fCenterPosition)*transn;
                                                   >> 334       transp = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposp);
                                                   >> 335       transp = G4Translate3D(fCenterPosition)*transp;
                                                   >> 336     } else {
                                                   >> 337       transn = G4Translate3D(zposn)*G4Translate3D(fCenterPosition);
                                                   >> 338       transp = G4Translate3D(zposp)*G4Translate3D(fCenterPosition);
                                                   >> 339     }
                                                   >> 340     G4double c[4];
                                                   >> 341     colorMap->GetMapColor(rphicell[r][phi], c);
                                                   >> 342     att.SetColour(c[0], c[1], c[2]);//, c[3]);
                                                   >> 343     /*
                                                   >> 344     G4cout << "   " << c[0] << ", "
                                                   >> 345      << c[1] << ", " << c[2] << G4endl;
                                                   >> 346     */
                                                   >> 347     pVisManager->Draw(cylinder, att, transn);
                                                   >> 348     pVisManager->Draw(cylinder, att, transp);
                                                   >> 349   }
                                                   >> 350       }
424     }                                             351     }
425                                                   352 
426     colorMap->SetPSUnit(fDrawUnit);               353     colorMap->SetPSUnit(fDrawUnit);
427     colorMap->SetPSName(fDrawPSName);             354     colorMap->SetPSName(fDrawPSName);
428     colorMap->DrawColorChart();                   355     colorMap->DrawColorChart();
                                                   >> 356 
429   }                                               357   }
430 }                                                 358 }
431                                                   359 
432 void G4ScoringCylinder::DrawColumn(RunScore* m << 360 void G4ScoringCylinder::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, 
433                                    G4int idxPr << 361            G4int idxProj, G4int idxColumn) 
434 {                                                 362 {
435   G4int projAxis = 0;                             363   G4int projAxis = 0;
436   switch(idxProj)                              << 364   switch(idxProj) {
437   {                                            << 365   case 0: 
438     case 0:                                    << 366     projAxis = IR;
439       projAxis = IR;                           << 367     break;
440       break;                                   << 368   case 1:
441     case 1:                                    << 369     projAxis = IZ;
442       projAxis = IZ;                           << 370     break;
443       break;                                   << 371   case 2:
444     case 2:                                    << 372     projAxis = IPHI;
445       projAxis = IPHI;                         << 373     break;
446       break;                                   << 
447   }                                               374   }
448                                                   375 
449   if(idxColumn < 0 || idxColumn >= fNSegment[p << 376   if(idxColumn<0 || idxColumn>=fNSegment[projAxis])
450   {                                               377   {
451     G4cerr << "Warning : Column number " << id << 378     G4cerr << "Warning : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[projAxis]-1 <<
452            << " is out of scoring mesh [0," << << 379     "]. Method ignored." << G4endl;
453            << "]. Method ignored." << G4endl;  << 
454     return;                                       380     return;
455   }                                               381   }
456   G4VVisManager* pVisManager = G4VVisManager:: << 382   G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
457   if(pVisManager != nullptr)                   << 383   if(pVisManager) {
458   {                                            << 384 
459     // cell vectors                               385     // cell vectors
460     std::vector<std::vector<std::vector<G4doub << 386     std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
461     std::vector<G4double> ephi;                << 387     std::vector<double> ephi;
462     for(G4int phi = 0; phi < fNSegment[IPHI];  << 388     for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
463       ephi.push_back(0.);                      << 389     std::vector<std::vector<double> > ezphi;
464     std::vector<std::vector<G4double>> ezphi;  << 390     for(int z = 0; z < fNSegment[IZ]; z++) ezphi.push_back(ephi);
465     for(G4int z = 0; z < fNSegment[IZ]; z++)   << 391     for(int r = 0; r < fNSegment[IR]; r++) cell.push_back(ezphi);
466       ezphi.push_back(ephi);                   << 392 
467     for(G4int r = 0; r < fNSegment[IR]; r++)   << 393     std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
468       cell.push_back(ezphi);                   << 394     std::vector<double> ez;
469                                                << 395     for(int z = 0; z < fNSegment[IZ]; z++) ez.push_back(0.);
470     std::vector<std::vector<G4double>> rzcell; << 396     for(int r = 0; r < fNSegment[IR]; r++) rzcell.push_back(ez);
471     std::vector<G4double> ez;                  << 397 
472     for(G4int z = 0; z < fNSegment[IZ]; z++)   << 398     std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
473       ez.push_back(0.);                        << 399     for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
474     for(G4int r = 0; r < fNSegment[IR]; r++)   << 400 
475       rzcell.push_back(ez);                    << 401     std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
476                                                << 402     for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
477     std::vector<std::vector<G4double>> zphicel << 
478     for(G4int z = 0; z < fNSegment[IZ]; z++)   << 
479       zphicell.push_back(ephi);                << 
480                                                << 
481     std::vector<std::vector<G4double>> rphicel << 
482     for(G4int r = 0; r < fNSegment[IR]; r++)   << 
483       rphicell.push_back(ephi);                << 
484                                                   403 
485     // projections                                404     // projections
486     G4int q[3];                                   405     G4int q[3];
487     auto itr = map->GetMap()->begin();         << 406     std::map<G4int, G4double*>::iterator itr = map->begin();
488     for(; itr != map->GetMap()->end(); itr++)  << 407     for(; itr != map->end(); itr++) {
489     {                                          << 408       if(itr->first < 0) {
490       if(itr->first < 0)                       << 409   G4cout << itr->first << G4endl;
491       {                                        << 410   continue;
492         G4cout << itr->first << G4endl;        << 
493         continue;                              << 
494       }                                           411       }
495       GetRZPhi(itr->first, q);                    412       GetRZPhi(itr->first, q);
496                                                   413 
497       if(projAxis == IR && q[IR] == idxColumn) << 414       if(projAxis == IR && q[IR] == idxColumn) { // zphi plane
498       {  // zphi plane                         << 415   zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
499         zphicell[q[IZ]][q[IPHI]] += (itr->seco << 
500       }                                        << 
501       if(projAxis == IZ && q[IZ] == idxColumn) << 
502       {  // rphi plane                         << 
503         rphicell[q[IR]][q[IPHI]] += (itr->seco << 
504       }                                        << 
505       if(projAxis == IPHI && q[IPHI] == idxCol << 
506       {  // rz plane                           << 
507         rzcell[q[IR]][q[IZ]] += (itr->second-> << 
508       }                                           416       }
509     }                                          << 417       if(projAxis == IZ && q[IZ] == idxColumn) { // rphi plane
                                                   >> 418   rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
                                                   >> 419       }
                                                   >> 420       if(projAxis == IPHI && q[IPHI] == idxColumn) { // rz plane
                                                   >> 421   rzcell[q[IR]][q[IZ]] += *(itr->second)/fDrawUnitValue; 
                                                   >> 422       }
                                                   >> 423     }  
510                                                   424 
511     // search min./max. values                    425     // search min./max. values
512     G4double rzmin = DBL_MAX, zphimin = DBL_MA    426     G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
513     G4double rzmax = 0., zphimax = 0., rphimax    427     G4double rzmax = 0., zphimax = 0., rphimax = 0.;
514     for(G4int r = 0; r < fNSegment[IR]; r++)   << 428     for(int r = 0; r < fNSegment[IR]; r++) {
515     {                                          << 429       for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
516       for(G4int phi = 0; phi < fNSegment[IPHI] << 430   if(rphimin > rphicell[r][phi]) rphimin = rphicell[r][phi];
517       {                                        << 431   if(rphimax < rphicell[r][phi]) rphimax = rphicell[r][phi];
518         if(rphimin > rphicell[r][phi])         << 432       }
519           rphimin = rphicell[r][phi];          << 433       for(int z = 0; z < fNSegment[IZ]; z++) {
520         if(rphimax < rphicell[r][phi])         << 434   if(rzmin > rzcell[r][z]) rzmin = rzcell[r][z];
521           rphimax = rphicell[r][phi];          << 435   if(rzmax < rzcell[r][z]) rzmax = rzcell[r][z];
522       }                                        << 
523       for(G4int z = 0; z < fNSegment[IZ]; z++) << 
524       {                                        << 
525         if(rzmin > rzcell[r][z])               << 
526           rzmin = rzcell[r][z];                << 
527         if(rzmax < rzcell[r][z])               << 
528           rzmax = rzcell[r][z];                << 
529       }                                           436       }
530     }                                             437     }
531     for(G4int z = 0; z < fNSegment[IZ]; z++)   << 438     for(int z = 0; z < fNSegment[IZ]; z++) {
532     {                                          << 439       for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
533       for(G4int phi = 0; phi < fNSegment[IPHI] << 440   if(zphimin > zphicell[z][phi]) zphimin = zphicell[z][phi];
534       {                                        << 441   if(zphimax < zphicell[z][phi]) zphimax = zphicell[z][phi];
535         if(zphimin > zphicell[z][phi])         << 
536           zphimin = zphicell[z][phi];          << 
537         if(zphimax < zphicell[z][phi])         << 
538           zphimax = zphicell[z][phi];          << 
539       }                                           442       }
540     }                                             443     }
541                                                   444 
                                                   >> 445 
542     G4VisAttributes att;                          446     G4VisAttributes att;
543     att.SetForceSolid(true);                      447     att.SetForceSolid(true);
544     att.SetForceAuxEdgeVisible(true);             448     att.SetForceAuxEdgeVisible(true);
545                                                   449 
546     pVisManager->BeginDraw();                  << 
547                                                   450 
548     G4Scale3D scale;                              451     G4Scale3D scale;
549     // z-phi plane                                452     // z-phi plane
550     if(projAxis == IR)                         << 453     if(projAxis == IR) {
551     {                                          << 454       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin,zphimax); }
552       if(colorMap->IfFloatMinMax())            << 455 
553       {                                        << 456       G4double zhalf = fSize[1]/fNSegment[IZ];
554         colorMap->SetMinMax(zphimin, zphimax); << 457       G4double rsize[2] = {fSize[0]/fNSegment[IR]*idxColumn,
555       }                                        << 458           fSize[0]/fNSegment[IR]*(idxColumn+1)};
556                                                << 459       for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
557       G4double zhalf    = fSize[2] / fNSegment << 460   for(int z = 0; z < fNSegment[IZ]; z++) {
558       G4double rsize[2] = {                    << 461 
559         fSize[0] + (fSize[1] - fSize[0]) / fNS << 462     G4double angle = twopi/fNSegment[IPHI]*phi*radian;
560         fSize[0] + (fSize[1] - fSize[0]) / fNS << 463     G4double dphi = twopi/fNSegment[IPHI]*radian;
561       };                                       << 464     G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf,
562       for(int phi = 0; phi < fNSegment[IPHI];  << 465         angle, dphi*0.99999);
563       {                                        << 466 
564         for(int z = 0; z < fNSegment[IZ]; z++) << 467     G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
565         {                                      << 468     G4Transform3D trans;
566           G4double angle = fAngle[0] + fAngle[ << 469     if(fRotationMatrix) {
567           G4double dphi  = fAngle[1] / fNSegme << 470       trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
568           G4Tubs cylinder("z-phi", rsize[0], r << 471       trans = G4Translate3D(fCenterPosition)*trans;
569                           dphi * 0.99999);     << 472     } else {
570                                                << 473       trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
571           G4ThreeVector zpos(                  << 474     }
572             0., 0., -fSize[2] + fSize[2] / fNS << 475     G4double c[4];
573           G4Transform3D trans;                 << 476     colorMap->GetMapColor(zphicell[z][phi], c);
574           if(fRotationMatrix != nullptr)       << 477     att.SetColour(c[0], c[1], c[2]);//, c[3]);
575           {                                    << 478     pVisManager->Draw(cylinder, att, trans);
576             trans =                            << 479   }
577               G4Rotate3D(*fRotationMatrix).inv << 
578             trans = G4Translate3D(fCenterPosit << 
579           }                                    << 
580           else                                 << 
581           {                                    << 
582             trans = G4Translate3D(zpos) * G4Tr << 
583           }                                    << 
584           G4double c[4];                       << 
585           colorMap->GetMapColor(zphicell[z][ph << 
586           att.SetColour(c[0], c[1], c[2]);  // << 
587                                                << 
588           G4Polyhedron* poly = cylinder.GetPol << 
589           poly->Transform(trans);              << 
590           poly->SetVisAttributes(att);         << 
591           pVisManager->Draw(*poly);            << 
592         }                                      << 
593       }                                           480       }
594                                                   481 
595       // r-phi plane                              482       // r-phi plane
596     }                                          << 483     } else if(projAxis == IZ) {
597     else if(projAxis == IZ)                    << 484       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin,rphimax); }
598     {                                          << 485 
599       if(colorMap->IfFloatMinMax())            << 486       G4double rsize = fSize[0]/fNSegment[IR];
600       {                                        << 487       for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
601         colorMap->SetMinMax(rphimin, rphimax); << 488   for(int r = 0; r < fNSegment[IR]; r++) {
602       }                                        << 489 
603                                                << 490     G4double rs[2] = {rsize*r, rsize*(r+1)};
604       G4double rsize = (fSize[1] - fSize[0]) / << 491     G4double angle = twopi/fNSegment[IPHI]*phi*radian;
605       for(G4int phi = 0; phi < fNSegment[IPHI] << 492     G4double dz = fSize[1]/fNSegment[IZ];
606       {                                        << 493     G4double dphi = twopi/fNSegment[IPHI]*radian;
607         for(G4int r = 0; r < fNSegment[IR]; r+ << 494     G4Tubs cylinder("r-phi", rs[0], rs[1], dz,
608         {                                      << 495         angle, dphi*0.99999);
609           G4double rs[2] = { fSize[0] + rsize  << 496     G4ThreeVector zpos(0., 0.,
610           G4double angle = fAngle[0] + fAngle[ << 497            -fSize[1]+fSize[1]/fNSegment[IZ]*(idxColumn*2+1));
611           G4double dz    = fSize[2] / fNSegmen << 498     G4Transform3D trans;
612           G4double dphi  = fAngle[1] / fNSegme << 499     if(fRotationMatrix) {
613           G4Tubs cylinder("r-phi", rs[0], rs[1 << 500       trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
614           G4ThreeVector zpos(                  << 501       trans = G4Translate3D(fCenterPosition)*trans;
615             0., 0., -fSize[2] + fSize[2] / fNS << 502     } else {
616           G4Transform3D trans;                 << 503       trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
617           if(fRotationMatrix != nullptr)       << 504     }
618           {                                    << 505     G4double c[4];
619             trans =                            << 506     colorMap->GetMapColor(rphicell[r][phi], c);
620               G4Rotate3D(*fRotationMatrix).inv << 507     att.SetColour(c[0], c[1], c[2]);//, c[3]);
621             trans = G4Translate3D(fCenterPosit << 508     pVisManager->Draw(cylinder, att, trans);
622           }                                    << 509   }
623           else                                 << 
624           {                                    << 
625             trans = G4Translate3D(zpos) * G4Tr << 
626           }                                    << 
627           G4double c[4];                       << 
628           colorMap->GetMapColor(rphicell[r][ph << 
629           att.SetColour(c[0], c[1], c[2]);  // << 
630                                                << 
631           G4Polyhedron* poly = cylinder.GetPol << 
632           poly->Transform(trans);              << 
633           poly->SetVisAttributes(att);         << 
634           pVisManager->Draw(*poly);            << 
635         }                                      << 
636       }                                           510       }
637                                                   511 
638       // r-z plane                                512       // r-z plane
639     }                                          << 513     } else if(projAxis == IPHI) {
640     else if(projAxis == IPHI)                  << 514       if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rzmin,rzmax); }
641     {                                          << 515 
642       if(colorMap->IfFloatMinMax())            << 516       G4double rsize = fSize[0]/fNSegment[IR];
643       {                                        << 517       G4double zhalf = fSize[1]/fNSegment[IZ];
644         colorMap->SetMinMax(rzmin, rzmax);     << 518       G4double angle = twopi/fNSegment[IPHI]*idxColumn*radian;
645       }                                        << 519       G4double dphi = twopi/fNSegment[IPHI]*radian;
646                                                << 520       for(int z = 0; z < fNSegment[IZ]; z++) {
647       G4double rsize = (fSize[1] - fSize[0]) / << 521   for(int r = 0; r < fNSegment[IR]; r++) {
648       G4double zhalf = fSize[2] / fNSegment[IZ << 522 
649       G4double angle = fAngle[0] + fAngle[1] / << 523     G4double rs[2] = {rsize*r, rsize*(r+1)};
650       G4double dphi  = fAngle[1] / fNSegment[I << 524     G4Tubs cylinder("z-phi", rs[0], rs[1], zhalf,
651       for(G4int z = 0; z < fNSegment[IZ]; z++) << 525         angle, dphi);
652       {                                        << 526 
653         for(G4int r = 0; r < fNSegment[IR]; r+ << 527     G4ThreeVector zpos(0., 0.,
654         {                                      << 528            -fSize[1]+fSize[1]/fNSegment[IZ]*(2.*z+1));
655           G4double rs[2] = { fSize[0] + rsize  << 529     G4Transform3D trans;
656           G4Tubs cylinder("z-phi", rs[0], rs[1 << 530     if(fRotationMatrix) {
657                                                << 531       trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
658           G4ThreeVector zpos(                  << 532       trans = G4Translate3D(fCenterPosition)*trans;
659             0., 0., -fSize[2] + fSize[2] / fNS << 533     } else {
660           G4Transform3D trans;                 << 534       trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
661           if(fRotationMatrix != nullptr)       << 535     }
662           {                                    << 536     G4double c[4];
663             trans =                            << 537     colorMap->GetMapColor(rzcell[r][z], c);
664               G4Rotate3D(*fRotationMatrix).inv << 538     att.SetColour(c[0], c[1], c[2]);//, c[3]);
665             trans = G4Translate3D(fCenterPosit << 539     pVisManager->Draw(cylinder, att, trans);
666           }                                    << 540   }
667           else                                 << 
668           {                                    << 
669             trans = G4Translate3D(zpos) * G4Tr << 
670           }                                    << 
671           G4double c[4];                       << 
672           colorMap->GetMapColor(rzcell[r][z],  << 
673           att.SetColour(c[0], c[1], c[2]);  // << 
674                                                << 
675           G4Polyhedron* poly = cylinder.GetPol << 
676           poly->Transform(trans);              << 
677           poly->SetVisAttributes(att);         << 
678           pVisManager->Draw(*poly);            << 
679         }                                      << 
680       }                                           541       }
681     }                                             542     }
682     pVisManager->EndDraw();                    << 
683   }                                               543   }
684                                                   544 
685   colorMap->SetPSUnit(fDrawUnit);                 545   colorMap->SetPSUnit(fDrawUnit);
686   colorMap->SetPSName(fDrawPSName);               546   colorMap->SetPSName(fDrawPSName);
687   colorMap->DrawColorChart();                     547   colorMap->DrawColorChart();
                                                   >> 548 
688 }                                                 549 }
689                                                   550 
690 void G4ScoringCylinder::GetRZPhi(G4int index,  << 551 void G4ScoringCylinder::GetRZPhi(G4int index, G4int q[3]) const {
691 {                                              << 
692   // index = k + j * k-size + i * jk-plane-siz    552   // index = k + j * k-size + i * jk-plane-size
693                                                   553 
694   // nested : z -> phi -> r                       554   // nested : z -> phi -> r
695   G4int i  = IZ;                               << 555   G4int i = IZ;
696   G4int j  = IPHI;                             << 556   G4int j = IPHI;
697   G4int k  = IR;                               << 557   G4int k = IR;
698   G4int jk = fNSegment[j] * fNSegment[k];      << 558   G4int jk = fNSegment[j]*fNSegment[k];
699   q[i]     = index / jk;                       << 559   q[i] = index/jk;
700   q[j]     = (index - q[i] * jk) / fNSegment[k << 560   q[j] = (index - q[i]*jk)/fNSegment[k];
701   q[k]     = index - q[j] * fNSegment[k] - q[i << 561   q[k] = index - q[j]*fNSegment[k] - q[i]*jk;
702 }                                              << 
703                                                << 
704 void G4ScoringCylinder::DumpVolumes()          << 
705 {                                              << 
706   G4int lvl = 2;                               << 
707   DumpSolids(lvl);                             << 
708   DumpLogVols(lvl);                            << 
709   DumpPhysVols(lvl);                           << 
710 }                                              << 
711                                                << 
712 void G4ScoringCylinder::DumpSolids(G4int lvl)  << 
713 {                                              << 
714   G4cout << "*********** List of registered so << 
715   auto store = G4SolidStore::GetInstance();    << 
716   auto itr   = store->begin();                 << 
717   for(; itr != store->end(); itr++)            << 
718   {                                            << 
719     switch(lvl)                                << 
720     {                                          << 
721       case 0:                                  << 
722         G4cout << (*itr)->GetName() << G4endl; << 
723         break;                                 << 
724       case 1:                                  << 
725         G4cout << (*itr)->GetName() << "\t vol << 
726                << G4BestUnit((*itr)->GetCubicV << 
727                << "\t surface = "              << 
728                << G4BestUnit((*itr)->GetSurfac << 
729         break;                                 << 
730       default:                                 << 
731         (*itr)->DumpInfo();                    << 
732         break;                                 << 
733     }                                          << 
734   }                                            << 
735 }                                              << 
736                                                << 
737 void G4ScoringCylinder::DumpLogVols(G4int lvl) << 
738 {                                              << 
739   G4cout << "*********** List of registered lo << 
740          << G4endl;                            << 
741   auto store = G4LogicalVolumeStore::GetInstan << 
742   auto itr   = store->begin();                 << 
743   for(; itr != store->end(); itr++)            << 
744   {                                            << 
745     G4cout << (*itr)->GetName()                << 
746            << "\t Solid = " << (*itr)->GetSoli << 
747     if((*itr)->GetMaterial() != nullptr)       << 
748     {                                          << 
749       G4cout << "\t Material = " << (*itr)->Ge << 
750     }                                          << 
751     else                                       << 
752     {                                          << 
753       G4cout << "\t Material : not defined " < << 
754     }                                          << 
755     if(lvl < 1)                                << 
756       continue;                                << 
757     G4cout << "\t region = ";                  << 
758     if((*itr)->GetRegion() != nullptr)         << 
759     {                                          << 
760       G4cout << (*itr)->GetRegion()->GetName() << 
761     }                                          << 
762     else                                       << 
763     {                                          << 
764       G4cout << "not defined";                 << 
765     }                                          << 
766     G4cout << "\t sensitive detector = ";      << 
767     if((*itr)->GetSensitiveDetector() != nullp << 
768     {                                          << 
769       G4cout << (*itr)->GetSensitiveDetector() << 
770     }                                          << 
771     else                                       << 
772     {                                          << 
773       G4cout << "not defined";                 << 
774     }                                          << 
775     G4cout << G4endl;                          << 
776     G4cout << "\t daughters = " << (*itr)->Get << 
777     if((*itr)->GetNoDaughters() > 0)           << 
778     {                                          << 
779       switch((*itr)->CharacteriseDaughters())  << 
780       {                                        << 
781         case kNormal:                          << 
782           G4cout << " (placement)";            << 
783           break;                               << 
784         case kReplica:                         << 
785           G4cout << " (replica : " << (*itr)-> << 
786                  << ")";                       << 
787           break;                               << 
788         case kParameterised:                   << 
789           G4cout << " (parameterized : "       << 
790                  << (*itr)->GetDaughter(0)->Ge << 
791           break;                               << 
792         default:;                              << 
793       }                                        << 
794     }                                          << 
795     G4cout << G4endl;                          << 
796     if(lvl < 2)                                << 
797       continue;                                << 
798     if((*itr)->GetMaterial() != nullptr)       << 
799     {                                          << 
800       G4cout << "\t weight = " << G4BestUnit(( << 
801              << G4endl;                        << 
802     }                                          << 
803     else                                       << 
804     {                                          << 
805       G4cout << "\t weight : not available" << << 
806     }                                          << 
807   }                                            << 
808 }                                              << 
809                                                << 
810 void G4ScoringCylinder::DumpPhysVols(G4int lvl << 
811 {                                              << 
812   G4cout << "*********** List of registered ph << 
813          << G4endl;                            << 
814   auto store = G4PhysicalVolumeStore::GetInsta << 
815   auto itr   = store->begin();                 << 
816   for(; itr != store->end(); itr++)            << 
817   {                                            << 
818     switch(lvl)                                << 
819     {                                          << 
820       case 0:                                  << 
821         G4cout << (*itr)->GetName() << G4endl; << 
822         break;                                 << 
823       case 1:                                  << 
824         G4cout << (*itr)->GetName() << "\t log << 
825                << (*itr)->GetLogicalVolume()-> << 
826                << "\t mother logical = ";      << 
827         if((*itr)->GetMotherLogical() != nullp << 
828         {                                      << 
829           G4cout << (*itr)->GetMotherLogical() << 
830         }                                      << 
831         else                                   << 
832         {                                      << 
833           G4cout << "not defined";             << 
834         }                                      << 
835         G4cout << G4endl;                      << 
836         break;                                 << 
837       default:                                 << 
838         G4cout << (*itr)->GetName() << "\t log << 
839                << (*itr)->GetLogicalVolume()-> << 
840                << "\t mother logical = ";      << 
841         if((*itr)->GetMotherLogical() != nullp << 
842         {                                      << 
843           G4cout << (*itr)->GetMotherLogical() << 
844         }                                      << 
845         else                                   << 
846         {                                      << 
847           G4cout << "not defined";             << 
848         }                                      << 
849         G4cout << "\t type = ";                << 
850         switch((*itr)->VolumeType())           << 
851         {                                      << 
852           case kNormal:                        << 
853             G4cout << "placement";             << 
854             break;                             << 
855           case kReplica:                       << 
856             G4cout << "replica";               << 
857             break;                             << 
858           case kParameterised:                 << 
859             G4cout << "parameterized";         << 
860             break;                             << 
861           default:;                            << 
862         }                                      << 
863         G4cout << G4endl;                      << 
864     }                                          << 
865   }                                            << 
866 }                                                 562 }
867                                                   563