| Geant4 Cross Reference |
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,v 1.16 2010-08-30 08:15:20 akimura Exp $
>> 28 // GEANT4 tag $Name: not supported by cvs2svn $
>> 29 //
28 30
29 #include "G4ScoringCylinder.hh" 31 #include "G4ScoringCylinder.hh"
>> 32 #include "G4VPhysicalVolume.hh"
30 33
>> 34 #include "G4Tubs.hh"
31 #include "G4LogicalVolume.hh" 35 #include "G4LogicalVolume.hh"
32 #include "G4MultiFunctionalDetector.hh" << 36 #include "G4VPhysicalVolume.hh"
33 #include "G4PVDivision.hh" <<
34 #include "G4PVPlacement.hh" 37 #include "G4PVPlacement.hh"
35 #include "G4PVReplica.hh" 38 #include "G4PVReplica.hh"
36 #include "G4PhysicalConstants.hh" << 39 #include "G4PVDivision.hh"
37 #include "G4SDManager.hh" <<
38 #include "G4ScoringManager.hh" <<
39 #include "G4StatDouble.hh" <<
40 #include "G4SystemOfUnits.hh" <<
41 #include "G4Tubs.hh" <<
42 #include "G4VPhysicalVolume.hh" <<
43 #include "G4VPrimitiveScorer.hh" <<
44 #include "G4VScoreColorMap.hh" <<
45 #include "G4VVisManager.hh" <<
46 #include "G4VisAttributes.hh" 40 #include "G4VisAttributes.hh"
>> 41 #include "G4VVisManager.hh"
>> 42 #include "G4VScoreColorMap.hh"
47 43
48 #include "G4LogicalVolumeStore.hh" << 44 #include "G4SDManager.hh"
49 #include "G4Material.hh" << 45 #include "G4MultiFunctionalDetector.hh"
50 #include "G4PhysicalVolumeStore.hh" << 46 #include "G4SDParticleFilter.hh"
51 #include "G4SolidStore.hh" << 47 #include "G4VPrimitiveScorer.hh"
52 #include "G4UnitsTable.hh" << 48 #include "G4PSEnergyDeposit.hh"
53 #include "G4VSensitiveDetector.hh" << 49 #include "G4PSTrackLength.hh"
54 #include "G4VSolid.hh" << 50 #include "G4PSNofStep.hh"
>> 51 #include "G4ScoringManager.hh"
55 52
56 53
57 G4ScoringCylinder::G4ScoringCylinder(const G4S << 54 G4ScoringCylinder::G4ScoringCylinder(G4String wName)
58 : G4VScoringMesh(wName) << 55 :G4VScoringMesh(wName), fMeshElementLogical(0)
59 { 56 {
60 fShape = MeshShape::cylinder; << 57 fShape = cylinderMesh;
61 58
62 fDivisionAxisNames[0] = "Z"; 59 fDivisionAxisNames[0] = "Z";
63 fDivisionAxisNames[1] = "PHI"; 60 fDivisionAxisNames[1] = "PHI";
64 fDivisionAxisNames[2] = "R"; 61 fDivisionAxisNames[2] = "R";
65 } 62 }
66 63
67 void G4ScoringCylinder::SetupGeometry(G4VPhysi << 64 G4ScoringCylinder::~G4ScoringCylinder()
>> 65 {;}
>> 66
>> 67 void G4ScoringCylinder::Construct(G4VPhysicalVolume* fWorldPhys)
68 { 68 {
69 if(verboseLevel > 9) << 69 if(fConstructed) {
70 G4cout << "G4ScoringCylinder::SetupGeometr << 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
>> 83 void G4ScoringCylinder::SetupGeometry(G4VPhysicalVolume * fWorldPhys) {
>> 84
>> 85 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::SetupGeometry() ..." << G4endl;
71 86
72 // World 87 // World
73 G4VPhysicalVolume* scoringWorld = fWorldPhys << 88 G4VPhysicalVolume * scoringWorld = fWorldPhys;
74 G4LogicalVolume* worldLogical = scoringWor << 89 G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume();
75 90
76 // Scoring Mesh 91 // Scoring Mesh
77 if(verboseLevel > 9) << 92 if(verboseLevel > 9) G4cout << fWorldName << G4endl;
78 G4cout << fWorldName << G4endl; << 93 G4String tubsName = fWorldName+"_mesh";
79 G4String tubsName = fWorldName + "_mesh"; <<
80 94
81 if(verboseLevel > 9) << 95 if(verboseLevel > 9) G4cout << "R max., Dz =: " << fSize[0] << ", " << fSize[1] << G4endl;
82 { << 96 G4VSolid * tubsSolid = new G4Tubs(tubsName+"0", // name
83 G4cout << "R min, R max., Dz =: " << fSize << 97 0., // R min
84 << ", " << 98 fSize[0], // R max
85 } << 99 fSize[1], // Dz
86 G4VSolid* tubsSolid = new G4Tubs(tu << 100 0., // starting phi
87 fSize[0], << 101 twopi*rad); // segment phi
88 fSize[1], << 102 G4LogicalVolume * tubsLogical = new G4LogicalVolume(tubsSolid, 0, tubsName);
89 fSize[2], << 103 new G4PVPlacement(fRotationMatrix, fCenterPosition,
90 fAngle[0], << 104 tubsLogical, tubsName+"0", worldLogical, false, 0);
91 fAngle[1]); << 105
92 auto tubsLogical = new G4LogicalVolume(tubs << 106 if(verboseLevel > 9) G4cout << " # of segments : r, phi, z =: "
93 new G4PVPlacement(fRotationMatrix, fCenterPo << 107 << fNSegment[IR] << ", " << fNSegment[IPHI] << ", " << fNSegment[IZ] << G4endl;
94 tubsName + "0", worldLogic << 108
95 << 109 G4String layerName[2] = {tubsName + "1", tubsName + "2"};
96 if(verboseLevel > 9) << 110 G4VSolid * layerSolid[2];
97 G4cout << " # of segments : r, phi, z =: " << 111 G4LogicalVolume * layerLogical[2];
98 << fNSegment[IPHI] << ", " << fNSeg <<
99 <<
100 G4String layerName[2] = { tubsName + "1", tu <<
101 G4VSolid* layerSolid[2]; <<
102 G4LogicalVolume* layerLogical[2]; <<
103 112
104 //-- fisrt nested layer (replicated along z 113 //-- fisrt nested layer (replicated along z direction)
105 if(verboseLevel > 9) << 114 if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
106 G4cout << "layer 1 :" << G4endl; << 115 layerSolid[0] = new G4Tubs(layerName[0], // name
107 layerSolid[0] = new G4Tubs(layerName[0], << 116 0., // inner radius
108 fSize[0], << 117 fSize[0], // outer radius
109 fSize[1], << 118 fSize[1]/fNSegment[IZ], // half len. in z
110 fSize[2] / fNSegm << 119 0., // starting phi angle
111 fAngle[0], << 120 twopi*rad); // delta angle of the segment
112 fAngle[1]); // d << 121 layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
113 layerLogical[0] = new G4LogicalVolume(layerS << 122 if(fNSegment[IZ] > 1) {
114 if(fNSegment[IZ] > 1) << 123 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction" << G4endl;
115 { << 124 if(G4ScoringManager::GetReplicaLevel()>0) {
116 if(verboseLevel > 9) << 125 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
117 G4cout << "G4ScoringCylinder::Construct( << 126 new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 2.*fSize[1]/fNSegment[IZ]);
118 << G4endl; << 127 } else {
119 if(G4ScoringManager::GetReplicaLevel() > 0 << 128 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
120 { << 129 new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kZAxis, fNSegment[IZ], 0.);
121 if(verboseLevel > 9) << 130 }
122 G4cout << "G4ScoringCylinder::Construc << 131 } else if(fNSegment[IZ] == 1) {
123 new G4PVReplica(layerName[0], layerLogic << 132 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
124 fNSegment[IZ], 2. * fSiz << 133 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], tubsLogical, false, 0);
125 } << 134 } 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 135 G4cerr << "G4ScoringCylinder::SetupGeometry() : invalid parameter ("
144 << fNSegment[IZ] << ") " << 136 << fNSegment[IZ] << ") "
145 << "in placement of the first neste << 137 << "in placement of the first nested layer." << G4endl;
146 } 138 }
147 139
148 // second nested layer (replicated along phi 140 // second nested layer (replicated along phi direction)
149 if(verboseLevel > 9) << 141 if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
150 G4cout << "layer 2 :" << G4endl; << 142 layerSolid[1] = new G4Tubs(layerName[1],
151 layerSolid[1] = << 143 0.,
152 new G4Tubs(layerName[1], fSize[0], fSize[1 << 144 fSize[0],
153 fAngle[0], fAngle[1] / fNSegmen << 145 fSize[1]/fNSegment[IZ],
154 layerLogical[1] = new G4LogicalVolume(layerS << 146 0.,
155 if(fNSegment[IPHI] > 1) << 147 twopi*rad/fNSegment[IPHI]);
156 { << 148 layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
157 if(verboseLevel > 9) << 149 if(fNSegment[IPHI] > 1) {
158 G4cout << "G4ScoringCylinder::Construct( << 150 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction" << G4endl;
159 << G4endl; << 151 if(G4ScoringManager::GetReplicaLevel()>1) {
160 if(G4ScoringManager::GetReplicaLevel() > 1 << 152 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
161 { <<
162 if(verboseLevel > 9) <<
163 G4cout << "G4ScoringCylinder::Construc <<
164 new G4PVReplica(layerName[1], layerLogic 153 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kPhi,
165 fNSegment[IPHI], fAngle[ << 154 fNSegment[IPHI], twopi*rad/fNSegment[IPHI]);
166 } << 155 } else {
167 else << 156 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
168 { << 157 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kPhi, fNSegment[IPHI], 0.);
169 if(verboseLevel > 9) << 158 }
170 G4cout << "G4ScoringCylinder::Construc << 159 } else if(fNSegment[IPHI] == 1) {
171 new G4PVDivision(layerName[1], layerLogi << 160 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
172 fNSegment[IPHI], 0.); << 161 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
173 } << 162 } 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 163 G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
184 << fNSegment[IPHI] << ") " << 164 << fNSegment[IPHI] << ") "
185 << "in placement of the second nest << 165 << "in placement of the second nested layer." << G4endl;
186 166
187 // mesh elements 167 // mesh elements
188 if(verboseLevel > 9) << 168 if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
189 G4cout << "mesh elements :" << G4endl; << 169 G4String elementName = tubsName +"3";
190 G4String elementName = tubsName + "3"; << 170 G4VSolid * elementSolid = new G4Tubs(elementName,
191 G4VSolid* elementSolid = new G4Tubs( << 171 0.,
192 elementName, fSize[0], (fSize[1] - fSize[0 << 172 fSize[0]/fNSegment[IR],
193 fSize[2] / fNSegment[IZ], fAngle[0], fAngl << 173 fSize[1]/fNSegment[IZ],
194 fMeshElementLogical = new G4LogicalVolume(el << 174 0.,
195 if(fNSegment[IR] >= 1) << 175 twopi*rad/fNSegment[IPHI]);
196 { << 176 fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
197 if(verboseLevel > 9) << 177 if(fNSegment[IR] > 1) {
198 G4cout << "G4ScoringCylinder::Construct( << 178
199 << G4endl; << 179 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction" << G4endl;
200 << 180
201 if(G4ScoringManager::GetReplicaLevel() > 2 << 181 if(G4ScoringManager::GetReplicaLevel()>2) {
202 { << 182 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
203 if(verboseLevel > 9) <<
204 G4cout << "G4ScoringCylinder::Construc <<
205 new G4PVReplica(elementName, fMeshElemen 183 new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kRho,
206 fNSegment[IR], (fSize[1] << 184 fNSegment[IR], fSize[0]/fNSegment[IR]);
207 fSize[0]); << 185 } else {
208 } << 186 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
209 else << 187 new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kRho, fNSegment[IR], 0.);
210 { << 188 }
211 if(verboseLevel > 9) << 189 } else if(fNSegment[IR] == 1) {
212 G4cout << "G4ScoringCylinder::Construc << 190 if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
213 new G4PVDivision(elementName, fMeshEleme << 191 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
214 fNSegment[IR], 0.); << 192 } else {
215 } <<
216 } <<
217 else <<
218 { <<
219 G4cerr << "G4ScoringCylinder::SetupGeometr 193 G4cerr << "G4ScoringCylinder::SetupGeometry() : "
220 << "invalid parameter (" << fNSegme << 194 << "invalid parameter (" << fNSegment[IR] << ") "
221 << "in mesh element placement." << << 195 << "in mesh element placement." << G4endl;
222 } 196 }
223 197
224 // set the sensitive detector 198 // set the sensitive detector
225 fMeshElementLogical->SetSensitiveDetector(fM 199 fMeshElementLogical->SetSensitiveDetector(fMFD);
>> 200
226 201
227 // vis. attributes 202 // vis. attributes
228 auto visatt = new G4VisAttributes(G4Colour( << 203 G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
229 visatt->SetVisibility(true); 204 visatt->SetVisibility(true);
230 layerLogical[0]->SetVisAttributes(visatt); 205 layerLogical[0]->SetVisAttributes(visatt);
231 layerLogical[1]->SetVisAttributes(visatt); 206 layerLogical[1]->SetVisAttributes(visatt);
232 visatt = new G4VisAttributes(G4Colour(.5, .5 << 207 visatt = new G4VisAttributes(G4Colour(.5,.5,.5,0.01));
233 // visatt->SetForceSolid(true); << 208 //visatt->SetForceSolid(true);
234 fMeshElementLogical->SetVisAttributes(visatt 209 fMeshElementLogical->SetVisAttributes(visatt);
235 <<
236 if(verboseLevel > 9) <<
237 DumpVolumes(); <<
238 } 210 }
239 211
240 void G4ScoringCylinder::List() const << 212 void G4ScoringCylinder::List() const {
241 { << 213 G4cout << "G4ScoringCylinder : " << fWorldName << " --- Shape: Cylindrical mesh" << G4endl;
242 G4cout << "G4ScoringCylinder : " << fWorldNa <<
243 << " --- Shape: Cylindrical mesh" << <<
244 214
245 G4cout << " Size (Rmin, Rmax, Dz): (" << fSi << 215 G4cout << " Size (R, Dz): ("
246 << fSize[1] / cm << ", " << fSize[2] << 216 << fSize[0]/cm << ", "
247 G4cout << " Angle (start, span): (" << fAngl << 217 << fSize[1]/cm << ") [cm]"
248 << fAngle[1] / deg << ") [deg]" << G4 << 218 << G4endl;
249 219
250 G4VScoringMesh::List(); 220 G4VScoringMesh::List();
251 } 221 }
252 222
253 void G4ScoringCylinder::Draw(RunScore* map, G4 << 223
254 G4int axflg) << 224 void G4ScoringCylinder::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
255 { << 225
256 G4VVisManager* pVisManager = G4VVisManager:: << 226 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
257 if(pVisManager != nullptr) << 227 if(pVisManager) {
258 { << 228
259 // cell vectors 229 // cell vectors
260 std::vector<G4double> ephi; << 230 std::vector<double> ephi;
261 for(G4int phi = 0; phi < fNSegment[IPHI]; << 231 for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
262 ephi.push_back(0.); <<
263 //- 232 //-
264 std::vector<std::vector<G4double>> zphicel << 233 std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
265 for(G4int z = 0; z < fNSegment[IZ]; z++) << 234 for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
266 zphicell.push_back(ephi); <<
267 //- 235 //-
268 std::vector<std::vector<G4double>> rphicel << 236 std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
269 for(G4int r = 0; r < fNSegment[IR]; r++) << 237 for(int r = 0; r < fNSegment[IR]; r++) rphicell.push_back(ephi);
270 rphicell.push_back(ephi); <<
271 238
272 // projections 239 // projections
273 G4int q[3]; 240 G4int q[3];
274 auto itr = map->GetMap()->begin(); << 241 std::map<G4int, G4double*>::iterator itr = map->begin();
275 for(; itr != map->GetMap()->end(); itr++) << 242 for(; itr != map->end(); itr++) {
276 { << 243 if(itr->first < 0) {
277 if(itr->first < 0) << 244 G4cout << itr->first << G4endl;
278 { << 245 continue;
279 G4cout << itr->first << G4endl; <<
280 continue; <<
281 } 246 }
282 GetRZPhi(itr->first, q); 247 GetRZPhi(itr->first, q);
283 248
284 zphicell[q[IZ]][q[IPHI]] += (itr->second << 249 zphicell[q[IZ]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
285 rphicell[q[IR]][q[IPHI]] += (itr->second << 250 rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
286 } << 251 }
287 << 252
288 // search min./max. values 253 // search min./max. values
289 G4double zphimin = DBL_MAX, rphimin = DBL_ 254 G4double zphimin = DBL_MAX, rphimin = DBL_MAX;
290 G4double zphimax = 0., rphimax = 0.; 255 G4double zphimax = 0., rphimax = 0.;
291 for(G4int iphi = 0; iphi < fNSegment[IPHI] << 256 for(int iphi = 0; iphi < fNSegment[IPHI]; iphi++) {
292 { << 257 for(int iz = 0; iz < fNSegment[IZ]; iz++) {
293 for(G4int iz = 0; iz < fNSegment[IZ]; iz << 258 if(zphimin > zphicell[iz][iphi]) zphimin = zphicell[iz][iphi];
294 { << 259 if(zphimax < zphicell[iz][iphi]) zphimax = zphicell[iz][iphi];
295 if(zphimin > zphicell[iz][iphi]) << 260 }
296 zphimin = zphicell[iz][iphi]; << 261 for(int ir = 0; ir < fNSegment[IR]; ir++) {
297 if(zphimax < zphicell[iz][iphi]) << 262 if(rphimin > rphicell[ir][iphi]) rphimin = rphicell[ir][iphi];
298 zphimax = zphicell[iz][iphi]; << 263 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 } 264 }
307 } 265 }
308 266
309 G4VisAttributes att; 267 G4VisAttributes att;
310 att.SetForceSolid(true); 268 att.SetForceSolid(true);
311 att.SetForceAuxEdgeVisible(true); 269 att.SetForceAuxEdgeVisible(true);
312 270
>> 271
313 G4Scale3D scale; 272 G4Scale3D scale;
314 if(axflg / 100 == 1) << 273 if(axflg/100==1) {
315 { <<
316 // rz plane 274 // rz plane
317 } 275 }
318 axflg = axflg % 100; << 276 axflg = axflg%100;
319 if(axflg / 10 == 1) << 277 if(axflg/10==1) {
320 { <<
321 pVisManager->BeginDraw(); <<
322 <<
323 // z-phi plane 278 // z-phi plane
324 if(colorMap->IfFloatMinMax()) << 279 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin, zphimax); }
325 { << 280
326 colorMap->SetMinMax(zphimin, zphimax); << 281 G4double zhalf = fSize[1]/fNSegment[IZ];
327 } << 282 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
328 << 283 for(int z = 0; z < fNSegment[IZ]; z++) {
329 G4double zhalf = fSize[2] / fNSegment[IZ << 284 //-
330 for(G4int phi = 0; phi < fNSegment[IPHI] << 285 G4double angle = twopi/fNSegment[IPHI]*phi;
331 { << 286 G4double dphi = twopi/fNSegment[IPHI];
332 for(G4int z = 0; z < fNSegment[IZ]; z+ << 287 G4Tubs cylinder("z-phi", // name
333 { << 288 fSize[0]*0.99, fSize[0], // inner radius, outer radius
334 //- << 289 zhalf, // half length in z
335 G4double angle = fAngle[0] + fAngle[ << 290 angle, dphi*0.99999); // starting phi angle, delta angle
336 G4double dphi = fAngle[1] / fNSegme << 291 //-
337 G4Tubs cylinder( << 292 G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
338 "z-phi", // nam << 293 G4Transform3D trans;
339 fSize[1] * 0.99, fSize[1], // inn << 294 if(fRotationMatrix) {
340 zhalf, // hal << 295 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
341 angle, dphi * 0.99999); // sta << 296 trans = G4Translate3D(fCenterPosition)*trans;
342 //- << 297 } else {
343 G4ThreeVector zpos( << 298 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
344 0., 0., -fSize[2] + fSize[2] / fNS << 299 }
345 G4Transform3D trans; << 300 G4double c[4];
346 if(fRotationMatrix != nullptr) << 301 colorMap->GetMapColor(zphicell[z][phi], c);
347 { << 302 att.SetColour(c[0], c[1], c[2]);//, c[3]);
348 trans = << 303 //-
349 G4Rotate3D(*fRotationMatrix).inv << 304 pVisManager->Draw(cylinder, att, trans);
350 trans = G4Translate3D(fCenterPosit << 305 }
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 } 306 }
366 pVisManager->EndDraw(); <<
367 } 307 }
368 axflg = axflg % 10; << 308 axflg = axflg%10;
369 if(axflg == 1) << 309 if(axflg==1) {
370 { <<
371 pVisManager->BeginDraw(); <<
372 <<
373 // r-phi plane 310 // r-phi plane
374 if(colorMap->IfFloatMinMax()) << 311 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 312
423 pVisManager->EndDraw(); << 313 G4double rsize = fSize[0]/fNSegment[IR];
>> 314 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
>> 315 for(int r = 0; r < fNSegment[IR]; r++) {
>> 316
>> 317 G4double rs[2] = {rsize*r, rsize*(r+1)};
>> 318 G4double angle = twopi/fNSegment[IPHI]*phi;
>> 319 G4double dphi = twopi/fNSegment[IPHI];
>> 320 G4Tubs cylinder("z-phi", rs[0], rs[1], 0.001,
>> 321 angle, dphi*0.99999);
>> 322 /*
>> 323 G4cout << ">>>> "
>> 324 << rs[0] << " - " << rs[1] << " : "
>> 325 << angle << " - " << angle + dphi
>> 326 << G4endl;
>> 327 */
>> 328
>> 329 G4ThreeVector zposn(0., 0., -fSize[1]);
>> 330 G4ThreeVector zposp(0., 0., fSize[1]);
>> 331 G4Transform3D transn, transp;
>> 332 if(fRotationMatrix) {
>> 333 transn = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposn);
>> 334 transn = G4Translate3D(fCenterPosition)*transn;
>> 335 transp = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zposp);
>> 336 transp = G4Translate3D(fCenterPosition)*transp;
>> 337 } else {
>> 338 transn = G4Translate3D(zposn)*G4Translate3D(fCenterPosition);
>> 339 transp = G4Translate3D(zposp)*G4Translate3D(fCenterPosition);
>> 340 }
>> 341 G4double c[4];
>> 342 colorMap->GetMapColor(rphicell[r][phi], c);
>> 343 att.SetColour(c[0], c[1], c[2]);//, c[3]);
>> 344 /*
>> 345 G4cout << " " << c[0] << ", "
>> 346 << c[1] << ", " << c[2] << G4endl;
>> 347 */
>> 348 pVisManager->Draw(cylinder, att, transn);
>> 349 pVisManager->Draw(cylinder, att, transp);
>> 350 }
>> 351 }
424 } 352 }
425 353
426 colorMap->SetPSUnit(fDrawUnit); 354 colorMap->SetPSUnit(fDrawUnit);
427 colorMap->SetPSName(fDrawPSName); 355 colorMap->SetPSName(fDrawPSName);
428 colorMap->DrawColorChart(); 356 colorMap->DrawColorChart();
>> 357
429 } 358 }
430 } 359 }
431 360
432 void G4ScoringCylinder::DrawColumn(RunScore* m << 361 void G4ScoringCylinder::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap,
433 G4int idxPr << 362 G4int idxProj, G4int idxColumn)
434 { 363 {
435 G4int projAxis = 0; 364 G4int projAxis = 0;
436 switch(idxProj) << 365 switch(idxProj) {
437 { << 366 case 0:
438 case 0: << 367 projAxis = IR;
439 projAxis = IR; << 368 break;
440 break; << 369 case 1:
441 case 1: << 370 projAxis = IZ;
442 projAxis = IZ; << 371 break;
443 break; << 372 case 2:
444 case 2: << 373 projAxis = IPHI;
445 projAxis = IPHI; << 374 break;
446 break; <<
447 } 375 }
448 376
449 if(idxColumn < 0 || idxColumn >= fNSegment[p << 377 if(idxColumn<0 || idxColumn>=fNSegment[projAxis])
450 { 378 {
451 G4cerr << "Warning : Column number " << id << 379 G4cerr << "Warning : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[projAxis]-1 <<
452 << " is out of scoring mesh [0," << << 380 "]. Method ignored." << G4endl;
453 << "]. Method ignored." << G4endl; <<
454 return; 381 return;
455 } 382 }
456 G4VVisManager* pVisManager = G4VVisManager:: << 383 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
457 if(pVisManager != nullptr) << 384 if(pVisManager) {
458 { << 385
459 // cell vectors 386 // cell vectors
460 std::vector<std::vector<std::vector<G4doub << 387 std::vector<std::vector<std::vector<double> > > cell; // cell[R][Z][PHI]
461 std::vector<G4double> ephi; << 388 std::vector<double> ephi;
462 for(G4int phi = 0; phi < fNSegment[IPHI]; << 389 for(int phi = 0; phi < fNSegment[IPHI]; phi++) ephi.push_back(0.);
463 ephi.push_back(0.); << 390 std::vector<std::vector<double> > ezphi;
464 std::vector<std::vector<G4double>> ezphi; << 391 for(int z = 0; z < fNSegment[IZ]; z++) ezphi.push_back(ephi);
465 for(G4int z = 0; z < fNSegment[IZ]; z++) << 392 for(int r = 0; r < fNSegment[IR]; r++) cell.push_back(ezphi);
466 ezphi.push_back(ephi); << 393
467 for(G4int r = 0; r < fNSegment[IR]; r++) << 394 std::vector<std::vector<double> > rzcell; // rzcell[R][Z]
468 cell.push_back(ezphi); << 395 std::vector<double> ez;
469 << 396 for(int z = 0; z < fNSegment[IZ]; z++) ez.push_back(0.);
470 std::vector<std::vector<G4double>> rzcell; << 397 for(int r = 0; r < fNSegment[IR]; r++) rzcell.push_back(ez);
471 std::vector<G4double> ez; << 398
472 for(G4int z = 0; z < fNSegment[IZ]; z++) << 399 std::vector<std::vector<double> > zphicell; // zphicell[Z][PHI]
473 ez.push_back(0.); << 400 for(int z = 0; z < fNSegment[IZ]; z++) zphicell.push_back(ephi);
474 for(G4int r = 0; r < fNSegment[IR]; r++) << 401
475 rzcell.push_back(ez); << 402 std::vector<std::vector<double> > rphicell; // rphicell[R][PHI]
476 << 403 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 404
485 // projections 405 // projections
486 G4int q[3]; 406 G4int q[3];
487 auto itr = map->GetMap()->begin(); << 407 std::map<G4int, G4double*>::iterator itr = map->begin();
488 for(; itr != map->GetMap()->end(); itr++) << 408 for(; itr != map->end(); itr++) {
489 { << 409 if(itr->first < 0) {
490 if(itr->first < 0) << 410 G4cout << itr->first << G4endl;
491 { << 411 continue;
492 G4cout << itr->first << G4endl; <<
493 continue; <<
494 } 412 }
495 GetRZPhi(itr->first, q); 413 GetRZPhi(itr->first, q);
496 414
497 if(projAxis == IR && q[IR] == idxColumn) << 415 if(projAxis == IR && q[IR] == idxColumn) { // zphi plane
498 { // zphi plane << 416 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 } 417 }
509 } << 418 if(projAxis == IZ && q[IZ] == idxColumn) { // rphi plane
>> 419 rphicell[q[IR]][q[IPHI]] += *(itr->second)/fDrawUnitValue;
>> 420 }
>> 421 if(projAxis == IPHI && q[IPHI] == idxColumn) { // rz plane
>> 422 rzcell[q[IR]][q[IZ]] += *(itr->second)/fDrawUnitValue;
>> 423 }
>> 424 }
510 425
511 // search min./max. values 426 // search min./max. values
512 G4double rzmin = DBL_MAX, zphimin = DBL_MA 427 G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
513 G4double rzmax = 0., zphimax = 0., rphimax 428 G4double rzmax = 0., zphimax = 0., rphimax = 0.;
514 for(G4int r = 0; r < fNSegment[IR]; r++) << 429 for(int r = 0; r < fNSegment[IR]; r++) {
515 { << 430 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
516 for(G4int phi = 0; phi < fNSegment[IPHI] << 431 if(rphimin > rphicell[r][phi]) rphimin = rphicell[r][phi];
517 { << 432 if(rphimax < rphicell[r][phi]) rphimax = rphicell[r][phi];
518 if(rphimin > rphicell[r][phi]) << 433 }
519 rphimin = rphicell[r][phi]; << 434 for(int z = 0; z < fNSegment[IZ]; z++) {
520 if(rphimax < rphicell[r][phi]) << 435 if(rzmin > rzcell[r][z]) rzmin = rzcell[r][z];
521 rphimax = rphicell[r][phi]; << 436 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 } 437 }
530 } 438 }
531 for(G4int z = 0; z < fNSegment[IZ]; z++) << 439 for(int z = 0; z < fNSegment[IZ]; z++) {
532 { << 440 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
533 for(G4int phi = 0; phi < fNSegment[IPHI] << 441 if(zphimin > zphicell[z][phi]) zphimin = zphicell[z][phi];
534 { << 442 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 } 443 }
540 } 444 }
541 445
>> 446
542 G4VisAttributes att; 447 G4VisAttributes att;
543 att.SetForceSolid(true); 448 att.SetForceSolid(true);
544 att.SetForceAuxEdgeVisible(true); 449 att.SetForceAuxEdgeVisible(true);
545 450
546 pVisManager->BeginDraw(); <<
547 451
548 G4Scale3D scale; 452 G4Scale3D scale;
549 // z-phi plane 453 // z-phi plane
550 if(projAxis == IR) << 454 if(projAxis == IR) {
551 { << 455 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(zphimin,zphimax); }
552 if(colorMap->IfFloatMinMax()) << 456
553 { << 457 G4double zhalf = fSize[1]/fNSegment[IZ];
554 colorMap->SetMinMax(zphimin, zphimax); << 458 G4double rsize[2] = {fSize[0]/fNSegment[IR]*idxColumn,
555 } << 459 fSize[0]/fNSegment[IR]*(idxColumn+1)};
556 << 460 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
557 G4double zhalf = fSize[2] / fNSegment << 461 for(int z = 0; z < fNSegment[IZ]; z++) {
558 G4double rsize[2] = { << 462
559 fSize[0] + (fSize[1] - fSize[0]) / fNS << 463 G4double angle = twopi/fNSegment[IPHI]*phi*radian;
560 fSize[0] + (fSize[1] - fSize[0]) / fNS << 464 G4double dphi = twopi/fNSegment[IPHI]*radian;
561 }; << 465 G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf,
562 for(int phi = 0; phi < fNSegment[IPHI]; << 466 angle, dphi*0.99999);
563 { << 467
564 for(int z = 0; z < fNSegment[IZ]; z++) << 468 G4ThreeVector zpos(0., 0., -fSize[1] + fSize[1]/fNSegment[IZ]*(1 + 2.*z));
565 { << 469 G4Transform3D trans;
566 G4double angle = fAngle[0] + fAngle[ << 470 if(fRotationMatrix) {
567 G4double dphi = fAngle[1] / fNSegme << 471 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
568 G4Tubs cylinder("z-phi", rsize[0], r << 472 trans = G4Translate3D(fCenterPosition)*trans;
569 dphi * 0.99999); << 473 } else {
570 << 474 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
571 G4ThreeVector zpos( << 475 }
572 0., 0., -fSize[2] + fSize[2] / fNS << 476 G4double c[4];
573 G4Transform3D trans; << 477 colorMap->GetMapColor(zphicell[z][phi], c);
574 if(fRotationMatrix != nullptr) << 478 att.SetColour(c[0], c[1], c[2]);//, c[3]);
575 { << 479 pVisManager->Draw(cylinder, att, trans);
576 trans = << 480 }
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 } 481 }
594 482
595 // r-phi plane 483 // r-phi plane
596 } << 484 } else if(projAxis == IZ) {
597 else if(projAxis == IZ) << 485 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rphimin,rphimax); }
598 { << 486
599 if(colorMap->IfFloatMinMax()) << 487 G4double rsize = fSize[0]/fNSegment[IR];
600 { << 488 for(int phi = 0; phi < fNSegment[IPHI]; phi++) {
601 colorMap->SetMinMax(rphimin, rphimax); << 489 for(int r = 0; r < fNSegment[IR]; r++) {
602 } << 490
603 << 491 G4double rs[2] = {rsize*r, rsize*(r+1)};
604 G4double rsize = (fSize[1] - fSize[0]) / << 492 G4double angle = twopi/fNSegment[IPHI]*phi*radian;
605 for(G4int phi = 0; phi < fNSegment[IPHI] << 493 G4double dz = fSize[1]/fNSegment[IZ];
606 { << 494 G4double dphi = twopi/fNSegment[IPHI]*radian;
607 for(G4int r = 0; r < fNSegment[IR]; r+ << 495 G4Tubs cylinder("r-phi", rs[0], rs[1], dz,
608 { << 496 angle, dphi*0.99999);
609 G4double rs[2] = { fSize[0] + rsize << 497 G4ThreeVector zpos(0., 0.,
610 G4double angle = fAngle[0] + fAngle[ << 498 -fSize[1]+fSize[1]/fNSegment[IZ]*(idxColumn*2+1));
611 G4double dz = fSize[2] / fNSegmen << 499 G4Transform3D trans;
612 G4double dphi = fAngle[1] / fNSegme << 500 if(fRotationMatrix) {
613 G4Tubs cylinder("r-phi", rs[0], rs[1 << 501 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
614 G4ThreeVector zpos( << 502 trans = G4Translate3D(fCenterPosition)*trans;
615 0., 0., -fSize[2] + fSize[2] / fNS << 503 } else {
616 G4Transform3D trans; << 504 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
617 if(fRotationMatrix != nullptr) << 505 }
618 { << 506 G4double c[4];
619 trans = << 507 colorMap->GetMapColor(rphicell[r][phi], c);
620 G4Rotate3D(*fRotationMatrix).inv << 508 att.SetColour(c[0], c[1], c[2]);//, c[3]);
621 trans = G4Translate3D(fCenterPosit << 509 pVisManager->Draw(cylinder, att, trans);
622 } << 510 }
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 } 511 }
637 512
638 // r-z plane 513 // r-z plane
639 } << 514 } else if(projAxis == IPHI) {
640 else if(projAxis == IPHI) << 515 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(rzmin,rzmax); }
641 { << 516
642 if(colorMap->IfFloatMinMax()) << 517 G4double rsize = fSize[0]/fNSegment[IR];
643 { << 518 G4double zhalf = fSize[1]/fNSegment[IZ];
644 colorMap->SetMinMax(rzmin, rzmax); << 519 G4double angle = twopi/fNSegment[IPHI]*idxColumn*radian;
645 } << 520 G4double dphi = twopi/fNSegment[IPHI]*radian;
646 << 521 for(int z = 0; z < fNSegment[IZ]; z++) {
647 G4double rsize = (fSize[1] - fSize[0]) / << 522 for(int r = 0; r < fNSegment[IR]; r++) {
648 G4double zhalf = fSize[2] / fNSegment[IZ << 523
649 G4double angle = fAngle[0] + fAngle[1] / << 524 G4double rs[2] = {rsize*r, rsize*(r+1)};
650 G4double dphi = fAngle[1] / fNSegment[I << 525 G4Tubs cylinder("z-phi", rs[0], rs[1], zhalf,
651 for(G4int z = 0; z < fNSegment[IZ]; z++) << 526 angle, dphi);
652 { << 527
653 for(G4int r = 0; r < fNSegment[IR]; r+ << 528 G4ThreeVector zpos(0., 0.,
654 { << 529 -fSize[1]+fSize[1]/fNSegment[IZ]*(2.*z+1));
655 G4double rs[2] = { fSize[0] + rsize << 530 G4Transform3D trans;
656 G4Tubs cylinder("z-phi", rs[0], rs[1 << 531 if(fRotationMatrix) {
657 << 532 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(zpos);
658 G4ThreeVector zpos( << 533 trans = G4Translate3D(fCenterPosition)*trans;
659 0., 0., -fSize[2] + fSize[2] / fNS << 534 } else {
660 G4Transform3D trans; << 535 trans = G4Translate3D(zpos)*G4Translate3D(fCenterPosition);
661 if(fRotationMatrix != nullptr) << 536 }
662 { << 537 G4double c[4];
663 trans = << 538 colorMap->GetMapColor(rzcell[r][z], c);
664 G4Rotate3D(*fRotationMatrix).inv << 539 att.SetColour(c[0], c[1], c[2]);//, c[3]);
665 trans = G4Translate3D(fCenterPosit << 540 pVisManager->Draw(cylinder, att, trans);
666 } << 541 }
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 } 542 }
681 } 543 }
682 pVisManager->EndDraw(); <<
683 } 544 }
684 545
685 colorMap->SetPSUnit(fDrawUnit); 546 colorMap->SetPSUnit(fDrawUnit);
686 colorMap->SetPSName(fDrawPSName); 547 colorMap->SetPSName(fDrawPSName);
687 colorMap->DrawColorChart(); 548 colorMap->DrawColorChart();
>> 549
688 } 550 }
689 551
690 void G4ScoringCylinder::GetRZPhi(G4int index, << 552 void G4ScoringCylinder::GetRZPhi(G4int index, G4int q[3]) const {
691 { <<
692 // index = k + j * k-size + i * jk-plane-siz 553 // index = k + j * k-size + i * jk-plane-size
693 554
694 // nested : z -> phi -> r 555 // nested : z -> phi -> r
695 G4int i = IZ; << 556 G4int i = IZ;
696 G4int j = IPHI; << 557 G4int j = IPHI;
697 G4int k = IR; << 558 G4int k = IR;
698 G4int jk = fNSegment[j] * fNSegment[k]; << 559 G4int jk = fNSegment[j]*fNSegment[k];
699 q[i] = index / jk; << 560 q[i] = index/jk;
700 q[j] = (index - q[i] * jk) / fNSegment[k << 561 q[j] = (index - q[i]*jk)/fNSegment[k];
701 q[k] = index - q[j] * fNSegment[k] - q[i << 562 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 } 563 }
867 564