| 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 // G4ScoringBox << 26 //
27 // ------------------------------------------- << 27 // $Id: G4ScoringBox.cc,v 1.54 2008/08/29 02:50:05 akimura Exp $
>> 28 // GEANT4 tag $Name: geant4-09-02-patch-04 $
>> 29 //
28 30
29 #include "G4ScoringBox.hh" 31 #include "G4ScoringBox.hh"
30 32
31 #include "G4Box.hh" 33 #include "G4Box.hh"
32 #include "G4LogicalVolume.hh" 34 #include "G4LogicalVolume.hh"
33 #include "G4VPhysicalVolume.hh" 35 #include "G4VPhysicalVolume.hh"
34 #include "G4PVPlacement.hh" 36 #include "G4PVPlacement.hh"
35 #include "G4PVReplica.hh" 37 #include "G4PVReplica.hh"
36 #include "G4PVDivision.hh" 38 #include "G4PVDivision.hh"
>> 39 #include "G4PVParameterised.hh"
37 #include "G4VisAttributes.hh" 40 #include "G4VisAttributes.hh"
>> 41 #include "G4ScoringBoxParameterisation.hh"
38 #include "G4VVisManager.hh" 42 #include "G4VVisManager.hh"
39 #include "G4VScoreColorMap.hh" 43 #include "G4VScoreColorMap.hh"
40 44
41 #include "G4MultiFunctionalDetector.hh" 45 #include "G4MultiFunctionalDetector.hh"
>> 46 #include "G4SDParticleFilter.hh"
42 #include "G4VPrimitiveScorer.hh" 47 #include "G4VPrimitiveScorer.hh"
43 #include "G4Polyhedron.hh" <<
44 48
45 #include "G4ScoringManager.hh" 49 #include "G4ScoringManager.hh"
46 #include "G4StatDouble.hh" <<
47 <<
48 #include "G4SystemOfUnits.hh" <<
49 50
50 #include <map> 51 #include <map>
51 #include <fstream> 52 #include <fstream>
52 53
53 G4ScoringBox::G4ScoringBox(const G4String& wNa << 54 G4ScoringBox::G4ScoringBox(G4String wName)
54 : G4VScoringMesh(wName) << 55 :G4VScoringMesh(wName), fSegmentDirection(-1),
55 , fSegmentDirection(-1) << 56 fMeshElementLogical(0)
>> 57 {
>> 58 fShape = boxMesh;
>> 59 }
>> 60
>> 61 G4ScoringBox::~G4ScoringBox()
56 { 62 {
57 fShape = MeshShape::box; <<
58 fDivisionAxisNames[0] = "X"; <<
59 fDivisionAxisNames[1] = "Y"; <<
60 fDivisionAxisNames[2] = "Z"; <<
61 } 63 }
62 64
63 void G4ScoringBox::SetupGeometry(G4VPhysicalVo << 65 void G4ScoringBox::Construct(G4VPhysicalVolume* fWorldPhys)
64 { 66 {
65 if(verboseLevel > 9) << 67 if(fConstructed) {
66 G4cout << "G4ScoringBox::SetupGeometry() . << 68
>> 69 if(verboseLevel > 0)
>> 70 G4cout << fWorldPhys->GetName() << " --- All quantities are reset." << G4endl;
>> 71 ResetScore();
>> 72
>> 73 } else {
>> 74 fConstructed = true;
>> 75 SetupGeometry(fWorldPhys);
>> 76 }
>> 77 }
>> 78
>> 79
>> 80
>> 81 void G4ScoringBox::SetupGeometry(G4VPhysicalVolume * fWorldPhys) {
>> 82
>> 83 if(verboseLevel > 9) G4cout << "G4ScoringBox::SetupGeometry() ..." << G4endl;
67 84
68 // World 85 // World
69 G4VPhysicalVolume* scoringWorld = fWorldPhys << 86 G4VPhysicalVolume * scoringWorld = fWorldPhys;
70 G4LogicalVolume* worldLogical = scoringWor << 87 G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume();
71 88
72 // Scoring Mesh 89 // Scoring Mesh
73 if(verboseLevel > 9) << 90 if(verboseLevel > 9) G4cout << fWorldName << G4endl;
74 G4cout << fWorldName << G4endl; <<
75 G4String boxName = fWorldName; 91 G4String boxName = fWorldName;
76 92
77 if(verboseLevel > 9) << 93 if(verboseLevel > 9) G4cout << fSize[0] << ", " << fSize[1] << ", " << fSize[2] << G4endl;
78 G4cout << fSize[0] << ", " << fSize[1] << << 94 G4VSolid * boxSolid = new G4Box(boxName+"0", fSize[0], fSize[1], fSize[2]);
79 G4VSolid* boxSolid = new G4Box(boxName + "0" << 95 G4LogicalVolume * boxLogical = new G4LogicalVolume(boxSolid, 0, boxName);
80 auto boxLogical = << 96 new G4PVPlacement(fRotationMatrix, fCenterPosition,
81 new G4LogicalVolume(boxSolid, nullptr, box << 97 boxLogical, boxName+"0", worldLogical, false, 0);
82 new G4PVPlacement(fRotationMatrix, fCenterPo << 98
83 worldLogical, false, 0); << 99 //G4double fsegment[3][3];
84 << 100 //G4int segOrder[3];
85 G4String layerName[2] = { boxName + "_1", bo << 101 //GetSegmentOrder(fSegmentDirection, fNSegment, segOrder, fsegment);
86 G4VSolid* layerSolid[2]; << 102 //EAxis axis[3] = {kXAxis, kYAxis, kZAxis};
87 G4LogicalVolume* layerLogical[2]; << 103
>> 104 G4String layerName[2] = {boxName + "1", boxName + "2"};
>> 105 G4VSolid * layerSolid[2];
>> 106 G4LogicalVolume * layerLogical[2];
88 107
89 //-- fisrt nested layer (replicated to x dir 108 //-- fisrt nested layer (replicated to x direction)
90 if(verboseLevel > 9) << 109 if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
91 G4cout << "layer 1 :" << G4endl; << 110 layerSolid[0] = new G4Box(layerName[0],
92 layerSolid[0] = << 111 fSize[0]/fNSegment[0],
93 new G4Box(layerName[0], fSize[0] / fNSegme << 112 fSize[1],
94 layerLogical[0] = new G4LogicalVolume(layerS << 113 fSize[2]);
95 if(fNSegment[0] > 1) << 114 layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
96 { << 115 if(fNSegment[0] > 1) {
97 if(verboseLevel > 9) << 116 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to x direction" << G4endl;
98 G4cout << "G4ScoringBox::Construct() : R << 117 if(G4ScoringManager::GetReplicaLevel()>0)
99 << G4endl; <<
100 if(G4ScoringManager::GetReplicaLevel() > 0 <<
101 { 118 {
102 new G4PVReplica(layerName[0], layerLogic 119 new G4PVReplica(layerName[0], layerLogical[0], boxLogical, kXAxis,
103 fNSegment[0], fSize[0] / << 120 fNSegment[0], fSize[0]/fNSegment[0]*2.);
104 } 121 }
105 else 122 else
106 { 123 {
107 new G4PVDivision(layerName[0], layerLogi 124 new G4PVDivision(layerName[0], layerLogical[0], boxLogical, kXAxis,
108 fNSegment[0], 0.); << 125 fNSegment[0], 0.);
109 } 126 }
110 } << 127 } else if(fNSegment[0] == 1) {
111 else if(fNSegment[0] == 1) << 128 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
112 { << 129 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], boxLogical, false, 0);
113 if(verboseLevel > 9) << 130 } else
114 G4cout << "G4ScoringBox::Construct() : P <<
115 new G4PVPlacement(nullptr, G4ThreeVector(0 <<
116 layerName[0], boxLogical <<
117 } <<
118 else <<
119 G4cerr << "ERROR : G4ScoringBox::SetupGeom 131 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
120 << fNSegment[0] << ") " << 132 << fNSegment[0] << ") "
121 << "in placement of the first neste << 133 << "in placement of the first nested layer." << G4endl;
122 134
123 if(verboseLevel > 9) << 135 if(verboseLevel > 9) {
124 { << 136 G4cout << fSize[0]/fNSegment[0] << ", "
125 G4cout << fSize[0] / fNSegment[0] << ", " << 137 << fSize[1] << ", "
126 << G4endl; << 138 << fSize[2] << G4endl;
127 G4cout << layerName[0] << ": kXAxis, " << << 139 G4cout << layerName[0] << ": kXAxis, "
128 << 2. * fSize[0] / fNSegment[0] << << 140 << fNSegment[0] << ", "
>> 141 << 2.*fSize[0]/fNSegment[0] << G4endl;
129 } 142 }
130 143
131 // second nested layer (replicated to y dire 144 // second nested layer (replicated to y direction)
132 if(verboseLevel > 9) << 145 if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
133 G4cout << "layer 2 :" << G4endl; << 146 layerSolid[1] = new G4Box(layerName[1],
134 layerSolid[1] = new G4Box(layerName[1], fS << 147 fSize[0]/fNSegment[0],
135 fSize[1] / fNSegme << 148 fSize[1]/fNSegment[1],
136 layerLogical[1] = new G4LogicalVolume(layerS << 149 fSize[2]);
137 if(fNSegment[1] > 1) << 150 layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
138 { << 151 if(fNSegment[1] > 1) {
139 if(verboseLevel > 9) << 152 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to y direction" << G4endl;
140 G4cout << "G4ScoringBox::Construct() : R << 153 if(G4ScoringManager::GetReplicaLevel()>1)
141 << G4endl; <<
142 if(G4ScoringManager::GetReplicaLevel() > 1 <<
143 { 154 {
144 new G4PVReplica(layerName[1], layerLogic 155 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
145 fNSegment[1], fSize[1] / << 156 fNSegment[1], fSize[1]/fNSegment[1]*2.);
146 } 157 }
147 else 158 else
148 { 159 {
149 new G4PVDivision(layerName[1], layerLogi 160 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
150 fNSegment[1], 0.); << 161 fNSegment[1], 0.);
151 } 162 }
152 } << 163 } else if(fNSegment[1] == 1) {
153 else if(fNSegment[1] == 1) << 164 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
154 { << 165 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
155 if(verboseLevel > 9) << 166 } else
156 G4cout << "G4ScoringBox::Construct() : P <<
157 new G4PVPlacement(nullptr, G4ThreeVector(0 <<
158 layerName[1], layerLogic <<
159 } <<
160 else <<
161 G4cerr << "ERROR : G4ScoringBox::SetupGeom 167 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
162 << fNSegment[1] << ") " << 168 << fNSegment[1] << ") "
163 << "in placement of the second nest << 169 << "in placement of the second nested layer." << G4endl;
164 170
165 if(verboseLevel > 9) << 171 if(verboseLevel > 9) {
166 { << 172 G4cout << fSize[0]/fNSegment[0] << ", "
167 G4cout << fSize[0] / fNSegment[0] << ", " << 173 << fSize[1]/fNSegment[1] << ", "
168 << fSize[2] << G4endl; << 174 << fSize[2] << G4endl;
169 G4cout << layerName[1] << ": kYAxis, " << << 175 G4cout << layerName[1] << ": kYAxis, "
170 << 2. * fSize[1] / fNSegment[1] << << 176 << fNSegment[1] << ", "
>> 177 << 2.*fSize[1]/fNSegment[1] << G4endl;
171 } 178 }
172 179
173 // mesh elements (replicated to z direction) 180 // mesh elements (replicated to z direction)
174 if(verboseLevel > 9) << 181 if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
175 G4cout << "mesh elements :" << G4endl; << 182 G4String elementName = boxName +"3";
176 G4String elementName = boxName + "_3"; << 183 G4VSolid * elementSolid = new G4Box(elementName,
177 G4VSolid* elementSolid = << 184 fSize[0]/fNSegment[0],
178 new G4Box(elementName, fSize[0] / fNSegmen << 185 fSize[1]/fNSegment[1],
179 fSize[2] / fNSegment[2]); << 186 fSize[2]/fNSegment[2]);
180 fMeshElementLogical = new G4LogicalVolume(el << 187 fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
181 if(fNSegment[2] > 1) << 188 if(fNSegment[2] > 1)
182 { << 189 if(fSegmentPositions.size() > 0) {
183 if(verboseLevel > 9) << 190 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Parameterise to z direction" << G4endl;
184 G4cout << "G4ScoringBox::Construct() : R << 191 G4double motherDims[3] ={fSize[0]/fNSegment[0],
185 << G4endl; << 192 fSize[1]/fNSegment[1],
186 << 193 fSize[2]/fNSegment[2]};
187 if(G4ScoringManager::GetReplicaLevel() > 2 << 194 G4int nelement = fNSegment[2];
188 { << 195 fSegmentPositions.push_back(fSize[2]*2.);
189 new G4PVReplica(elementName, fMeshElemen << 196 //G4ScoringBoxParameterisation * param =
190 fNSegment[2], 2. * fSize << 197 G4VPVParameterisation * param =
191 } << 198 new G4ScoringBoxParameterisation(kZAxis, motherDims, fSegmentPositions);
192 else << 199 new G4PVParameterised(elementName,
193 { << 200 fMeshElementLogical,
194 new G4PVDivision(elementName, fMeshEleme << 201 layerLogical[1],
195 kZAxis, fNSegment[2], 0 << 202 kZAxis,
196 } << 203 nelement,
197 } << 204 param);
198 else if(fNSegment[2] == 1) << 205
199 { << 206 if(verboseLevel > 9) {
200 if(verboseLevel > 9) << 207 G4cout << motherDims[0] << ", " << motherDims[1] << ", " << motherDims[2] << G4endl;
201 G4cout << "G4ScoringBox::Construct() : P << 208 for(int i = 0; i < (int)fSegmentPositions.size(); i++)
202 new G4PVPlacement(nullptr, G4ThreeVector(0 << 209 G4cout << fSegmentPositions[i] << ", ";
203 elementName, layerLogica << 210 G4cout << G4endl;
204 } << 211 }
205 else << 212
>> 213 } else {
>> 214 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to z direction" << G4endl;
>> 215
>> 216 if(G4ScoringManager::GetReplicaLevel()>2)
>> 217 {
>> 218 new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
>> 219 fNSegment[2], 2.*fSize[2]/fNSegment[2]);
>> 220 }
>> 221 else
>> 222 {
>> 223 new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
>> 224 fNSegment[2], 0.);
>> 225 }
>> 226 }
>> 227 else if(fNSegment[2] == 1) {
>> 228 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
>> 229 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical, elementName, layerLogical[1], false, 0);
>> 230 } else
206 G4cerr << "ERROR : G4ScoringBox::SetupGeom 231 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : "
207 << "invalid parameter (" << fNSegme << 232 << "invalid parameter (" << fNSegment[2] << ") "
208 << "in mesh element placement." << << 233 << "in mesh element placement." << G4endl;
209 234
210 if(verboseLevel > 9) << 235 if(verboseLevel > 9) {
211 { << 236 G4cout << fSize[0]/fNSegment[0] << ", "
212 G4cout << fSize[0] / fNSegment[0] << ", " << 237 << fSize[1]/fNSegment[1] << ", "
213 << fSize[2] / fNSegment[2] << G4end << 238 << fSize[2]/fNSegment[2] << G4endl;
214 G4cout << elementName << ": kZAxis, " << f << 239 G4cout << elementName << ": kZAxis, "
215 << 2. * fSize[2] / fNSegment[2] << << 240 << fNSegment[2] << ", "
>> 241 << 2.*fSize[2]/fNSegment[2] << G4endl;
216 } 242 }
217 243
>> 244
218 // set the sensitive detector 245 // set the sensitive detector
219 fMeshElementLogical->SetSensitiveDetector(fM 246 fMeshElementLogical->SetSensitiveDetector(fMFD);
>> 247
220 248
221 // vis. attributes 249 // vis. attributes
222 auto visatt = new G4VisAttributes(G4Colour( << 250 G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
223 visatt->SetVisibility(false); 251 visatt->SetVisibility(false);
224 layerLogical[0]->SetVisAttributes(visatt); 252 layerLogical[0]->SetVisAttributes(visatt);
225 layerLogical[1]->SetVisAttributes(visatt); 253 layerLogical[1]->SetVisAttributes(visatt);
226 visatt->SetVisibility(true); 254 visatt->SetVisibility(true);
227 fMeshElementLogical->SetVisAttributes(visatt 255 fMeshElementLogical->SetVisAttributes(visatt);
228 } 256 }
229 257
230 void G4ScoringBox::List() const << 258
231 { << 259 void G4ScoringBox::List() const {
232 G4cout << "G4ScoringBox : " << fWorldName << 260 G4cout << "G4ScoringBox : " << fWorldName << " --- Shape: Box mesh" << G4endl;
233 G4cout << " Size (x, y, z): (" << fSize[0] / << 261 G4cout << " Size (x, y, z): ("
234 << ", " << fSize[2] / cm << ") [cm]" << 262 << fSize[0]/cm << ", "
>> 263 << fSize[1]/cm << ", "
>> 264 << fSize[2]/cm << ") [cm]"
>> 265 << G4endl;
235 266
236 G4VScoringMesh::List(); 267 G4VScoringMesh::List();
237 } 268 }
238 269
239 void G4ScoringBox::Draw(RunScore* map, G4VScor << 270 void G4ScoringBox::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
240 { << 271
241 G4VVisManager* pVisManager = G4VVisManager:: << 272 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
242 if(pVisManager != nullptr) << 273 if(pVisManager) {
243 { << 274
244 // cell vectors 275 // cell vectors
245 std::vector<std::vector<std::vector<G4doub << 276 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z]
246 std::vector<G4double> ez; << 277 std::vector<double> ez;
247 for(G4int z = 0; z < fNSegment[2]; z++) << 278 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.);
248 ez.push_back(0.); << 279 std::vector<std::vector<double> > eyz;
249 std::vector<std::vector<G4double>> eyz; << 280 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez);
250 for(G4int y = 0; y < fNSegment[1]; y++) << 281 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz);
251 eyz.push_back(ez); << 282
252 for(G4int x = 0; x < fNSegment[0]; x++) << 283 std::vector<std::vector<double> > xycell; // xycell[X][Y]
253 cell.push_back(eyz); << 284 std::vector<double> ey;
254 << 285 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.);
255 std::vector<std::vector<G4double>> xycell; << 286 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey);
256 std::vector<G4double> ey; <<
257 for(G4int y = 0; y < fNSegment[1]; y++) <<
258 ey.push_back(0.); <<
259 for(G4int x = 0; x < fNSegment[0]; x++) <<
260 xycell.push_back(ey); <<
261 <<
262 std::vector<std::vector<G4double>> yzcell; <<
263 for(G4int y = 0; y < fNSegment[1]; y++) <<
264 yzcell.push_back(ez); <<
265 <<
266 std::vector<std::vector<G4double>> xzcell; <<
267 for(G4int x = 0; x < fNSegment[0]; x++) <<
268 xzcell.push_back(ez); <<
269 287
270 // projections << 288 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z]
271 G4int q[3]; << 289 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez);
272 auto itr = map->GetMap()->begin(); <<
273 for(; itr != map->GetMap()->end(); itr++) <<
274 { <<
275 GetXYZ(itr->first, q); <<
276 290
277 xycell[q[0]][q[1]] += (itr->second->sum_ << 291 std::vector<std::vector<double> > xzcell; // xzcell[X][Z]
278 yzcell[q[1]][q[2]] += (itr->second->sum_ << 292 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
279 xzcell[q[0]][q[2]] += (itr->second->sum_ <<
280 } <<
281 293
282 // search max. & min. values in each slice <<
283 G4double xymin = DBL_MAX, yzmin = DBL_MAX, 294 G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
284 G4double xymax = 0., yzmax = 0., xzmax = 0 295 G4double xymax = 0., yzmax = 0., xzmax = 0.;
285 for(G4int x = 0; x < fNSegment[0]; x++) << 296 G4int q[3];
286 { << 297 std::map<G4int, G4double*>::iterator itr = map->begin();
287 for(G4int y = 0; y < fNSegment[1]; y++) << 298 for(; itr != map->end(); itr++) {
288 { << 299 GetXYZ(itr->first, q);
289 if(xymin > xycell[x][y]) <<
290 xymin = xycell[x][y]; <<
291 if(xymax < xycell[x][y]) <<
292 xymax = xycell[x][y]; <<
293 } <<
294 for(G4int z = 0; z < fNSegment[2]; z++) <<
295 { <<
296 if(xzmin > xzcell[x][z]) <<
297 xzmin = xzcell[x][z]; <<
298 if(xzmax < xzcell[x][z]) <<
299 xzmax = xzcell[x][z]; <<
300 } <<
301 } <<
302 for(G4int y = 0; y < fNSegment[1]; y++) <<
303 { <<
304 for(G4int z = 0; z < fNSegment[2]; z++) <<
305 { <<
306 if(yzmin > yzcell[y][z]) <<
307 yzmin = yzcell[y][z]; <<
308 if(yzmax < yzcell[y][z]) <<
309 yzmax = yzcell[y][z]; <<
310 } <<
311 } <<
312 300
>> 301 xycell[q[0]][q[1]] += *(itr->second);
>> 302 if(xymin > xycell[q[0]][q[1]]) xymin = xycell[q[0]][q[1]];
>> 303 if(xymax < xycell[q[0]][q[1]]) xymax = xycell[q[0]][q[1]];
>> 304
>> 305 yzcell[q[1]][q[2]] += *(itr->second);
>> 306 if(yzmin > yzcell[q[1]][q[2]]) yzmin = yzcell[q[1]][q[2]];
>> 307 if(yzmax < yzcell[q[1]][q[2]]) yzmax = yzcell[q[1]][q[2]];
>> 308
>> 309 xzcell[q[0]][q[2]] += *(itr->second);
>> 310 if(xzmin > xzcell[q[0]][q[2]]) xzmin = xzcell[q[0]][q[2]];
>> 311 if(xzmax < xzcell[q[0]][q[2]]) xzmax = xzcell[q[0]][q[2]];
>> 312 }
>> 313
313 G4VisAttributes att; 314 G4VisAttributes att;
314 att.SetForceSolid(true); 315 att.SetForceSolid(true);
315 att.SetForceAuxEdgeVisible(true); 316 att.SetForceAuxEdgeVisible(true);
316 G4double thick = 0.01; <<
317 317
318 G4Scale3D scale; 318 G4Scale3D scale;
319 if(axflg / 100 == 1) << 319 if(axflg/100==1) {
320 { <<
321 pVisManager->BeginDraw(); <<
322 <<
323 // xy plane 320 // xy plane
324 if(colorMap->IfFloatMinMax()) << 321 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xymin ,xymax); }
325 { << 322 G4ThreeVector zhalf(0., 0., fSize[2]/fNSegment[2]*0.98);
326 colorMap->SetMinMax(xymin, xymax); << 323 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]*0.01);
327 } << 324 for(int x = 0; x < fNSegment[0]; x++) {
328 G4ThreeVector zhalf(0., 0., fSize[2] / f << 325 for(int y = 0; y < fNSegment[1]; y++) {
329 for(G4int x = 0; x < fNSegment[0]; x++) << 326 G4ThreeVector pos(GetReplicaPosition(x, y, 0) - zhalf);
330 { << 327 G4ThreeVector pos2(GetReplicaPosition(x, y, fNSegment[2]-1) + zhalf);
331 for(G4int y = 0; y < fNSegment[1]; y++ << 328 G4Transform3D trans, trans2;
332 { << 329 if(fRotationMatrix) {
333 G4ThreeVector pos(GetReplicaPosition << 330 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
334 G4ThreeVector pos2(GetReplicaPositio << 331 trans = G4Translate3D(fCenterPosition)*trans;
335 zhalf); << 332 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
336 G4Transform3D trans, trans2; << 333 trans2 = G4Translate3D(fCenterPosition)*trans2;
337 if(fRotationMatrix != nullptr) << 334 } else {
338 { << 335 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
339 trans = G4Rotate3D(*fRotationMatri << 336 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
340 trans = G4Translate3D(fCenterPosit << 337 }
341 trans2 = << 338 G4double c[4];
342 G4Rotate3D(*fRotationMatrix).inv << 339 colorMap->GetMapColor(xycell[x][y], c);
343 trans2 = G4Translate3D(fCenterPosi << 340 att.SetColour(c[0], c[1], c[2]);//, c[3]);
344 } << 341 pVisManager->Draw(xyplate, att, trans);
345 else << 342 pVisManager->Draw(xyplate, att, trans2);
346 { << 343
347 trans = G4Translate3D(pos) * G4Tr << 344 }
348 trans2 = G4Translate3D(pos2) * G4T <<
349 } <<
350 G4double c[4]; <<
351 colorMap->GetMapColor(xycell[x][y], <<
352 att.SetColour(c[0], c[1], c[2]); // <<
353 <<
354 G4Box xyplate("xy", fSize[0] / fNSeg <<
355 thick); <<
356 G4Polyhedron* poly = xyplate.GetPoly <<
357 poly->Transform(trans); <<
358 poly->SetVisAttributes(&att); <<
359 pVisManager->Draw(*poly); <<
360 <<
361 G4Box xyplate2 = xyplate; <<
362 G4Polyhedron* poly2 = xyplate2.GetPo <<
363 poly2->Transform(trans2); <<
364 poly2->SetVisAttributes(&att); <<
365 pVisManager->Draw(*poly2); <<
366 } <<
367 } 345 }
368 pVisManager->EndDraw(); <<
369 } 346 }
370 axflg = axflg % 100; << 347 axflg = axflg%100;
371 if(axflg / 10 == 1) << 348 if(axflg/10==1) {
372 { <<
373 pVisManager->BeginDraw(); <<
374 <<
375 // yz plane 349 // yz plane
376 if(colorMap->IfFloatMinMax()) << 350 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(yzmin, yzmax); }
377 { << 351 G4ThreeVector xhalf(fSize[0]/fNSegment[0]*0.98, 0., 0.);
378 colorMap->SetMinMax(yzmin, yzmax); << 352 G4Box yzplate("yz", fSize[0]/fNSegment[0]*0.01, fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
379 } << 353 for(int y = 0; y < fNSegment[1]; y++) {
380 G4ThreeVector xhalf(fSize[0] / fNSegment << 354 for(int z = 0; z < fNSegment[2]; z++) {
381 for(G4int y = 0; y < fNSegment[1]; y++) << 355 G4ThreeVector pos(GetReplicaPosition(0, y, z) - xhalf);
382 { << 356 G4ThreeVector pos2(GetReplicaPosition(fNSegment[0]-1, y, z) + xhalf);
383 for(G4int z = 0; z < fNSegment[2]; z++ << 357 G4Transform3D trans, trans2;
384 { << 358 if(fRotationMatrix) {
385 G4ThreeVector pos(GetReplicaPosition << 359 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
386 G4ThreeVector pos2(GetReplicaPositio << 360 trans = G4Translate3D(fCenterPosition)*trans;
387 xhalf); << 361 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
388 G4Transform3D trans, trans2; << 362 trans2 = G4Translate3D(fCenterPosition)*trans2;
389 if(fRotationMatrix != nullptr) << 363 } else {
390 { << 364 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
391 trans = G4Rotate3D(*fRotationMatri << 365 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
392 trans = G4Translate3D(fCenterPosit << 366 }
393 trans2 = << 367 G4double c[4];
394 G4Rotate3D(*fRotationMatrix).inv << 368 colorMap->GetMapColor(yzcell[y][z], c);
395 trans2 = G4Translate3D(fCenterPosi << 369 att.SetColour(c[0], c[1], c[2]);//, c[3]);
396 } << 370 pVisManager->Draw(yzplate, att, trans);
397 else << 371 pVisManager->Draw(yzplate, att, trans2);
398 { << 372
399 trans = G4Translate3D(pos) * G4Tr << 373 }
400 trans2 = G4Translate3D(pos2) * G4T <<
401 } <<
402 G4double c[4]; <<
403 colorMap->GetMapColor(yzcell[y][z], <<
404 att.SetColour(c[0], c[1], c[2]); // <<
405 <<
406 G4Box yzplate("yz", thick, // fSize <<
407 fSize[1] / fNSegment[1 <<
408 G4Polyhedron* poly = yzplate.GetPoly <<
409 poly->Transform(trans); <<
410 poly->SetVisAttributes(&att); <<
411 pVisManager->Draw(*poly); <<
412 <<
413 G4Box yzplate2 = yzplate; <<
414 G4Polyhedron* poly2 = yzplate2.GetPo <<
415 poly2->Transform(trans2); <<
416 poly2->SetVisAttributes(&att); <<
417 pVisManager->Draw(*poly2); <<
418 } <<
419 } 374 }
420 pVisManager->EndDraw(); <<
421 } 375 }
422 axflg = axflg % 10; << 376 axflg = axflg%10;
423 if(axflg == 1) << 377 if(axflg==1) {
424 { <<
425 pVisManager->BeginDraw(); <<
426 <<
427 // xz plane 378 // xz plane
428 if(colorMap->IfFloatMinMax()) << 379 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xzmin,xzmax); }
429 { << 380 G4ThreeVector yhalf(0., fSize[1]/fNSegment[1]*0.98, 0.);
430 colorMap->SetMinMax(xzmin, xzmax); << 381 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1]*0.01, fSize[2]/fNSegment[2]);
431 } << 382 for(int x = 0; x < fNSegment[0]; x++) {
432 G4ThreeVector yhalf(0., fSize[1] / fNSeg << 383 for(int z = 0; z < fNSegment[2]; z++) {
433 for(G4int x = 0; x < fNSegment[0]; x++) << 384 G4ThreeVector pos(GetReplicaPosition(x, 0, z) - yhalf);
434 { << 385 G4ThreeVector pos2(GetReplicaPosition(x, fNSegment[1]-1, z) + yhalf);
435 for(G4int z = 0; z < fNSegment[2]; z++ << 386 G4Transform3D trans, trans2;
436 { << 387 if(fRotationMatrix) {
437 G4ThreeVector pos(GetReplicaPosition << 388 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
438 G4ThreeVector pos2(GetReplicaPositio << 389 trans = G4Translate3D(fCenterPosition)*trans;
439 yhalf); << 390 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
440 G4Transform3D trans, trans2; << 391 trans2 = G4Translate3D(fCenterPosition)*trans2;
441 if(fRotationMatrix != nullptr) << 392 } else {
442 { << 393 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
443 trans = G4Rotate3D(*fRotationMatri << 394 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
444 trans = G4Translate3D(fCenterPosit << 395 }
445 trans2 = << 396 G4double c[4];
446 G4Rotate3D(*fRotationMatrix).inv << 397 colorMap->GetMapColor(xzcell[x][z], c);
447 trans2 = G4Translate3D(fCenterPosi << 398 att.SetColour(c[0], c[1], c[2]);//, c[3]);
448 } << 399 pVisManager->Draw(xzplate, att, trans);
449 else << 400 pVisManager->Draw(xzplate, att, trans2);
450 { << 401
451 trans = G4Translate3D(pos) * G4Tr << 402 }
452 trans2 = G4Translate3D(pos2) * G4T <<
453 } <<
454 G4double c[4]; <<
455 colorMap->GetMapColor(xzcell[x][z], <<
456 att.SetColour(c[0], c[1], c[2]); // <<
457 <<
458 G4Box xzplate("xz", fSize[0] / fNSeg <<
459 thick, // fSize[1]/fN <<
460 fSize[2] / fNSegment[2 <<
461 G4Polyhedron* poly = xzplate.GetPoly <<
462 poly->Transform(trans); <<
463 poly->SetVisAttributes(&att); <<
464 pVisManager->Draw(*poly); <<
465 <<
466 G4Box xzplate2 = xzplate; <<
467 G4Polyhedron* poly2 = xzplate2.GetPo <<
468 poly2->Transform(trans2); <<
469 poly2->SetVisAttributes(&att); <<
470 pVisManager->Draw(*poly2); <<
471 } <<
472 } 403 }
473 pVisManager->EndDraw(); <<
474 } 404 }
475 } 405 }
476 colorMap->SetPSUnit(fDrawUnit); <<
477 colorMap->SetPSName(fDrawPSName); <<
478 colorMap->DrawColorChart(); 406 colorMap->DrawColorChart();
479 } 407 }
480 408
481 G4ThreeVector G4ScoringBox::GetReplicaPosition << 409 G4ThreeVector G4ScoringBox::GetReplicaPosition(G4int x, G4int y, G4int z) {
482 { << 410
483 G4ThreeVector width(fSize[0] / fNSegment[0], << 411 G4ThreeVector width(fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
484 fSize[2] / fNSegment[2]) << 412 G4ThreeVector pos(-fSize[0] + 2*(x+0.5)*width.x(),
485 G4ThreeVector pos(-fSize[0] + 2 * (x + 0.5) << 413 -fSize[1] + 2*(y+0.5)*width.y(),
486 -fSize[1] + 2 * (y + 0.5) << 414 -fSize[2] + 2*(z+0.5)*width.z());
487 -fSize[2] + 2 * (z + 0.5) <<
488 415
489 return pos; 416 return pos;
490 } 417 }
491 418
492 void G4ScoringBox::GetXYZ(G4int index, G4int q << 419 void G4ScoringBox::GetXYZ(G4int index, G4int q[3]) const {
493 { << 420
494 q[0] = index / (fNSegment[2] * fNSegment[1]) << 421 q[0] = index/(fNSegment[2]*fNSegment[1]);
495 q[1] = (index - q[0] * fNSegment[2] * fNSegm << 422 q[1] = (index - q[0]*fNSegment[2]*fNSegment[1])/fNSegment[2];
496 q[2] = index - q[1] * fNSegment[2] - q[0] * << 423 q[2] = index - q[1]*fNSegment[2] - q[0]*fNSegment[2]*fNSegment[1];
>> 424
497 } 425 }
498 426
499 G4int G4ScoringBox::GetIndex(G4int x, G4int y, << 427 G4int G4ScoringBox::GetIndex(G4int x, G4int y, G4int z) const {
500 { << 428 return x + y*fNSegment[0] + z*fNSegment[0]*fNSegment[1];
501 return x + y * fNSegment[0] + z * fNSegment[ <<
502 } 429 }
503 430
504 void G4ScoringBox::DrawColumn(RunScore* map, G << 431 void G4ScoringBox::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap,
505 G4int idxProj, G << 432 G4int idxProj, G4int idxColumn)
506 { 433 {
507 G4int iColumn[3] = { 2, 0, 1 }; << 434 if(idxColumn<0 || idxColumn>=fNSegment[idxProj])
508 if(idxColumn < 0 || idxColumn >= fNSegment[i <<
509 { 435 {
510 G4cerr << "ERROR : Column number " << idxC << 436 G4cerr << "ERROR : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[idxProj]-1 <<
511 << " is out of scoring mesh [0," << << 437 "]. Method ignored." << G4endl;
512 << "]. Method ignored." << G4endl; <<
513 return; 438 return;
514 } 439 }
515 G4VVisManager* pVisManager = G4VVisManager:: << 440 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
516 if(pVisManager != nullptr) << 441 if(pVisManager) {
517 { << 442
518 pVisManager->BeginDraw(); <<
519 <<
520 // cell vectors 443 // cell vectors
521 std::vector<std::vector<std::vector<G4doub << 444 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z]
522 std::vector<G4double> ez; << 445 std::vector<double> ez;
523 for(G4int z = 0; z < fNSegment[2]; z++) << 446 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.);
524 ez.push_back(0.); << 447 std::vector<std::vector<double> > eyz;
525 std::vector<std::vector<G4double>> eyz; << 448 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez);
526 for(G4int y = 0; y < fNSegment[1]; y++) << 449 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz);
527 eyz.push_back(ez); << 450
528 for(G4int x = 0; x < fNSegment[0]; x++) << 451 std::vector<std::vector<double> > xycell; // xycell[X][Y]
529 cell.push_back(eyz); << 452 std::vector<double> ey;
530 << 453 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.);
531 std::vector<std::vector<G4double>> xycell; << 454 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey);
532 std::vector<G4double> ey; <<
533 for(G4int y = 0; y < fNSegment[1]; y++) <<
534 ey.push_back(0.); <<
535 for(G4int x = 0; x < fNSegment[0]; x++) <<
536 xycell.push_back(ey); <<
537 <<
538 std::vector<std::vector<G4double>> yzcell; <<
539 for(G4int y = 0; y < fNSegment[1]; y++) <<
540 yzcell.push_back(ez); <<
541 <<
542 std::vector<std::vector<G4double>> xzcell; <<
543 for(G4int x = 0; x < fNSegment[0]; x++) <<
544 xzcell.push_back(ez); <<
545 455
546 // projections << 456 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z]
547 G4int q[3]; << 457 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez);
548 auto itr = map->GetMap()->begin(); <<
549 for(; itr != map->GetMap()->end(); itr++) <<
550 { <<
551 GetXYZ(itr->first, q); <<
552 458
553 if(idxProj == 0 && q[2] == idxColumn) << 459 std::vector<std::vector<double> > xzcell; // xzcell[X][Z]
554 { // xy plane << 460 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
555 xycell[q[0]][q[1]] += (itr->second->su <<
556 } <<
557 if(idxProj == 1 && q[0] == idxColumn) <<
558 { // yz plane <<
559 yzcell[q[1]][q[2]] += (itr->second->su <<
560 } <<
561 if(idxProj == 2 && q[1] == idxColumn) <<
562 { // zx plane <<
563 xzcell[q[0]][q[2]] += (itr->second->su <<
564 } <<
565 } <<
566 461
567 // search max. & min. values in each slice <<
568 G4double xymin = DBL_MAX, yzmin = DBL_MAX, <<
569 G4double xymax = 0., yzmax = 0., xzmax = 0 462 G4double xymax = 0., yzmax = 0., xzmax = 0.;
570 for(G4int x = 0; x < fNSegment[0]; x++) << 463 G4int q[3];
571 { << 464 std::map<G4int, G4double*>::iterator itr = map->begin();
572 for(G4int y = 0; y < fNSegment[1]; y++) << 465 for(; itr != map->end(); itr++) {
573 { << 466 GetXYZ(itr->first, q);
574 if(xymin > xycell[x][y]) <<
575 xymin = xycell[x][y]; <<
576 if(xymax < xycell[x][y]) <<
577 xymax = xycell[x][y]; <<
578 } <<
579 for(G4int z = 0; z < fNSegment[2]; z++) <<
580 { <<
581 if(xzmin > xzcell[x][z]) <<
582 xzmin = xzcell[x][z]; <<
583 if(xzmax < xzcell[x][z]) <<
584 xzmax = xzcell[x][z]; <<
585 } <<
586 } <<
587 for(G4int y = 0; y < fNSegment[1]; y++) <<
588 { <<
589 for(G4int z = 0; z < fNSegment[2]; z++) <<
590 { <<
591 if(yzmin > yzcell[y][z]) <<
592 yzmin = yzcell[y][z]; <<
593 if(yzmax < yzcell[y][z]) <<
594 yzmax = yzcell[y][z]; <<
595 } <<
596 } <<
597 467
>> 468 if(idxProj == 0 && q[2] == idxColumn) { // xy plane
>> 469 xycell[q[0]][q[1]] += *(itr->second);
>> 470 if(xymax < xycell[q[0]][q[1]]) xymax = xycell[q[0]][q[1]];
>> 471 }
>> 472 if(idxProj == 1 && q[0] == idxColumn) { // yz plane
>> 473 yzcell[q[1]][q[2]] += *(itr->second);
>> 474 if(yzmax < yzcell[q[1]][q[2]]) yzmax = yzcell[q[1]][q[2]];
>> 475 }
>> 476 if(idxProj == 2 && q[1] == idxColumn) { // zx plane
>> 477 xzcell[q[0]][q[2]] += *(itr->second);
>> 478 if(xzmax < xzcell[q[0]][q[2]]) xzmax = xzcell[q[0]][q[2]];
>> 479 }
>> 480 }
>> 481
598 G4VisAttributes att; 482 G4VisAttributes att;
599 att.SetForceSolid(true); 483 att.SetForceSolid(true);
600 att.SetForceAuxEdgeVisible(true); 484 att.SetForceAuxEdgeVisible(true);
601 485
>> 486
602 G4Scale3D scale; 487 G4Scale3D scale;
603 // xy plane 488 // xy plane
604 if(idxProj == 0) << 489 if(idxProj == 0) {
605 { << 490 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,xymax); }
606 if(colorMap->IfFloatMinMax()) << 491 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
607 { << 492 for(int x = 0; x < fNSegment[0]; x++) {
608 colorMap->SetMinMax(xymin, xymax); << 493 for(int y = 0; y < fNSegment[1]; y++) {
609 } << 494 G4ThreeVector pos(GetReplicaPosition(x, y, idxColumn));
610 for(G4int x = 0; x < fNSegment[0]; x++) << 495 G4Transform3D trans;
611 { << 496 if(fRotationMatrix) {
612 for(G4int y = 0; y < fNSegment[1]; y++ << 497 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
613 { << 498 trans = G4Translate3D(fCenterPosition)*trans;
614 G4Box xyplate("xy", fSize[0] / fNSeg << 499 } else {
615 fSize[2] / fNSegment[2 << 500 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
616 << 501 }
617 G4ThreeVector pos(GetReplicaPosition << 502 G4double c[4];
618 G4Transform3D trans; << 503 colorMap->GetMapColor(xycell[x][y], c);
619 if(fRotationMatrix != nullptr) << 504 att.SetColour(c[0], c[1], c[2]);//, c[3]);
620 { << 505 pVisManager->Draw(xyplate, att, trans);
621 trans = G4Rotate3D(*fRotationMatri << 506
622 trans = G4Translate3D(fCenterPosit << 507 }
623 } << 508 }
624 else << 509 } else
625 { << 510 // yz plane
626 trans = G4Translate3D(pos) * G4Tra << 511 if(idxProj == 1) {
627 } << 512 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,yzmax); }
628 G4double c[4]; << 513 G4Box yzplate("yz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
629 colorMap->GetMapColor(xycell[x][y], << 514 for(int y = 0; y < fNSegment[1]; y++) {
630 att.SetColour(c[0], c[1], c[2]); << 515 for(int z = 0; z < fNSegment[2]; z++) {
631 << 516 G4ThreeVector pos(GetReplicaPosition(idxColumn, y, z));
632 G4Polyhedron* poly = xyplate.GetPoly << 517 G4Transform3D trans;
633 poly->Transform(trans); << 518 if(fRotationMatrix) {
634 poly->SetVisAttributes(att); << 519 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
635 pVisManager->Draw(*poly); << 520 trans = G4Translate3D(fCenterPosition)*trans;
636 } << 521 } else {
637 } << 522 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
638 } << 523 }
639 else << 524 G4double c[4];
640 // yz plane << 525 colorMap->GetMapColor(yzcell[y][z], c);
641 if(idxProj == 1) << 526 att.SetColour(c[0], c[1], c[2]);//, c[3]);
642 { << 527 pVisManager->Draw(yzplate, att, trans);
643 if(colorMap->IfFloatMinMax()) << 528 }
644 { << 529 }
645 colorMap->SetMinMax(yzmin, yzmax); << 530 } else
646 } << 531 // xz plane
647 for(G4int y = 0; y < fNSegment[1]; y++) << 532 if(idxProj == 2) {
648 { << 533 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,xzmax);}
649 for(G4int z = 0; z < fNSegment[2]; z++ << 534 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
650 { << 535 for(int x = 0; x < fNSegment[0]; x++) {
651 G4Box yzplate("yz", fSize[0] / fNSeg << 536 for(int z = 0; z < fNSegment[2]; z++) {
652 fSize[2] / fNSegment[2 << 537 G4ThreeVector pos(GetReplicaPosition(x, idxColumn, z));
653 << 538 G4Transform3D trans;
654 G4ThreeVector pos(GetReplicaPosition << 539 if(fRotationMatrix) {
655 G4Transform3D trans; << 540 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
656 if(fRotationMatrix != nullptr) << 541 trans = G4Translate3D(fCenterPosition)*trans;
657 { << 542 } else {
658 trans = G4Rotate3D(*fRotationMatri << 543 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
659 trans = G4Translate3D(fCenterPosit << 544 }
660 } << 545 G4double c[4];
661 else << 546 colorMap->GetMapColor(xzcell[x][z], c);
662 { << 547 att.SetColour(c[0], c[1], c[2]);//, c[3]);
663 trans = G4Translate3D(pos) * G4Tra << 548 pVisManager->Draw(xzplate, att, trans);
664 } << 549 }
665 G4double c[4]; <<
666 colorMap->GetMapColor(yzcell[y][z], <<
667 att.SetColour(c[0], c[1], c[2]); // <<
668 <<
669 G4Polyhedron* poly = yzplate.GetPoly <<
670 poly->Transform(trans); <<
671 poly->SetVisAttributes(att); <<
672 pVisManager->Draw(*poly); <<
673 } <<
674 } 550 }
675 } 551 }
676 else <<
677 // xz plane <<
678 if(idxProj == 2) <<
679 { <<
680 if(colorMap->IfFloatMinMax()) <<
681 { <<
682 colorMap->SetMinMax(xzmin, xzmax); <<
683 } <<
684 for(G4int x = 0; x < fNSegment[0]; x++) <<
685 { <<
686 for(G4int z = 0; z < fNSegment[2]; z++ <<
687 { <<
688 G4Box xzplate("xz", fSize[0] / fNSeg <<
689 fSize[2] / fNSegment[2 <<
690 <<
691 G4ThreeVector pos(GetReplicaPosition <<
692 G4Transform3D trans; <<
693 if(fRotationMatrix != nullptr) <<
694 { <<
695 trans = G4Rotate3D(*fRotationMatri <<
696 trans = G4Translate3D(fCenterPosit <<
697 } <<
698 else <<
699 { <<
700 trans = G4Translate3D(pos) * G4Tra <<
701 } <<
702 G4double c[4]; <<
703 colorMap->GetMapColor(xzcell[x][z], <<
704 att.SetColour(c[0], c[1], c[2]); // <<
705 <<
706 G4Polyhedron* poly = xzplate.GetPoly <<
707 poly->Transform(trans); <<
708 poly->SetVisAttributes(att); <<
709 pVisManager->Draw(*poly); <<
710 } <<
711 } <<
712 } <<
713 pVisManager->EndDraw(); <<
714 } 552 }
715 553
716 colorMap->SetPSUnit(fDrawUnit); <<
717 colorMap->SetPSName(fDrawPSName); <<
718 colorMap->DrawColorChart(); 554 colorMap->DrawColorChart();
719 } 555 }
>> 556
>> 557
720 558