source: trunk/source/digits_hits/utils/src/G4ScoringBox.cc@ 881

Last change on this file since 881 was 850, checked in by garnier, 17 years ago

geant4.8.2 beta
File size: 19.8 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4ScoringBox.cc,v 1.54 2008/08/29 02:50:05 akimura Exp $
28// GEANT4 tag $Name: HEAD $
29//
30
31#include "G4ScoringBox.hh"
32
33#include "G4Box.hh"
34#include "G4LogicalVolume.hh"
35#include "G4VPhysicalVolume.hh"
36#include "G4PVPlacement.hh"
37#include "G4PVReplica.hh"
38#include "G4PVDivision.hh"
39#include "G4PVParameterised.hh"
40#include "G4VisAttributes.hh"
41#include "G4ScoringBoxParameterisation.hh"
42#include "G4VVisManager.hh"
43#include "G4VScoreColorMap.hh"
44
45#include "G4MultiFunctionalDetector.hh"
46#include "G4SDParticleFilter.hh"
47#include "G4VPrimitiveScorer.hh"
48
49#include "G4ScoringManager.hh"
50
51#include <map>
52#include <fstream>
53
54G4ScoringBox::G4ScoringBox(G4String wName)
55 :G4VScoringMesh(wName), fSegmentDirection(-1),
56 fMeshElementLogical(0)
57{
58 fShape = boxMesh;
59}
60
61G4ScoringBox::~G4ScoringBox()
62{
63}
64
65void G4ScoringBox::Construct(G4VPhysicalVolume* fWorldPhys)
66{
67 if(fConstructed) {
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
81void G4ScoringBox::SetupGeometry(G4VPhysicalVolume * fWorldPhys) {
82
83 if(verboseLevel > 9) G4cout << "G4ScoringBox::SetupGeometry() ..." << G4endl;
84
85 // World
86 G4VPhysicalVolume * scoringWorld = fWorldPhys;
87 G4LogicalVolume * worldLogical = scoringWorld->GetLogicalVolume();
88
89 // Scoring Mesh
90 if(verboseLevel > 9) G4cout << fWorldName << G4endl;
91 G4String boxName = fWorldName;
92
93 if(verboseLevel > 9) G4cout << fSize[0] << ", " << fSize[1] << ", " << fSize[2] << G4endl;
94 G4VSolid * boxSolid = new G4Box(boxName+"0", fSize[0], fSize[1], fSize[2]);
95 G4LogicalVolume * boxLogical = new G4LogicalVolume(boxSolid, 0, boxName);
96 new G4PVPlacement(fRotationMatrix, fCenterPosition,
97 boxLogical, boxName+"0", worldLogical, false, 0);
98
99 //G4double fsegment[3][3];
100 //G4int segOrder[3];
101 //GetSegmentOrder(fSegmentDirection, fNSegment, segOrder, fsegment);
102 //EAxis axis[3] = {kXAxis, kYAxis, kZAxis};
103
104 G4String layerName[2] = {boxName + "1", boxName + "2"};
105 G4VSolid * layerSolid[2];
106 G4LogicalVolume * layerLogical[2];
107
108 //-- fisrt nested layer (replicated to x direction)
109 if(verboseLevel > 9) G4cout << "layer 1 :" << G4endl;
110 layerSolid[0] = new G4Box(layerName[0],
111 fSize[0]/fNSegment[0],
112 fSize[1],
113 fSize[2]);
114 layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
115 if(fNSegment[0] > 1) {
116 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to x direction" << G4endl;
117 if(G4ScoringManager::GetReplicaLevel()>0)
118 {
119 new G4PVReplica(layerName[0], layerLogical[0], boxLogical, kXAxis,
120 fNSegment[0], fSize[0]/fNSegment[0]*2.);
121 }
122 else
123 {
124 new G4PVDivision(layerName[0], layerLogical[0], boxLogical, kXAxis,
125 fNSegment[0], 0.);
126 }
127 } else if(fNSegment[0] == 1) {
128 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
129 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[0], layerName[0], boxLogical, false, 0);
130 } else
131 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
132 << fNSegment[0] << ") "
133 << "in placement of the first nested layer." << G4endl;
134
135 if(verboseLevel > 9) {
136 G4cout << fSize[0]/fNSegment[0] << ", "
137 << fSize[1] << ", "
138 << fSize[2] << G4endl;
139 G4cout << layerName[0] << ": kXAxis, "
140 << fNSegment[0] << ", "
141 << 2.*fSize[0]/fNSegment[0] << G4endl;
142 }
143
144 // second nested layer (replicated to y direction)
145 if(verboseLevel > 9) G4cout << "layer 2 :" << G4endl;
146 layerSolid[1] = new G4Box(layerName[1],
147 fSize[0]/fNSegment[0],
148 fSize[1]/fNSegment[1],
149 fSize[2]);
150 layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
151 if(fNSegment[1] > 1) {
152 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Replicate to y direction" << G4endl;
153 if(G4ScoringManager::GetReplicaLevel()>1)
154 {
155 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
156 fNSegment[1], fSize[1]/fNSegment[1]*2.);
157 }
158 else
159 {
160 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
161 fNSegment[1], 0.);
162 }
163 } else if(fNSegment[1] == 1) {
164 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
165 new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), layerLogical[1], layerName[1], layerLogical[0], false, 0);
166 } else
167 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
168 << fNSegment[1] << ") "
169 << "in placement of the second nested layer." << G4endl;
170
171 if(verboseLevel > 9) {
172 G4cout << fSize[0]/fNSegment[0] << ", "
173 << fSize[1]/fNSegment[1] << ", "
174 << fSize[2] << G4endl;
175 G4cout << layerName[1] << ": kYAxis, "
176 << fNSegment[1] << ", "
177 << 2.*fSize[1]/fNSegment[1] << G4endl;
178 }
179
180 // mesh elements (replicated to z direction)
181 if(verboseLevel > 9) G4cout << "mesh elements :" << G4endl;
182 G4String elementName = boxName +"3";
183 G4VSolid * elementSolid = new G4Box(elementName,
184 fSize[0]/fNSegment[0],
185 fSize[1]/fNSegment[1],
186 fSize[2]/fNSegment[2]);
187 fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
188 if(fNSegment[2] > 1)
189 if(fSegmentPositions.size() > 0) {
190 if(verboseLevel > 9) G4cout << "G4ScoringBox::Construct() : Parameterise to z direction" << G4endl;
191 G4double motherDims[3] ={fSize[0]/fNSegment[0],
192 fSize[1]/fNSegment[1],
193 fSize[2]/fNSegment[2]};
194 G4int nelement = fNSegment[2];
195 fSegmentPositions.push_back(fSize[2]*2.);
196 //G4ScoringBoxParameterisation * param =
197 G4VPVParameterisation * param =
198 new G4ScoringBoxParameterisation(kZAxis, motherDims, fSegmentPositions);
199 new G4PVParameterised(elementName,
200 fMeshElementLogical,
201 layerLogical[1],
202 kZAxis,
203 nelement,
204 param);
205
206 if(verboseLevel > 9) {
207 G4cout << motherDims[0] << ", " << motherDims[1] << ", " << motherDims[2] << G4endl;
208 for(int i = 0; i < (int)fSegmentPositions.size(); i++)
209 G4cout << fSegmentPositions[i] << ", ";
210 G4cout << G4endl;
211 }
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
231 G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : "
232 << "invalid parameter (" << fNSegment[2] << ") "
233 << "in mesh element placement." << G4endl;
234
235 if(verboseLevel > 9) {
236 G4cout << fSize[0]/fNSegment[0] << ", "
237 << fSize[1]/fNSegment[1] << ", "
238 << fSize[2]/fNSegment[2] << G4endl;
239 G4cout << elementName << ": kZAxis, "
240 << fNSegment[2] << ", "
241 << 2.*fSize[2]/fNSegment[2] << G4endl;
242 }
243
244
245 // set the sensitive detector
246 fMeshElementLogical->SetSensitiveDetector(fMFD);
247
248
249 // vis. attributes
250 G4VisAttributes * visatt = new G4VisAttributes(G4Colour(.5,.5,.5));
251 visatt->SetVisibility(false);
252 layerLogical[0]->SetVisAttributes(visatt);
253 layerLogical[1]->SetVisAttributes(visatt);
254 visatt->SetVisibility(true);
255 fMeshElementLogical->SetVisAttributes(visatt);
256}
257
258
259void G4ScoringBox::List() const {
260 G4cout << "G4ScoringBox : " << fWorldName << " --- Shape: Box mesh" << G4endl;
261 G4cout << " Size (x, y, z): ("
262 << fSize[0]/cm << ", "
263 << fSize[1]/cm << ", "
264 << fSize[2]/cm << ") [cm]"
265 << G4endl;
266
267 G4VScoringMesh::List();
268}
269
270void G4ScoringBox::Draw(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap, G4int axflg) {
271
272 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
273 if(pVisManager) {
274
275 // cell vectors
276 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z]
277 std::vector<double> ez;
278 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.);
279 std::vector<std::vector<double> > eyz;
280 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez);
281 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz);
282
283 std::vector<std::vector<double> > xycell; // xycell[X][Y]
284 std::vector<double> ey;
285 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.);
286 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey);
287
288 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z]
289 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez);
290
291 std::vector<std::vector<double> > xzcell; // xzcell[X][Z]
292 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
293
294 G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
295 G4double xymax = 0., yzmax = 0., xzmax = 0.;
296 G4int q[3];
297 std::map<G4int, G4double*>::iterator itr = map->begin();
298 for(; itr != map->end(); itr++) {
299 GetXYZ(itr->first, q);
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
314 G4VisAttributes att;
315 att.SetForceSolid(true);
316 att.SetForceAuxEdgeVisible(true);
317
318 G4Scale3D scale;
319 if(axflg/100==1) {
320 // xy plane
321 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xymin ,xymax); }
322 G4ThreeVector zhalf(0., 0., fSize[2]/fNSegment[2]*0.98);
323 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]*0.01);
324 for(int x = 0; x < fNSegment[0]; x++) {
325 for(int y = 0; y < fNSegment[1]; y++) {
326 G4ThreeVector pos(GetReplicaPosition(x, y, 0) - zhalf);
327 G4ThreeVector pos2(GetReplicaPosition(x, y, fNSegment[2]-1) + zhalf);
328 G4Transform3D trans, trans2;
329 if(fRotationMatrix) {
330 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
331 trans = G4Translate3D(fCenterPosition)*trans;
332 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
333 trans2 = G4Translate3D(fCenterPosition)*trans2;
334 } else {
335 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
336 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
337 }
338 G4double c[4];
339 colorMap->GetMapColor(xycell[x][y], c);
340 att.SetColour(c[0], c[1], c[2]);//, c[3]);
341 pVisManager->Draw(xyplate, att, trans);
342 pVisManager->Draw(xyplate, att, trans2);
343
344 }
345 }
346 }
347 axflg = axflg%100;
348 if(axflg/10==1) {
349 // yz plane
350 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(yzmin, yzmax); }
351 G4ThreeVector xhalf(fSize[0]/fNSegment[0]*0.98, 0., 0.);
352 G4Box yzplate("yz", fSize[0]/fNSegment[0]*0.01, fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
353 for(int y = 0; y < fNSegment[1]; y++) {
354 for(int z = 0; z < fNSegment[2]; z++) {
355 G4ThreeVector pos(GetReplicaPosition(0, y, z) - xhalf);
356 G4ThreeVector pos2(GetReplicaPosition(fNSegment[0]-1, y, z) + xhalf);
357 G4Transform3D trans, trans2;
358 if(fRotationMatrix) {
359 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
360 trans = G4Translate3D(fCenterPosition)*trans;
361 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
362 trans2 = G4Translate3D(fCenterPosition)*trans2;
363 } else {
364 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
365 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
366 }
367 G4double c[4];
368 colorMap->GetMapColor(yzcell[y][z], c);
369 att.SetColour(c[0], c[1], c[2]);//, c[3]);
370 pVisManager->Draw(yzplate, att, trans);
371 pVisManager->Draw(yzplate, att, trans2);
372
373 }
374 }
375 }
376 axflg = axflg%10;
377 if(axflg==1) {
378 // xz plane
379 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(xzmin,xzmax); }
380 G4ThreeVector yhalf(0., fSize[1]/fNSegment[1]*0.98, 0.);
381 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1]*0.01, fSize[2]/fNSegment[2]);
382 for(int x = 0; x < fNSegment[0]; x++) {
383 for(int z = 0; z < fNSegment[2]; z++) {
384 G4ThreeVector pos(GetReplicaPosition(x, 0, z) - yhalf);
385 G4ThreeVector pos2(GetReplicaPosition(x, fNSegment[1]-1, z) + yhalf);
386 G4Transform3D trans, trans2;
387 if(fRotationMatrix) {
388 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
389 trans = G4Translate3D(fCenterPosition)*trans;
390 trans2 = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos2);
391 trans2 = G4Translate3D(fCenterPosition)*trans2;
392 } else {
393 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
394 trans2 = G4Translate3D(pos2)*G4Translate3D(fCenterPosition);
395 }
396 G4double c[4];
397 colorMap->GetMapColor(xzcell[x][z], c);
398 att.SetColour(c[0], c[1], c[2]);//, c[3]);
399 pVisManager->Draw(xzplate, att, trans);
400 pVisManager->Draw(xzplate, att, trans2);
401
402 }
403 }
404 }
405 }
406 colorMap->DrawColorChart();
407}
408
409G4ThreeVector G4ScoringBox::GetReplicaPosition(G4int x, G4int y, G4int z) {
410
411 G4ThreeVector width(fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
412 G4ThreeVector pos(-fSize[0] + 2*(x+0.5)*width.x(),
413 -fSize[1] + 2*(y+0.5)*width.y(),
414 -fSize[2] + 2*(z+0.5)*width.z());
415
416 return pos;
417}
418
419void G4ScoringBox::GetXYZ(G4int index, G4int q[3]) const {
420
421 q[0] = index/(fNSegment[2]*fNSegment[1]);
422 q[1] = (index - q[0]*fNSegment[2]*fNSegment[1])/fNSegment[2];
423 q[2] = index - q[1]*fNSegment[2] - q[0]*fNSegment[2]*fNSegment[1];
424
425}
426
427G4int G4ScoringBox::GetIndex(G4int x, G4int y, G4int z) const {
428 return x + y*fNSegment[0] + z*fNSegment[0]*fNSegment[1];
429}
430
431void G4ScoringBox::DrawColumn(std::map<G4int, G4double*> * map, G4VScoreColorMap* colorMap,
432 G4int idxProj, G4int idxColumn)
433{
434 if(idxColumn<0 || idxColumn>=fNSegment[idxProj])
435 {
436 G4cerr << "ERROR : Column number " << idxColumn << " is out of scoring mesh [0," << fNSegment[idxProj]-1 <<
437 "]. Method ignored." << G4endl;
438 return;
439 }
440 G4VVisManager * pVisManager = G4VVisManager::GetConcreteInstance();
441 if(pVisManager) {
442
443 // cell vectors
444 std::vector<std::vector<std::vector<double> > > cell; // cell[X][Y][Z]
445 std::vector<double> ez;
446 for(int z = 0; z < fNSegment[2]; z++) ez.push_back(0.);
447 std::vector<std::vector<double> > eyz;
448 for(int y = 0; y < fNSegment[1]; y++) eyz.push_back(ez);
449 for(int x = 0; x < fNSegment[0]; x++) cell.push_back(eyz);
450
451 std::vector<std::vector<double> > xycell; // xycell[X][Y]
452 std::vector<double> ey;
453 for(int y = 0; y < fNSegment[1]; y++) ey.push_back(0.);
454 for(int x = 0; x < fNSegment[0]; x++) xycell.push_back(ey);
455
456 std::vector<std::vector<double> > yzcell; // yzcell[Y][Z]
457 for(int y = 0; y < fNSegment[1]; y++) yzcell.push_back(ez);
458
459 std::vector<std::vector<double> > xzcell; // xzcell[X][Z]
460 for(int x = 0; x < fNSegment[0]; x++) xzcell.push_back(ez);
461
462 G4double xymax = 0., yzmax = 0., xzmax = 0.;
463 G4int q[3];
464 std::map<G4int, G4double*>::iterator itr = map->begin();
465 for(; itr != map->end(); itr++) {
466 GetXYZ(itr->first, q);
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
482 G4VisAttributes att;
483 att.SetForceSolid(true);
484 att.SetForceAuxEdgeVisible(true);
485
486
487 G4Scale3D scale;
488 // xy plane
489 if(idxProj == 0) {
490 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,xymax); }
491 G4Box xyplate("xy", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
492 for(int x = 0; x < fNSegment[0]; x++) {
493 for(int y = 0; y < fNSegment[1]; y++) {
494 G4ThreeVector pos(GetReplicaPosition(x, y, idxColumn));
495 G4Transform3D trans;
496 if(fRotationMatrix) {
497 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
498 trans = G4Translate3D(fCenterPosition)*trans;
499 } else {
500 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
501 }
502 G4double c[4];
503 colorMap->GetMapColor(xycell[x][y], c);
504 att.SetColour(c[0], c[1], c[2]);//, c[3]);
505 pVisManager->Draw(xyplate, att, trans);
506
507 }
508 }
509 } else
510 // yz plane
511 if(idxProj == 1) {
512 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,yzmax); }
513 G4Box yzplate("yz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
514 for(int y = 0; y < fNSegment[1]; y++) {
515 for(int z = 0; z < fNSegment[2]; z++) {
516 G4ThreeVector pos(GetReplicaPosition(idxColumn, y, z));
517 G4Transform3D trans;
518 if(fRotationMatrix) {
519 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
520 trans = G4Translate3D(fCenterPosition)*trans;
521 } else {
522 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
523 }
524 G4double c[4];
525 colorMap->GetMapColor(yzcell[y][z], c);
526 att.SetColour(c[0], c[1], c[2]);//, c[3]);
527 pVisManager->Draw(yzplate, att, trans);
528 }
529 }
530 } else
531 // xz plane
532 if(idxProj == 2) {
533 if(colorMap->IfFloatMinMax()) { colorMap->SetMinMax(0.,xzmax);}
534 G4Box xzplate("xz", fSize[0]/fNSegment[0], fSize[1]/fNSegment[1], fSize[2]/fNSegment[2]);
535 for(int x = 0; x < fNSegment[0]; x++) {
536 for(int z = 0; z < fNSegment[2]; z++) {
537 G4ThreeVector pos(GetReplicaPosition(x, idxColumn, z));
538 G4Transform3D trans;
539 if(fRotationMatrix) {
540 trans = G4Rotate3D(*fRotationMatrix).inverse()*G4Translate3D(pos);
541 trans = G4Translate3D(fCenterPosition)*trans;
542 } else {
543 trans = G4Translate3D(pos)*G4Translate3D(fCenterPosition);
544 }
545 G4double c[4];
546 colorMap->GetMapColor(xzcell[x][z], c);
547 att.SetColour(c[0], c[1], c[2]);//, c[3]);
548 pVisManager->Draw(xzplate, att, trans);
549 }
550 }
551 }
552 }
553
554 colorMap->DrawColorChart();
555}
556
557
Note: See TracBrowser for help on using the repository browser.