Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
G4GMocrenFileSceneHandler.cc
Go to the documentation of this file.
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$
28//
29//
30// Created: Mar. 31, 2009 Akinori Kimura
31// Sep. 22, 2009 Akinori Kimura : modify and fix code to support
32// PrimitiveScorers and clean up
33//
34// GMocrenFile scene handler
35
36
37//----- header files
38#include <fstream>
39#include <cstdlib>
40#include <cstring>
41#include <sstream>
42
43#include "globals.hh"
44#include "G4PhysicalConstants.hh"
45#include "G4SystemOfUnits.hh"
46#include "G4VisManager.hh"
47
48#include "G4GMocrenFile.hh"
49#include "G4GMocrenFileSceneHandler.hh"
50#include "G4GMocrenFileViewer.hh"
51#include "G4Point3D.hh"
52#include "G4VisAttributes.hh"
53#include "G4Scene.hh"
54#include "G4Transform3D.hh"
55#include "G4Polyhedron.hh"
56#include "G4Box.hh"
57#include "G4Cons.hh"
58#include "G4Polyline.hh"
59#include "G4Trd.hh"
60#include "G4Tubs.hh"
61#include "G4Trap.hh"
62#include "G4Torus.hh"
63#include "G4Sphere.hh"
64#include "G4Para.hh"
65#include "G4Text.hh"
66#include "G4Circle.hh"
67#include "G4Square.hh"
68#include "G4VPhysicalVolume.hh"
69#include "G4PhysicalVolumeModel.hh"
70#include "G4LogicalVolume.hh"
71#include "G4Material.hh"
72
73#include "G4VPVParameterisation.hh"
74#include "G4VVolumeMaterialScanner.hh"
75#include "G4VisTrajContext.hh"
76#include "G4TrajectoriesModel.hh"
77#include "G4VTrajectoryModel.hh"
78#include "G4TrajectoryDrawByCharge.hh"
79#include "G4HitsModel.hh"
80#include "G4GMocrenMessenger.hh"
81//#include "G4PSHitsModel.hh"
82#include "G4GMocrenIO.hh"
83#include "G4VNestedParameterisation.hh"
84#include "G4GMocrenTouchable.hh"
85#include "G4GMocrenFileCTtoDensityMap.hh"
86#include "G4PhantomParameterisation.hh"
87
88#include "G4ScoringManager.hh"
89#include "G4ScoringBox.hh"
90
91//----- constants
92const char GDD_FILE_HEADER [] = "g4_";
93const char DEFAULT_GDD_FILE_NAME[] = "g4_00.gdd";
94
95const G4int FR_MAX_FILE_NUM = 100 ;
96const G4int MAX_NUM_TRAJECTORIES = 100000;
97
98//-- for a debugging
99const G4bool GFDEBUG = false;
100const G4bool GFDEBUG_TRK = false;//true;
101const G4bool GFDEBUG_HIT = false;//true;
102const G4bool GFDEBUG_DIGI = false;//true;
103const G4int GFDEBUG_DET = 0; // 0: false
104
105//////////////////////
106// static variables //
107//////////////////////
108
109//----- static variables
110G4int G4GMocrenFileSceneHandler::kSceneIdCount = 0;
111
112///////////////////////////
113// Driver-dependent part //
114///////////////////////////
115
116
117//----- G4GMocrenFileSceneHandler, constructor
118G4GMocrenFileSceneHandler::G4GMocrenFileSceneHandler(G4GMocrenFile& system,
119 G4GMocrenMessenger & messenger,
120 const G4String& name)
121 : G4VSceneHandler(system, kSceneIdCount++, name),
122 kSystem(system),
123 kMessenger(messenger),
124 kgMocrenIO(new G4GMocrenIO()),
125 kbSetModalityVoxelSize(false),
126 kbModelingTrajectory(false),
127// kGddDest(0),
128 kFlagInModeling(false),
129 kFlagSaving_g4_gdd(false),
130 kFlagParameterization(0),
131 kFLagProcessedInteractiveScorer(false) {
132
133 // g4.gdd filename and its directory
134 if(getenv("G4GMocrenFile_DEST_DIR") == NULL) {
135 kGddDestDir[0] = '\0';
136 //std::strcpy(kGddDestDir , ""); // output dir
137 //std::strcpy(kGddFileName, DEFAULT_GDD_FILE_NAME); // filename
138 std::strncpy(kGddFileName, DEFAULT_GDD_FILE_NAME, std::strlen(DEFAULT_GDD_FILE_NAME)); // filename
139 } else {
140 const char * env = getenv("G4GMocrenFile_DEST_DIR");
141 std::strncpy(kGddDestDir, env, std::strlen(env)); // output dir
142 std::strncpy(kGddFileName, DEFAULT_GDD_FILE_NAME, std::strlen(DEFAULT_GDD_FILE_NAME)); // filename
143 }
144
145 // maximum number of g4.gdd files in the dest directory
146 kMaxFileNum = FR_MAX_FILE_NUM ; // initialization
147 if ( std::getenv( "G4GMocrenFile_MAX_FILE_NUM" ) != NULL ) {
148
149 std::sscanf( getenv("G4GMocrenFile_MAX_FILE_NUM"), "%d", &kMaxFileNum ) ;
150
151 } else {
152 kMaxFileNum = FR_MAX_FILE_NUM ;
153 }
154 if( kMaxFileNum < 1 ) { kMaxFileNum = 1 ; }
155
156 InitializeParameters();
157
158}
159
160
161//----- G4GMocrenFileSceneHandler, destructor
162G4GMocrenFileSceneHandler::~G4GMocrenFileSceneHandler ()
163{
164 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
165 G4cout << "***** ~G4GMocrenFileSceneHandler" << G4endl;
166
167 if(kGddDest) {
168 //----- End of modeling
169 // close g4.gdd
170 GFEndModeling();
171 }
172}
173
174//----- initialize all parameters
175void G4GMocrenFileSceneHandler::InitializeParameters() {
176
177 kbSetModalityVoxelSize = false;
178
179 for(G4int i = 0; i < 3; i++) {
180 kModalitySize[i] = 0;
181 kNestedVolumeDimension[i] = 0;
182 kNestedVolumeDirAxis[i] = -1;
183 }
184
185 // delete kgMocrenIO;
186
187}
188
189//-----
190void G4GMocrenFileSceneHandler::SetGddFileName()
191{
192 // g4_00.gdd, g4_01.gdd, ..., g4_MAX_FILE_INDEX.gdd
193 const G4int MAX_FILE_INDEX = kMaxFileNum - 1 ;
194
195 // dest directory (null if no environmental variables is set)
196 std::strncpy(kGddFileName, kGddDestDir, std::strlen(kGddDestDir));
197
198 // create full path name (default)
199 std::strncat ( kGddFileName, DEFAULT_GDD_FILE_NAME, std::strlen(DEFAULT_GDD_FILE_NAME));
200
201 // Automatic updation of file names
202 static G4int currentNumber = 0;
203 for( G4int i = currentNumber ; i < kMaxFileNum ; i++) {
204
205 // Message in the final execution
206 if( i == MAX_FILE_INDEX )
207 {
208 if (G4VisManager::GetVerbosity() >= G4VisManager::warnings) {
209 G4cout << "===========================================" << G4endl;
210 G4cout << "WARNING MESSAGE from GMocrenFile driver: " << G4endl;
211 G4cout << " This file name is the final one in the " << G4endl;
212 G4cout << " automatic updation of the output file name." << G4endl;
213 G4cout << " You may overwrite existing files, i.e. " << G4endl;
214 G4cout << " g4_XX.gdd." << G4endl;
215 G4cout << "===========================================" << G4endl;
216 }
217 }
218
219 // re-determine file name as G4GMocrenFile_DEST_DIR/g4_XX.gdd
220 if( i >= 0 && i <= 9 ) {
221 std::sprintf( kGddFileName, "%s%s%s%d.gdd" , kGddDestDir, GDD_FILE_HEADER, "0", i );
222 } else {
223 std::sprintf( kGddFileName, "%s%s%d.gdd" , kGddDestDir, GDD_FILE_HEADER, i );
224 }
225
226 // check validity of the file name
227 std::ifstream fin(kGddFileName);
228 if(GFDEBUG)
229 G4cout << "FILEOPEN: " << i << " : " << kGddFileName << fin.fail() << G4endl;
230 if(!fin) {
231 // new file
232 fin.close();
233 currentNumber = i+1;
234 break;
235 } else {
236 // already exists (try next)
237 fin.close();
238 }
239
240 } // for
241
242 G4cout << "======================================================================" << G4endl;
243 G4cout << "Output file: " << kGddFileName << G4endl;
244 G4cout << "Destination directory (current dir if NULL): " << kGddDestDir << G4endl;
245 G4cout << "Maximum number of files in the destination directory: " << kMaxFileNum << G4endl;
246 G4cout << "Note:" << G4endl;
247 G4cout << " * The maximum number is customizable as: " << G4endl;
248 G4cout << " % setenv G4GMocrenFile_MAX_FILE_NUM number " << G4endl;
249 G4cout << " * The destination directory is customizable as:" << G4endl;
250 G4cout << " % setenv G4GMocrenFile_DEST_DIR dir_name/ " << G4endl;
251 G4cout << " ** Do not forget \"/\" at the end of the dir_name, e.g. \"./tmp/\"." << G4endl;
252 //G4cout << " dir_name, e.g. \"./tmp/\"." << G4endl;
253 G4cout << G4endl;
254 G4cout << "Maximum number of trajectories is set to " << MAX_NUM_TRAJECTORIES << "."<< G4endl;
255 G4cout << "======================================================================" << G4endl;
256
257} // G4GMocrenFileSceneHandler::SetGddFileName()
258
259
260//-----
261void G4GMocrenFileSceneHandler::BeginSavingGdd( void )
262{
263 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
264 G4cout << "***** BeginSavingGdd (called)" << G4endl;
265
266 if( !IsSavingGdd() ) {
267
268 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations) {
269 G4cout << "***** (started) " ;
270 G4cout << "(open g4.gdd, ##)" << G4endl;
271 }
272
273 SetGddFileName() ; // result set to kGddFileName
274 kFlagSaving_g4_gdd = true;
275
276
277 G4GMocrenFileCTtoDensityMap ctdens;
278 short minmax[2];
279 minmax[0] = ctdens.GetMinCT();
280 minmax[1] = ctdens.GetMaxCT();
281 kgMocrenIO->setModalityImageMinMax(minmax);
282 std::vector<G4float> map;
283 G4float dens;
284 for(G4int i = minmax[0]; i <= minmax[1]; i++) {
285 dens = ctdens.GetDensity(i);
286 map.push_back(dens);
287 }
288 kgMocrenIO->setModalityImageDensityMap(map);
289
290 /*
291 G4String fname = "modality-map.dat";
292 std::ifstream ifile(fname);
293 if(ifile) {
294 short minmax[2];
295 ifile >> minmax[0] >> minmax[1];
296 kgMocrenIO->setModalityImageMinMax(minmax);
297 std::vector<G4float> map;
298 G4float dens;
299 for(G4int i = minmax[0]; i <= minmax[1]; i++) {
300 ifile >> dens;
301 map.push_back(dens);
302 }
303 kgMocrenIO->setModalityImageDensityMap(map);
304
305 } else {
306 G4cout << "cann't open the file : " << fname << G4endl;
307 }
308 */
309
310 // mesh size
311 //kMessenger.getNoVoxels(kModalitySize[0], kModalitySize[1], kModalitySize[2]);
312 //kgMocrenIO->setModalityImageSize(kModalitySize);
313
314 // initializations
315 //kgMocrenIO->clearModalityImage();
316 kgMocrenIO->clearDoseDistAll();
317 kgMocrenIO->clearROIAll();
318 kgMocrenIO->clearTracks();
319 kgMocrenIO->clearDetector();
320 std::vector<Detector>::iterator itr = kDetectors.begin();
321 for(; itr != kDetectors.end(); itr++) {
322 itr->clear();
323 }
324 kDetectors.clear();
325
326 kNestedHitsList.clear();
327 kNestedVolumeNames.clear();
328
329 }
330}
331
332void G4GMocrenFileSceneHandler::EndSavingGdd ( void )
333{
334 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
335 G4cout << "***** EndSavingGdd (called)" << G4endl;
336
337 if(IsSavingGdd()) {
338 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
339 G4cout << "***** (started) (close "
340 << kGddFileName << ")" << G4endl;
341
342 if(kGddDest) kGddDest.close();
343 kFlagSaving_g4_gdd = false;
344
345 std::map<Index3D, G4float>::iterator itr = kNestedModality.begin();
346 G4int xmax=0, ymax=0, zmax=0;
347 for(; itr != kNestedModality.end(); itr++) {
348 if(itr->first.x > xmax) xmax = itr->first.x;
349 if(itr->first.y > ymax) ymax = itr->first.y;
350 if(itr->first.z > zmax) zmax = itr->first.z;
351 }
352 // mesh size
353 kModalitySize[0] = xmax+1;
354 kModalitySize[1] = ymax+1;
355 kModalitySize[2] = zmax+1;
356 kgMocrenIO->setModalityImageSize(kModalitySize);
357 if(GFDEBUG) G4cout << "gMocren-file driver : modality size : "
358 << kModalitySize[0] << " x "
359 << kModalitySize[1] << " x "
360 << kModalitySize[2] << G4endl;
361
362 G4int nxy = kModalitySize[0]*kModalitySize[1];
363 //std::map<G4int, G4float>::iterator itr;
364 for(G4int z = 0; z < kModalitySize[2]; z++) {
365 short * modality = new short[nxy];
366 for(G4int y = 0; y < kModalitySize[1]; y++) {
367 for(G4int x = 0; x < kModalitySize[0]; x++) {
368 //for(G4int x = kModalitySize[0]-1; x >= 0 ; x--) {
369 //G4int ixy = x + (kModalitySize[1]-y-1)*kModalitySize[0];
370
371 G4int ixy = x + y*kModalitySize[0];
372 Index3D idx(x,y,z);
373 itr = kNestedModality.find(idx);
374 if(itr != kNestedModality.end()) {
375
376 modality[ixy] = kgMocrenIO->convertDensityToHU(itr->second);
377 } else {
378 modality[ixy] = -1024;
379 }
380
381 }
382 }
383 kgMocrenIO->setModalityImage(modality);
384 }
385
386 //-- dose
387 size_t nhits = kNestedHitsList.size();
388 if(GFDEBUG) G4cout << "gMocren-file driver : # hits = " << nhits << G4endl;
389
390 std::map<Index3D, G4double>::iterator hitsItr;
391 std::map<G4String, std::map<Index3D, G4double> >::iterator hitsListItr = kNestedHitsList.begin();
392
393 for(G4int n = 0; hitsListItr != kNestedHitsList.end(); hitsListItr++, n++) {
394
395 kgMocrenIO->newDoseDist();
396 kgMocrenIO->setDoseDistName(hitsListItr->first, n);
397 kgMocrenIO->setDoseDistSize(kModalitySize, n);
398
399 G4double minmax[2] = {DBL_MAX, -DBL_MAX};
400 for(G4int z = 0 ; z < kModalitySize[2]; z++) {
401 G4double * values = new G4double[nxy];
402 for(G4int y = 0; y < kModalitySize[1]; y++) {
403 for(G4int x = 0; x < kModalitySize[0]; x++) {
404
405 G4int ixy = x + y*kModalitySize[0];
406 Index3D idx(x,y,z);
407 hitsItr = hitsListItr->second.find(idx);
408 if(hitsItr != hitsListItr->second.end()) {
409
410 values[ixy] = hitsItr->second;
411 } else {
412 values[ixy] = 0.;
413 }
414 if(values[ixy] < minmax[0]) minmax[0] = values[ixy];
415 if(values[ixy] > minmax[1]) minmax[1] = values[ixy];
416 }
417 }
418 kgMocrenIO->setDoseDist(values, n);
419 }
420 kgMocrenIO->setDoseDistMinMax(minmax, n);
421 G4double lower = 0.;
422 if(minmax[0] < 0) lower = minmax[0];
423 G4double scale = (minmax[1]-lower)/25000.;
424 kgMocrenIO->setDoseDistScale(scale, n);
425 G4String sunit("unit?"); //temporarily
426 kgMocrenIO->setDoseDistUnit(sunit, n);
427 }
428
429
430 //-- draw axes
431 if(false) {//true,false
432 G4ThreeVector trans;
433 G4RotationMatrix rot;
434 trans = kVolumeTrans3D.getTranslation();
435 rot = kVolumeTrans3D.getRotation().inverse();
436 // x
437 std::vector<G4float *> tracks;
438 unsigned char colors[3];
439 G4float * trk = new G4float[6];
440 tracks.push_back(trk);
441
442 G4ThreeVector orig(0.,0.,0), xa(2000.,0.,0.), ya(0.,2000.,0.), za(0.,0.,2000.);
443 orig -= trans;
444 orig.transform(rot);
445 xa -= trans;
446 xa.transform(rot);
447 ya -= trans;
448 ya.transform(rot);
449 za -= trans;
450 za.transform(rot);
451 for(G4int i = 0; i < 3; i++) trk[i] = orig[i];
452 for(G4int i = 0; i < 3; i++) trk[i+3] = xa[i];
453 colors[0] = 255; colors[1] = 0; colors[2] = 0;
454 kgMocrenIO->addTrack(tracks, colors);
455 // y
456 for(G4int i = 0; i < 3; i++) trk[i+3] = ya[i];
457 colors[0] = 0; colors[1] = 255; colors[2] = 0;
458 kgMocrenIO->addTrack(tracks, colors);
459 // z
460 for(G4int i = 0; i < 3; i++) trk[i+3] = za[i];
461 colors[0] = 0; colors[1] = 0; colors[2] = 255;
462 kgMocrenIO->addTrack(tracks, colors);
463 }
464
465 //-- detector
466 ExtractDetector();
467
468
469 if(GFDEBUG_DET) G4cout << ">>>>>>>>>>>>>>>>>>>>>> (";
470 std::vector<G4float> transformObjects;
471 for(G4int i = 0; i < 3; i++) {
472 // need to check!!
473 transformObjects.push_back((kVolumeSize[i]/2. - kVoxelDimension[i]/2.));
474 if(GFDEBUG_DET) G4cout << transformObjects[i] << ", ";
475 }
476 if(GFDEBUG_DET) G4cout << ")" << G4endl;
477
478
479 kgMocrenIO->translateTracks(transformObjects);
480 kgMocrenIO->translateDetector(transformObjects);
481
482 // store
483 kgMocrenIO->storeData(kGddFileName);
484 }
485
486}
487
488
489//-----
490void G4GMocrenFileSceneHandler::GFBeginModeling( void )
491{
492 G4VSceneHandler::BeginModeling();
493
494 if( !GFIsInModeling() ) {
495
496
497 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
498 G4cout << "***** G4GMocrenFileSceneHandler::GFBeginModeling (called & started)" << G4endl;
499
500 //----- Send saving command and heading comment
501 BeginSavingGdd();
502
503 kFlagInModeling = true ;
504
505 // These models are entrusted to user commands /vis/scene/add/psHits or hits
506 //GetScene()->AddEndOfEventModel(new G4PSHitsModel());
507 //GetScene()->AddEndOfRunModel(new G4PSHitsModel());
508 //scene->AddEndOfEventModel(new G4HitsModel());
509 if(GFDEBUG_HIT) {
510 G4Scene * scene = GetScene();
511 std::vector<G4Scene::Model> vmodel = scene->GetEndOfEventModelList();
512 std::vector<G4Scene::Model>::iterator itr = vmodel.begin();
513 for(; itr != vmodel.end(); itr++) {
514 G4cout << " IIIIII model name: " << itr->fpModel->GetGlobalTag() << G4endl;
515 }
516 }
517
518 } // if
519}
520
521
522//========== AddPrimitive() functions ==========//
523
524//----- Add polyline
525void G4GMocrenFileSceneHandler::AddPrimitive (const G4Polyline& polyline)
526{
527 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
528 G4cout << "***** AddPrimitive" << G4endl;
529
530 if (fProcessing2D) {
531 static G4bool warned = false;
532 if (!warned) {
533 warned = true;
534 G4Exception
535 ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Polyline&)",
536 "gMocren1001", JustWarning,
537 "2D polylines not implemented. Ignored.");
538 }
539 return;
540 }
541
542 //----- Initialize if necessary
543 GFBeginModeling();
544
545 static G4int numTrajectories = 0;
546 if(numTrajectories >= MAX_NUM_TRAJECTORIES) return;
547
548 // draw trajectories
549 if(kbModelingTrajectory) {
550
551 G4TrajectoriesModel * pTrModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
552 if (!pTrModel) {
553 G4Exception
554 ("G4VSceneHandler::AddCompound(const G4Polyline&)",
555 "gMocren0002", FatalException, "Not a G4TrajectoriesModel.");
556 }
557
558 G4ThreeVector trans;
559 G4RotationMatrix rot;
560 trans = kVolumeTrans3D.getTranslation();
561 rot = kVolumeTrans3D.getRotation().inverse();
562
563 if(GFDEBUG_TRK) G4cout << " trajectory points : " << G4endl;
564 std::vector<G4float *> trajectory;
565 if(polyline.size() < 2) return;
566 G4Polyline::const_iterator preitr = polyline.begin();
567 G4Polyline::const_iterator postitr = preitr; postitr++;
568 for(; postitr != polyline.end(); preitr++, postitr++) {
569 G4ThreeVector prePts(preitr->x(), preitr->y(), preitr->z());
570 prePts -= trans;
571 prePts.transform(rot);
572 G4ThreeVector postPts(postitr->x(), postitr->y(), postitr->z());
573 postPts -= trans;
574 postPts.transform(rot);
575 G4float * stepPts = new G4float[6];
576 stepPts[0] = prePts.x();
577 stepPts[1] = prePts.y();
578 stepPts[2] = prePts.z();
579 stepPts[3] = postPts.x();
580 stepPts[4] = postPts.y();
581 stepPts[5] = postPts.z();
582 trajectory.push_back(stepPts);
583
584 if(GFDEBUG_TRK) {
585 G4cout << " ("
586 << stepPts[0] << ", "
587 << stepPts[1] << ", "
588 << stepPts[2] << ") - ("
589 << stepPts[3] << ", "
590 << stepPts[4] << ", "
591 << stepPts[5] << ")" << G4endl;
592 }
593 }
594
595 const G4VisAttributes * att = polyline.GetVisAttributes();
596 G4Color color = att->GetColor();
597 unsigned char trkcolor[3];
598 trkcolor[0] = (unsigned char)(color.GetRed()*255);
599 trkcolor[1] = (unsigned char)(color.GetGreen()*255);
600 trkcolor[2] = (unsigned char)(color.GetBlue()*255);
601 if(GFDEBUG_TRK) {
602 G4cout << " color : ["
603 << color.GetRed() << ", "
604 << color.GetGreen() << ", "
605 << color.GetBlue() << "]" << G4endl;
606 }
607
608 kgMocrenIO->addTrack(trajectory, trkcolor);
609
610 numTrajectories++;
611 }
612
613} // G4GMocrenFileSceneHandler::AddPrimitive (polyline)
614
615
616//----- Add nurbes
617void G4GMocrenFileSceneHandler::AddPrimitive (const G4NURBS&)
618{
619 //-----
620 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
621 G4cout << "***** AddPrimitive( G4NURBS )" << G4endl;
622
623 //----- Initialize if necessary
624 GFBeginModeling();
625
626}
627
628
629
630//----- Add text
631void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Text& text )
632{
633 if (fProcessing2D) {
634 static G4bool warned = false;
635 if (!warned) {
636 warned = true;
637 G4Exception
638 ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Text&)",
639 "gMocren1002", JustWarning,
640 "2D text not implemented. Ignored.");
641 }
642 return;
643 }
644
645 // to avoid a warning in the compile process
646 G4Text dummytext = text;
647
648 //-----
649 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
650 G4cout << "***** AddPrimitive( G4Text )" << G4endl;
651
652 //----- Initialize IF NECESSARY
653 GFBeginModeling();
654
655} // G4GMocrenFileSceneHandler::AddPrimitive ( text )
656
657
658//----- Add circle
659void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Circle& mark_circle )
660{
661 // to avoid a warning in the compile process
662 G4Circle dummycircle = mark_circle;
663
664 if (fProcessing2D) {
665 static G4bool warned = false;
666 if (!warned) {
667 warned = true;
668 G4Exception
669 ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Circle&)",
670 "gMocren1003", JustWarning,
671 "2D circles not implemented. Ignored.");
672 }
673 return;
674 }
675
676 //-----
677 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
678 G4cout << "***** AddPrimitive( G4Circle )" << G4endl;
679
680 //----- Initialize IF NECESSARY
681 GFBeginModeling();
682
683
684} // G4GMocrenFileSceneHandler::AddPrimitive ( mark_circle )
685
686
687//----- Add square
688void G4GMocrenFileSceneHandler::AddPrimitive (const G4Square& mark_square )
689{
690 // to avoid a warning in the compile process
691 G4Square dummysquare = mark_square;
692
693 if (fProcessing2D) {
694 static G4bool warned = false;
695 if (!warned) {
696 warned = true;
697 G4Exception
698 ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Square&)",
699 "gMocren1004", JustWarning,
700 "2D squares not implemented. Ignored.");
701 }
702 return;
703 }
704
705 //-----
706 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
707 G4cout << "***** AddPrimitive( G4Square )" << G4endl;
708
709 //----- Initialize if necessary
710 GFBeginModeling();
711
712} // G4GMocrenFileSceneHandler::AddPrimitive ( mark_square )
713
714
715//----- Add polyhedron
716void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Polyhedron& polyhedron )
717{
718 //-----
719 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
720 G4cout << "***** AddPrimitive( G4Polyhedron )" << G4endl;
721
722
723 if (polyhedron.GetNoFacets() == 0) return;
724
725 if (fProcessing2D) {
726 static G4bool warned = false;
727 if (!warned) {
728 warned = true;
729 G4Exception
730 ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Polyhedron&)",
731 "gMocren1005", JustWarning,
732 "2D polyhedra not implemented. Ignored.");
733 }
734 return;
735 }
736
737 //----- Initialize if necessary
738 GFBeginModeling();
739
740 //---------- (3) Facet block
741 for (G4int f = polyhedron.GetNoFacets(); f; f--){
742 G4bool notLastEdge = true;
743 G4int index = -1; // initialization
744 G4int edgeFlag = 1;
745 //G4int preedgeFlag = 1;
746 //G4int work[4], i = 0;
747 G4int i = 0;
748 do {
749 //preedgeFlag = edgeFlag;
750 notLastEdge = polyhedron.GetNextVertexIndex(index, edgeFlag);
751 //work[i++] = index;
752 i++;
753 }while (notLastEdge);
754 switch (i){
755 case 3:
756 //SendStrInt3(FR_FACET, work[0], work[1], work[2] );
757 break;
758 case 4:
759 //SendStrInt4(FR_FACET, work[0], work[1], work[2], work[3] );
760 break;
761 default:
762 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
763 G4cout <<
764 "ERROR G4GMocrenFileSceneHandler::AddPrimitive(G4Polyhedron)" << G4endl;
765 G4PhysicalVolumeModel* pPVModel =
766 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
767 if (pPVModel)
768 if(G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
769 G4cout << "Volume " << pPVModel->GetCurrentPV()->GetName() <<
770 ", Solid " << pPVModel->GetCurrentLV()->GetSolid()->GetName() <<
771 " (" << pPVModel->GetCurrentLV()->GetSolid()->GetEntityType();
772
773 if(G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
774 G4cout <<
775 "\nG4Polyhedron facet with " << i << " edges" << G4endl;
776 }
777 }
778
779} // G4GMocrenFileSceneHandler::AddPrimitive (polyhedron)
780
781
782//-----
783void G4GMocrenFileSceneHandler::GFEndModeling ()
784{
785 G4VSceneHandler::EndModeling();
786
787 //-----
788 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
789 G4cout << "***** GFEndModeling (called)" << G4endl;
790
791 if( GFIsInModeling() ) {
792
793 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations) {
794 G4cout << "***** GFEndModeling (started) " ;
795 G4cout << "(/EndModeling, /DrawAll, /CloseDevice)" << G4endl;
796 }
797
798 //----- End saving data to g4.gdd
799 EndSavingGdd() ;
800
801 //------ Reset flag
802 kFlagInModeling = false ;
803
804 }
805
806}
807
808
809//-----
810void G4GMocrenFileSceneHandler::BeginPrimitives (const G4Transform3D& objectTransformation)
811{
812 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
813 G4cout << "***** BeginPrimitives " << G4endl;
814
815 GFBeginModeling();
816
817 G4VSceneHandler::BeginPrimitives (objectTransformation);
818
819}
820
821
822//-----
823void G4GMocrenFileSceneHandler::EndPrimitives ()
824{
825 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
826 G4cout << "***** EndPrimitives " << G4endl;
827
828 G4VSceneHandler::EndPrimitives ();
829}
830
831
832//========== AddSolid() functions ==========//
833
834//----- Add box
835void G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )
836{
837 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
838 G4cout << "***** AddSolid ( box )" << G4endl;
839
840 if(GFDEBUG_DET > 0)
841 G4cout << "G4GMocrenFileSceneHandler::AddSolid(const G4Box&) : "
842 << box.GetName() << G4endl;
843
844 //----- skip drawing invisible primitive
845 if( !IsVisible() ) { return ; }
846
847 //----- Initialize if necessary
848 GFBeginModeling();
849
850
851 //--
852 if(GFDEBUG_DET > 1) {
853 G4cout << "-------" << G4endl;
854 G4cout << " " << box.GetName() << G4endl;
855 G4Polyhedron * poly = box.CreatePolyhedron();
856 poly->Transform(fObjectTransformation);
857 //G4int nv = poly->GetNoVertices();
858 G4Point3D v1, v2;
859 G4int next;
860 //while(1) { // next flag isn't functional.
861 for(G4int i = 0; i < 12; i++) { // # of edges is 12.
862 poly->GetNextEdge(v1, v2, next);
863 if(next == 0) break;
864 G4cout << " (" << v1.x() << ", "
865 << v1.y() << ", "
866 << v1.z() << ") - ("
867 << v2.x() << ", "
868 << v2.y() << ", "
869 << v2.z() << ") [" << next << "]"
870 << G4endl;
871 }
872 delete poly;
873 }
874
875
876 // the volume name set by /vis/gMocren/setVolumeName
877 G4String volName = kMessenger.getVolumeName();
878
879 if(kFlagParameterization != 2) {
880 G4ScoringManager * pScrMan = G4ScoringManager::GetScoringManager();
881 if(pScrMan) {
882 G4ScoringBox * pScBox = dynamic_cast<G4ScoringBox*>(pScrMan->FindMesh(volName));
883 G4bool bMesh = false;
884 if(pScBox != NULL) bMesh = true;
885 if(bMesh) kFlagParameterization = 2;
886 if(GFDEBUG_DET > 0) G4cout << " G4ScoringManager::FindMesh() : "
887 << volName << " - " << bMesh << G4endl;
888 }
889 }
890
891 const G4VModel* pv_model = GetModel();
892 if (!pv_model) { return ; }
893 G4PhysicalVolumeModel* pPVModel =
894 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
895 if (!pPVModel) { return ; }
896
897
898 //-- debug information
899 if(GFDEBUG_DET > 0) {
900 G4Material * mat = pPVModel->GetCurrentMaterial();
901 G4String name = mat->GetName();
902 G4double dens = mat->GetDensity()/(g/cm3);
903 G4int copyNo = pPVModel->GetCurrentPV()->GetCopyNo();
904 G4int depth = pPVModel->GetCurrentDepth();
905 G4cout << " copy no.: " << copyNo << G4endl;
906 G4cout << " depth : " << depth << G4endl;
907 G4cout << " density : " << dens << " [g/cm3]" << G4endl;
908 G4cout << " location: " << pPVModel->GetCurrentPV()->GetObjectTranslation() << G4endl;
909 G4cout << " Multiplicity : " << pPVModel->GetCurrentPV()->GetMultiplicity() << G4endl;
910 G4cout << " Is replicated? : " << pPVModel->GetCurrentPV()->IsReplicated() << G4endl;
911 G4cout << " Is parameterised? : " << pPVModel->GetCurrentPV()->IsParameterised() << G4endl;
912 G4cout << " top phys. vol. name : " << pPVModel->GetTopPhysicalVolume()->GetName() << G4endl;
913 }
914
915 //-- check the parameterised volume
916 if(box.GetName() == volName) {
917
918 kVolumeTrans3D = fObjectTransformation;
919 // coordination system correction for gMocren
920 G4ThreeVector raxis(1., 0., 0.), dummy(0.,0.,0.);
921 G4RotationMatrix rot(raxis, pi*rad);
922 G4Transform3D trot(rot, dummy);
923 if(GFDEBUG_DET) {
924 G4ThreeVector trans1 = kVolumeTrans3D.getTranslation();
925 G4RotationMatrix rot1 = kVolumeTrans3D.getRotation().inverse();
926 G4cout << "kVolumeTrans3D: " << trans1 << G4endl << rot1 << G4endl;
927 }
928 kVolumeTrans3D = kVolumeTrans3D*trot;
929 if(GFDEBUG_DET) G4cout << " Parameterised volume : " << box.GetName() << G4endl;
930
931
932
933 //
934 G4VPhysicalVolume * pv[3] = {0,0,0};
935 pv[0] = pPVModel->GetCurrentPV()->GetLogicalVolume()->GetDaughter(0);
936 if(!pv[0]) {
937 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
938 "gMocren0003", FatalException, "Unexpected volume.");
939 }
940 G4int dirAxis[3] = {-1,-1,-1};
941 G4int nDaughters[3] = {0,0,0};
942
943 EAxis axis; G4int nReplicas; G4double width; G4double offset; G4bool consuming;
944 pv[0]->GetReplicationData(axis, nReplicas, width, offset, consuming);
945 nDaughters[0] = nReplicas;
946 switch(axis) {
947 case kXAxis: dirAxis[0] = 0; break;
948 case kYAxis: dirAxis[0] = 1; break;
949 case kZAxis: dirAxis[0] = 2; break;
950 default:
951 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
952 "gMocren0004", FatalException, "Error.");
953 }
954 kNestedVolumeNames.push_back(pv[0]->GetName());
955 if(GFDEBUG_DET)
956 G4cout << " daughter name : " << pv[0]->GetName()
957 << " # : " << nDaughters[0] << G4endl;
958
959 //
960 if(GFDEBUG_DET) {
961 if(pv[0]->GetLogicalVolume()->GetNoDaughters()) {
962 G4cout << "# of daughters : "
963 << pv[0]->GetLogicalVolume()->GetNoDaughters() << G4endl;
964 } else {
965 //G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
966 // "gMocren0005", FatalException, "Error.");
967 }
968 }
969
970 // check whether nested or regular parameterization
971 if(GFDEBUG_DET) G4cout << "# of daughters : "
972 << pv[0]->GetLogicalVolume()->GetNoDaughters() << G4endl;
973 if(pv[0]->GetLogicalVolume()->GetNoDaughters() == 0) {
974 kFlagParameterization = 1;
975 //G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
976 // "gMocren0006", FatalException, "Error.");
977 }
978
979 if(kFlagParameterization == 0) {
980
981 pv[1] = pv[0]->GetLogicalVolume()->GetDaughter(0);
982 if(pv[1]) {
983 pv[1]->GetReplicationData(axis, nReplicas, width, offset, consuming);
984 nDaughters[1] = nReplicas;
985 switch(axis) {
986 case kXAxis: dirAxis[1] = 0; break;
987 case kYAxis: dirAxis[1] = 1; break;
988 case kZAxis: dirAxis[1] = 2; break;
989 default:
990 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
991 "gMocren0007", FatalException, "Error.");
992 }
993 kNestedVolumeNames.push_back(pv[1]->GetName());
994 if(GFDEBUG_DET)
995 G4cout << " sub-daughter name : " << pv[1]->GetName()
996 << " # : " << nDaughters[1]<< G4endl;
997
998 //
999 pv[2] = pv[1]->GetLogicalVolume()->GetDaughter(0);
1000 if(pv[2]) {
1001 nDaughters[2] = pv[2]->GetMultiplicity();
1002 kNestedVolumeNames.push_back(pv[2]->GetName());
1003 if(GFDEBUG_DET)
1004 G4cout << " sub-sub-daughter name : " << pv[2]->GetName()
1005 << " # : " << nDaughters[2] << G4endl;
1006
1007 if(nDaughters[2] > 1) {
1008 G4VNestedParameterisation * nestPara
1009 = dynamic_cast<G4VNestedParameterisation*>(pv[2]->GetParameterisation());
1010 if(nestPara == NULL)
1011 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
1012 "gMocren0008", FatalException, "Non-nested parameterisation");
1013
1014 nestPara->ComputeTransformation(0, pv[2]);
1015 G4ThreeVector trans0 = pv[2]->GetObjectTranslation();
1016 nestPara->ComputeTransformation(1, pv[2]);
1017 G4ThreeVector trans1 = pv[2]->GetObjectTranslation();
1018 G4ThreeVector diff(trans0 - trans1);
1019 if(GFDEBUG_DET)
1020 G4cout << trans0 << " - " << trans1 << " - " << diff << G4endl;
1021
1022 if(diff.x() != 0.) dirAxis[2] = 0;
1023 else if(diff.y() != 0.) dirAxis[2] = 1;
1024 else if(diff.z() != 0.) dirAxis[2] = 2;
1025 else
1026 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
1027 "gMocren0009", FatalException, "Unexpected nested parameterisation");
1028 }
1029 }
1030 }
1031
1032 for(G4int i = 0; i < 3; i++) {
1033 kNestedVolumeDimension[i] = nDaughters[i];
1034 //kNestedVolumeDimension[i] = nDaughters[dirAxis[i]];
1035 kNestedVolumeDirAxis[i] = dirAxis[i];
1036 }
1037 //G4cout << "@@@@@@@@@ "
1038 // << dirAxis[0] << ", " << dirAxis[1] << ", " << dirAxis[2] << G4endl;
1039
1040 // get densities
1041 G4VNestedParameterisation * nestPara
1042 = dynamic_cast<G4VNestedParameterisation*>(pv[2]->GetParameterisation());
1043 if(nestPara != NULL) {
1044 G4double prexyz[3] = {0.,0.,0.}, xyz[3] = {0.,0.,0.};
1045 for(G4int n0 = 0; n0 < nDaughters[0]; n0++) {
1046 for(G4int n1 = 0; n1 < nDaughters[1]; n1++) {
1047 for(G4int n2 = 0; n2 < nDaughters[2]; n2++) {
1048
1049 G4GMocrenTouchable * touch = new G4GMocrenTouchable(n1, n0);
1050 if(GFDEBUG_DET)
1051 G4cout << " retrieve volume : copy # : " << n0
1052 << ", " << n1 << ", " << n2 << G4endl;
1053 G4Material * mat = nestPara->ComputeMaterial(pv[2], n2, touch);
1054 delete touch;
1055 G4double dens = mat->GetDensity()/(g/cm3);
1056
1057 if(GFDEBUG_DET)
1058 G4cout << " density :" << dens << " [g/cm3]" << G4endl;
1059
1060 G4Box tbox(box);
1061 nestPara->ComputeDimensions(tbox, n2, pv[2]);
1062 xyz[0] = tbox.GetXHalfLength()/mm;
1063 xyz[1] = tbox.GetYHalfLength()/mm;
1064 xyz[2] = tbox.GetZHalfLength()/mm;
1065 if(n0 != 0 || n1 != 0 || n2 != 0) {
1066 for(G4int i = 0; i < 3; i++) {
1067 if(xyz[i] != prexyz[i])
1068 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
1069 "gMocren0010", FatalException, "Unsupported parameterisation");
1070 }
1071 }
1072 if(GFDEBUG_DET)
1073 G4cout << " size : " << tbox.GetXHalfLength()/mm << " x "
1074 << tbox.GetYHalfLength()/mm << " x "
1075 << tbox.GetZHalfLength()/mm << " [mm3]" << G4endl;
1076
1077 G4int idx[3];
1078 idx[dirAxis[0]] = n0;
1079 idx[dirAxis[1]] = n1;
1080 idx[dirAxis[2]] = n2;
1081 Index3D i3d(idx[0],idx[1],idx[2]);
1082 kNestedModality[i3d] = dens;
1083 if(GFDEBUG_DET)
1084 G4cout << " index: " << idx[0] << ", " << idx[1] << ", " << idx[2]
1085 << " density: " << dens << G4endl;
1086
1087 for(G4int i = 0; i < 3; i++) prexyz[i] = xyz[i];
1088 }
1089 }
1090 }
1091
1092 kVolumeSize.set(box.GetXHalfLength()*2/mm,
1093 box.GetYHalfLength()*2/mm,
1094 box.GetZHalfLength()*2/mm);
1095 // mesh size
1096 if(!kbSetModalityVoxelSize) {
1097 G4float spacing[3] = {static_cast<G4float>(2*xyz[0]),
1098 static_cast<G4float>(2*xyz[1]),
1099 static_cast<G4float>(2*xyz[2])};
1100 kgMocrenIO->setVoxelSpacing(spacing);
1101 kVoxelDimension.set(spacing[0], spacing[1], spacing[2]);
1102 kbSetModalityVoxelSize = true;
1103 }
1104
1105 } else {
1106 if(GFDEBUG_DET)
1107 G4cout << pv[2]->GetName() << G4endl;
1108 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
1109 "gMocren0011", FatalException, "Non-nested parameterisation");
1110 }
1111
1112
1113
1114 //-- debug
1115 if(GFDEBUG_DET > 1) {
1116 if(pPVModel->GetCurrentPV()->IsParameterised()) {
1117 G4VPVParameterisation * para = pPVModel->GetCurrentPV()->GetParameterisation();
1118 G4cout << " Is nested parameterisation? : " << para->IsNested() << G4endl;
1119
1120
1121 G4int npvp = pPVModel->GetDrawnPVPath().size();
1122 G4cout << " physical volume node id : "
1123 << "size: " << npvp << ", PV name: ";
1124 for(G4int i = 0; i < npvp; i++) {
1125 G4cout << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetName()
1126 << " [param:"
1127 << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->IsParameterised()
1128 << ",rep:"
1129 << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->IsReplicated();
1130 if(pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetParameterisation()) {
1131 G4cout << ",nest:"
1132 << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetParameterisation()->IsNested();
1133 }
1134 G4cout << ",copyno:"
1135 << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetCopyNo();
1136 G4cout << "] - ";
1137 }
1138 G4cout << G4endl;
1139
1140
1141 pPVModel->GetCurrentPV()->GetReplicationData(axis, nReplicas, width, offset, consuming);
1142 G4cout << " # replicas : " << nReplicas << G4endl;
1143 G4double pareDims[3] = {0.,0.,0.};
1144 G4Box * pbox = dynamic_cast<G4Box *>(pPVModel->GetDrawnPVPath()[npvp-2].GetPhysicalVolume()->GetLogicalVolume()->GetSolid());
1145 if(pbox) {
1146 pareDims[0] = 2.*pbox->GetXHalfLength()*mm;
1147 pareDims[1] = 2.*pbox->GetYHalfLength()*mm;
1148 pareDims[2] = 2.*pbox->GetZHalfLength()*mm;
1149 G4cout << " mother size ["
1150 << pPVModel->GetDrawnPVPath()[npvp-2].GetPhysicalVolume()->GetName()
1151 << "] : "
1152 << pareDims[0] << " x "
1153 << pareDims[1] << " x "
1154 << pareDims[2] << " [mm3]"
1155 << G4endl;
1156 }
1157 G4double paraDims[3];
1158 G4Box * boxP = dynamic_cast<G4Box *>(pPVModel->GetDrawnPVPath()[npvp-1].GetPhysicalVolume()->GetLogicalVolume()->GetSolid());
1159 if(boxP) {
1160 paraDims[0] = 2.*boxP->GetXHalfLength()*mm;
1161 paraDims[1] = 2.*boxP->GetYHalfLength()*mm;
1162 paraDims[2] = 2.*boxP->GetZHalfLength()*mm;
1163 G4cout << " parameterised volume? ["
1164 << pPVModel->GetDrawnPVPath()[npvp-1].GetPhysicalVolume()->GetName()
1165 << "] : "
1166 << paraDims[0] << " x "
1167 << paraDims[1] << " x "
1168 << paraDims[2] << " [mm3] : "
1169 << G4int(pareDims[0]/paraDims[0]) << " x "
1170 << G4int(pareDims[1]/paraDims[1]) << " x "
1171 << G4int(pareDims[2]/paraDims[2]) << G4endl;
1172 } else {
1173 G4cout << pPVModel->GetDrawnPVPath()[npvp-2].GetPhysicalVolume()->GetName()
1174 << " isn't a G4Box." << G4endl;
1175 }
1176 }
1177 }
1178
1179
1180 } else if(kFlagParameterization == 1) { // G4PhantomParameterisation based geom. construnction
1181
1182 // get the dimension of the parameterized patient geometry
1183 G4PhantomParameterisation * phantomPara
1184 = dynamic_cast<G4PhantomParameterisation*>(pv[0]->GetParameterisation());
1185 if(phantomPara == NULL) {
1186 G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
1187 "gMocren0012", FatalException, "no G4PhantomParameterisation");
1188 } else {
1189 ;
1190 }
1191
1192 kNestedVolumeDimension[0] = phantomPara->GetNoVoxelX();
1193 kNestedVolumeDimension[1] = phantomPara->GetNoVoxelY();
1194 kNestedVolumeDimension[2] = phantomPara->GetNoVoxelZ();
1195 kNestedVolumeDirAxis[0] = 0;
1196 kNestedVolumeDirAxis[1] = 1;
1197 kNestedVolumeDirAxis[2] = 2;
1198
1199 // get densities of the parameterized patient geometry
1200 G4int nX = kNestedVolumeDimension[0];
1201 G4int nXY = kNestedVolumeDimension[0]*kNestedVolumeDimension[1];
1202
1203 for(G4int n0 = 0; n0 < kNestedVolumeDimension[0]; n0++) {
1204 for(G4int n1 = 0; n1 < kNestedVolumeDimension[1]; n1++) {
1205 for(G4int n2 = 0; n2 < kNestedVolumeDimension[2]; n2++) {
1206
1207 G4int repNo = n0 + n1*nX + n2*nXY;
1208 G4Material * mat = phantomPara->ComputeMaterial(repNo, pv[0]);
1209 G4double dens = mat->GetDensity()/(g/cm3);
1210
1211
1212 G4int idx[3];
1213 idx[kNestedVolumeDirAxis[0]] = n0;
1214 idx[kNestedVolumeDirAxis[1]] = n1;
1215 idx[kNestedVolumeDirAxis[2]] = n2;
1216 Index3D i3d(idx[0],idx[1],idx[2]);
1217 kNestedModality[i3d] = dens;
1218
1219 if(GFDEBUG_DET)
1220 G4cout << " index: " << idx[0] << ", " << idx[1] << ", " << idx[2]
1221 << " density: " << dens << G4endl;
1222
1223 }
1224 }
1225 }
1226
1227 kVolumeSize.set(box.GetXHalfLength()*2/mm,
1228 box.GetYHalfLength()*2/mm,
1229 box.GetZHalfLength()*2/mm);
1230
1231 // mesh size
1232 if(!kbSetModalityVoxelSize) {
1233 G4float spacing[3] = {static_cast<G4float>(2*phantomPara->GetVoxelHalfX()),
1234 static_cast<G4float>(2*phantomPara->GetVoxelHalfY()),
1235 static_cast<G4float>(2*phantomPara->GetVoxelHalfZ())};
1236 kgMocrenIO->setVoxelSpacing(spacing);
1237 kVoxelDimension.set(spacing[0], spacing[1], spacing[2]);
1238 kbSetModalityVoxelSize = true;
1239 }
1240 }
1241
1242 } // if(box.GetName() == volName)
1243
1244
1245 // processing geometry construction based on the interactive PS
1246 if(!kFLagProcessedInteractiveScorer) {
1247
1248
1249 // get the dimension of the geometry defined in G4VScoringMesh
1250 G4ScoringManager * pScrMan = G4ScoringManager::GetScoringManager();
1251 if(!pScrMan) return;
1252 G4ScoringBox * scoringBox
1253 = dynamic_cast<G4ScoringBox*>(pScrMan->FindMesh(volName));
1254 if(scoringBox == NULL) return;
1255
1256
1257 G4int nVoxels[3];
1258 scoringBox->GetNumberOfSegments(nVoxels);
1259 // this order depends on the G4ScoringBox
1260 kNestedVolumeDimension[0] = nVoxels[2];
1261 kNestedVolumeDimension[1] = nVoxels[1];
1262 kNestedVolumeDimension[2] = nVoxels[0];
1263 kNestedVolumeDirAxis[0] = 2;
1264 kNestedVolumeDirAxis[1] = 1;
1265 kNestedVolumeDirAxis[2] = 0;
1266
1267 // get densities of the parameterized patient geometry
1268 for(G4int n0 = 0; n0 < kNestedVolumeDimension[0]; n0++) {
1269 for(G4int n1 = 0; n1 < kNestedVolumeDimension[1]; n1++) {
1270 for(G4int n2 = 0; n2 < kNestedVolumeDimension[2]; n2++) {
1271
1272 G4double dens = 0.*(g/cm3);
1273
1274 G4int idx[3];
1275 idx[kNestedVolumeDirAxis[0]] = n0;
1276 idx[kNestedVolumeDirAxis[1]] = n1;
1277 idx[kNestedVolumeDirAxis[2]] = n2;
1278 Index3D i3d(idx[0],idx[1],idx[2]);
1279 kNestedModality[i3d] = dens;
1280
1281 }
1282 }
1283 }
1284
1285 G4ThreeVector boxSize = scoringBox->GetSize();
1286 if(GFDEBUG_DET > 1) {
1287 G4cout << "Interactive Scorer : size - "
1288 << boxSize.x()/cm << " x "
1289 << boxSize.y()/cm << " x "
1290 << boxSize.z()/cm << " [cm3]" << G4endl;
1291 G4cout << "Interactive Scorer : # voxels - "
1292 << nVoxels[0] << " x "
1293 << nVoxels[1] << " x "
1294 << nVoxels[2] << G4endl;
1295 }
1296 kVolumeSize.set(boxSize.x()*2,
1297 boxSize.y()*2,
1298 boxSize.z()*2);
1299
1300 // mesh size
1301 if(!kbSetModalityVoxelSize) {
1302 G4float spacing[3] = {static_cast<G4float>(boxSize.x()*2/nVoxels[0]),
1303 static_cast<G4float>(boxSize.y()*2/nVoxels[1]),
1304 static_cast<G4float>(boxSize.z()*2/nVoxels[2])};
1305
1306 kgMocrenIO->setVoxelSpacing(spacing);
1307 kVoxelDimension.set(spacing[0], spacing[1], spacing[2]);
1308 kbSetModalityVoxelSize = true;
1309
1310 }
1311
1312
1313 kVolumeTrans3D = fObjectTransformation;
1314
1315 // translation for the scoring mesh
1316 G4ThreeVector sbth = scoringBox->GetTranslation();
1317 G4Translate3D sbtranslate(sbth);
1318 kVolumeTrans3D = kVolumeTrans3D*sbtranslate;
1319
1320 // rotation matrix for the scoring mesh
1321 G4RotationMatrix sbrm;
1322 sbrm = scoringBox->GetRotationMatrix();
1323 if(!sbrm.isIdentity()) {
1324 G4ThreeVector sbdummy(0.,0.,0.);
1325 G4Transform3D sbrotate(sbrm.inverse(), sbdummy);
1326 kVolumeTrans3D = kVolumeTrans3D*sbrotate;
1327 }
1328
1329
1330 // coordination system correction for gMocren
1331 G4ThreeVector raxisY(0., 1., 0.), dummyY(0.,0.,0.);
1332 G4RotationMatrix rotY(raxisY, pi*rad);
1333 G4Transform3D trotY(rotY, dummyY);
1334 G4ThreeVector raxisZ(0., 0., 1.), dummyZ(0.,0.,0.);
1335 G4RotationMatrix rotZ(raxisZ, pi*rad);
1336 G4Transform3D trotZ(rotZ, dummyZ);
1337
1338 kVolumeTrans3D = kVolumeTrans3D*trotY*trotZ;
1339
1340
1341 //
1342 kFLagProcessedInteractiveScorer = true;
1343 }
1344
1345
1346
1347 //-- add detectors
1348 G4bool bAddDet = true;
1349 if(!kMessenger.getDrawVolumeGrid()) {
1350
1351 if(kFlagParameterization == 0) { // nested parameterisation
1352
1353 if(volName == box.GetName()) {
1354 bAddDet = false;
1355 }
1356
1357 std::vector<G4String>::iterator itr = kNestedVolumeNames.begin();
1358 for(; itr != kNestedVolumeNames.end(); itr++) {
1359 if(*itr == box.GetName()) {
1360 bAddDet = false;
1361 break;
1362 }
1363 }
1364 } else if(kFlagParameterization == 1) { // phantom paramemterisation
1365
1366 if(volName != box.GetName()) {
1367 bAddDet = false;
1368 }
1369
1370 } else if(kFlagParameterization == 2) { // interactive primitive scorer
1371 ;
1372 }
1373
1374 }
1375 if(bAddDet) AddDetector(box);
1376
1377
1378} // void G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )
1379
1380
1381//----- Add tubes
1382void
1383G4GMocrenFileSceneHandler::AddSolid( const G4Tubs& tubes )
1384{
1385 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1386 G4cout << "***** AddSolid ( tubes )" << G4endl;
1387
1388 //----- skip drawing invisible primitive
1389 if( !IsVisible() ) { return ; }
1390
1391 //----- Initialize if necessary
1392 GFBeginModeling();
1393
1394 //
1395 AddDetector(tubes);
1396
1397
1398 // for a debug
1399 if(GFDEBUG_DET > 0) {
1400 G4cout << "-------" << G4endl;
1401 G4cout << " " << tubes.GetName() << G4endl;
1402 G4Polyhedron * poly = tubes.CreatePolyhedron();
1403 G4int nv = poly->GetNoVertices();
1404 for(G4int i = 0; i < nv; i++) {
1405 G4cout << " (" << poly->GetVertex(i).x() << ", "
1406 << poly->GetVertex(i).y() << ", "
1407 << poly->GetVertex(i).z() << ")" << G4endl;
1408 }
1409 delete poly;
1410 }
1411
1412 const G4VModel* pv_model = GetModel();
1413 if (!pv_model) { return ; }
1414 G4PhysicalVolumeModel* pPVModel =
1415 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
1416 if (!pPVModel) { return ; }
1417 G4Material * mat = pPVModel->GetCurrentMaterial();
1418 G4String name = mat->GetName();
1419
1420} // void G4GMocrenFileSceneHandler::AddSolid( const G4Tubs& )
1421
1422
1423
1424//----- Add cons
1425void
1426G4GMocrenFileSceneHandler::AddSolid( const G4Cons& cons )
1427{
1428 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1429 G4cout << "***** AddSolid ( cons )" << G4endl;
1430
1431 //----- skip drawing invisible primitive
1432 if( !IsVisible() ) { return ; }
1433
1434 //----- Initialize if necessary
1435 GFBeginModeling();
1436
1437 //
1438 AddDetector(cons);
1439
1440}// G4GMocrenFileSceneHandler::AddSolid( cons )
1441
1442
1443//----- Add trd
1444void G4GMocrenFileSceneHandler::AddSolid ( const G4Trd& trd )
1445{
1446 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1447 G4cout << "***** AddSolid ( trd )" << G4endl;
1448
1449
1450 //----- skip drawing invisible primitive
1451 if( !IsVisible() ) { return ; }
1452
1453 //----- Initialize if necessary
1454 GFBeginModeling();
1455
1456 //
1457 AddDetector(trd);
1458
1459} // G4GMocrenFileSceneHandler::AddSolid ( trd )
1460
1461
1462//----- Add sphere
1463void G4GMocrenFileSceneHandler::AddSolid ( const G4Sphere& sphere )
1464{
1465 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1466 G4cout << "***** AddSolid ( sphere )" << G4endl;
1467
1468 //----- skip drawing invisible primitive
1469 if( !IsVisible() ) { return ; }
1470
1471 //----- Initialize if necessary
1472 GFBeginModeling();
1473
1474 //
1475 AddDetector(sphere);
1476
1477} // G4GMocrenFileSceneHandler::AddSolid ( sphere )
1478
1479
1480//----- Add para
1481void G4GMocrenFileSceneHandler::AddSolid (const G4Para& para)
1482{
1483 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1484 G4cout << "***** AddSolid ( para )" << G4endl;
1485
1486 //----- skip drawing invisible primitive
1487 if( !IsVisible() ) { return ; }
1488
1489 //----- Initialize if necessary
1490 GFBeginModeling();
1491
1492 //
1493 AddDetector(para);
1494
1495} // G4GMocrenFileSceneHandler::AddSolid ( para )
1496
1497
1498//----- Add trap
1499void G4GMocrenFileSceneHandler::AddSolid (const G4Trap& trap)
1500{
1501 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1502 G4cout << "***** AddSolid ( trap )" << G4endl;
1503
1504 //----- skip drawing invisible primitive
1505 if( !IsVisible() ) { return ; }
1506
1507 //----- Initialize if necessary
1508 GFBeginModeling();
1509
1510 //
1511 AddDetector(trap);
1512
1513} // G4GMocrenFileSceneHandler::AddSolid (const G4Trap& trap)
1514
1515
1516//----- Add torus
1517void
1518G4GMocrenFileSceneHandler::AddSolid( const G4Torus& torus )
1519{
1520 if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
1521 G4cout << "***** AddSolid ( torus )" << G4endl;
1522
1523 //----- skip drawing invisible primitive
1524 if( !IsVisible() ) { return ; }
1525
1526 //----- Initialize if necessary
1527 GFBeginModeling();
1528
1529 //
1530 AddDetector(torus);
1531
1532} // void G4GMocrenFileSceneHandler::AddSolid( const G4Torus& )
1533
1534
1535
1536//----- Add a shape which is not treated above
1537void G4GMocrenFileSceneHandler::AddSolid ( const G4VSolid& solid )
1538{
1539 //----- skip drawing invisible primitive
1540 if( !IsVisible() ) { return ; }
1541
1542 //----- Initialize if necessary
1543 GFBeginModeling();
1544
1545 //
1546 AddDetector(solid);
1547
1548 //----- Send a primitive
1549 G4VSceneHandler::AddSolid( solid ) ;
1550
1551} //G4GMocrenFileSceneHandler::AddSolid ( const G4VSolid& )
1552
1553#include "G4TrajectoriesModel.hh"
1554#include "G4VTrajectory.hh"
1555#include "G4VTrajectoryPoint.hh"
1556
1557//----- Add a trajectory
1558void G4GMocrenFileSceneHandler::AddCompound(const G4VTrajectory & traj) {
1559
1560 kbModelingTrajectory = true;
1561
1562 G4VSceneHandler::AddCompound(traj);
1563
1564 if(GFDEBUG_TRK) {
1565 G4cout << " ::AddCompound(const G4VTrajectory&) >>>>>>>>> " << G4endl;
1566 G4TrajectoriesModel * pTrModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
1567 if (!pTrModel) {
1568 G4Exception
1569 ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
1570 "gMocren0013", FatalException, "Not a G4TrajectoriesModel.");
1571 } else {
1572 traj.DrawTrajectory(pTrModel->GetDrawingMode());
1573
1574 const G4VTrajectory * trj = pTrModel->GetCurrentTrajectory();
1575 G4cout << "------ track" << G4endl;
1576 G4cout << " name: " << trj->GetParticleName() << G4endl;
1577 G4cout << " id: " << trj->GetTrackID() << G4endl;
1578 G4cout << " charge: " << trj->GetCharge() << G4endl;
1579 G4cout << " momentum: " << trj->GetInitialMomentum() << G4endl;
1580
1581 G4int nPnt = trj->GetPointEntries();
1582 G4cout << " point: ";
1583 for(G4int i = 0; i < nPnt; i++) {
1584 G4cout << trj->GetPoint(i)->GetPosition() << ", ";
1585 }
1586 G4cout << G4endl;
1587 }
1588 G4cout << G4endl;
1589 }
1590
1591 kbModelingTrajectory = false;
1592}
1593
1594#include <vector>
1595#include "G4VHit.hh"
1596#include "G4AttValue.hh"
1597//----- Add a hit
1598void G4GMocrenFileSceneHandler::AddCompound( const G4VHit & hit) {
1599 if(GFDEBUG_HIT) G4cout << " ::AddCompound(const G4VHit&) >>>>>>>>> " << G4endl;
1600
1601 G4VSceneHandler::AddCompound(hit);
1602
1603 /*
1604 const std::map<G4String, G4AttDef> * map = hit.GetAttDefs();
1605 if(!map) return;
1606 std::map<G4String, G4AttDef>::const_iterator itr = map->begin();
1607 for(; itr != map->end(); itr++) {
1608 G4cout << itr->first << " : " << itr->second.GetName()
1609 << " , " << itr->second.GetDesc() << G4endl;
1610 }
1611 */
1612
1613 std::vector<G4String> hitNames = kMessenger.getHitNames();
1614 if(GFDEBUG_HIT) {
1615 std::vector<G4String>::iterator itr = hitNames.begin();
1616 for(; itr != hitNames.end(); itr++)
1617 G4cout << " hit name : " << *itr << G4endl;
1618 }
1619
1620 std::vector<G4AttValue> * attval = hit.CreateAttValues();
1621 if(!attval) {G4cout << "0 empty " << (unsigned long)attval << G4endl;}
1622 else {
1623
1624 G4bool bid[3] = {false, false, false};
1625 Index3D id;
1626
1627 std::vector<G4AttValue>::iterator itr;
1628 // First, get IDs
1629 for(itr = attval->begin(); itr != attval->end(); itr++) {
1630 std::string stmp = itr->GetValue();
1631 std::istringstream sval(stmp.c_str());
1632
1633 if(itr->GetName() == G4String("XID")) {
1634 sval >> id.x;
1635 bid[0] = true;
1636 continue;
1637 }
1638 if(itr->GetName() == G4String("YID")) {
1639 sval >> id.y;
1640 bid[1] = true;
1641 continue;
1642 }
1643 if(itr->GetName() == G4String("ZID")) {
1644 sval >> id.z;
1645 bid[2] = true;
1646 continue;
1647 }
1648 }
1649
1650 G4int nhitname = (G4int)hitNames.size();
1651
1652 if(bid[0] && bid[1] && bid[2]) {
1653
1654 if(GFDEBUG_HIT)
1655 G4cout << " Hit : index(" << id.x << ", " << id.y << ", "
1656 << id.z << ")" << G4endl;
1657
1658 // Get attributes
1659 for(itr = attval->begin(); itr != attval->end(); itr++) {
1660 for(G4int i = 0; i < nhitname; i++) {
1661 if(itr->GetName() == hitNames[i]) {
1662
1663 std::string stmp = itr->GetValue();
1664 std::istringstream sval(stmp.c_str());
1665 G4double value;
1666 G4String unit;
1667 sval >> value >> unit;
1668
1669 std::map<G4String, std::map<Index3D, G4double> >::iterator kNestedHitsListItr;
1670 kNestedHitsListItr = kNestedHitsList.find(hitNames[i]);
1671 if(kNestedHitsListItr != kNestedHitsList.end()) {
1672 //fTempNestedHits = &kNestedHitsListItr->second;
1673 //(*fTempNestedHits)[id] = value;
1674 kNestedHitsListItr->second[id] = value;
1675 } else {
1676 std::map<Index3D, G4double> hits;
1677 hits.insert(std::map<Index3D, G4double>::value_type(id, value));
1678 kNestedHitsList[hitNames[i]] = hits;
1679 }
1680
1681
1682 if(GFDEBUG_HIT)
1683 G4cout << " : " << hitNames[i] << " -> " << value
1684 << " [" << unit << "]" << G4endl;
1685 }
1686 }
1687 }
1688 } else {
1689 G4Exception("G4GMocrenFileSceneHandler::AddCompound(const G4VHit &)",
1690 "gMocren0014", FatalException, "Error");
1691 }
1692
1693 delete attval;
1694 }
1695
1696}
1697
1698void G4GMocrenFileSceneHandler::AddCompound( const G4VDigi & digi) {
1699 if(GFDEBUG_DIGI) G4cout << " ::AddCompound(const G4VDigi&) >>>>>>>>> " << G4endl;
1700 G4VSceneHandler::AddCompound(digi);
1701}
1702
1703void G4GMocrenFileSceneHandler::AddCompound(const G4THitsMap<G4double> & hits) {
1704 if(GFDEBUG_HIT)
1705 G4cout << " ::AddCompound(const std::map<G4int, G4double*> &) >>>>>>>>> " << G4endl;
1706
1707
1708 std::vector<G4String> hitScorerNames = kMessenger.getHitScorerNames();
1709 G4int nhitname = (G4int)hitScorerNames.size();
1710 G4String scorername = static_cast<G4VHitsCollection>(hits).GetName();
1711
1712 //-- --//
1713 /*
1714 std::vector<G4String> hitScorerNames = kMessenger.getHitScorerNames();
1715 if(GFDEBUG_HIT) {
1716 std::vector<G4String>::iterator itr = hitScorerNames.begin();
1717 for(; itr != hitScorerNames.end(); itr++)
1718 G4cout << " PS name : " << *itr << G4endl;
1719 }
1720 */
1721
1722 { // Scope bracket to avoid compiler messages about shadowing (JA).
1723 //for(G4int i = 0; i < nhitname; i++) { // this selection trusts
1724 //if(scorername == hitScorerNames[i]) { // thea command /vis/scene/add/psHits hit_name.
1725
1726 G4int idx[3];
1727 std::map<G4int, G4double*> * map = hits.GetMap();
1728 std::map<G4int, G4double*>::const_iterator itr = map->begin();
1729 for(; itr != map->end(); itr++) {
1730 GetNestedVolumeIndex(itr->first, idx);
1731 Index3D id(idx[0], idx[1], idx[2]);
1732
1733 std::map<G4String, std::map<Index3D, G4double> >::iterator nestedHitsListItr;
1734 nestedHitsListItr = kNestedHitsList.find(scorername);
1735 if(nestedHitsListItr != kNestedHitsList.end()) {
1736 nestedHitsListItr->second[id] = *itr->second;
1737 } else {
1738 std::map<Index3D, G4double> hit;
1739 hit.insert(std::map<Index3D, G4double>::value_type(id, *itr->second));
1740 kNestedHitsList[scorername] = hit;
1741 }
1742 }
1743
1744 //break;
1745 //}
1746 //}
1747 }
1748
1749 if(GFDEBUG_HIT) {
1750 G4String meshname = static_cast<G4VHitsCollection>(hits).GetSDname();
1751 G4cout << " >>>>> " << meshname << " : " << scorername << G4endl;
1752
1753 for(G4int i = 0; i < nhitname; i++)
1754 if(scorername == hitScorerNames[i])
1755 G4cout << " !!!! Hit scorer !!!! " << scorername << G4endl;
1756
1757 G4cout << " dimension: "
1758 << kNestedVolumeDimension[0] << " x "
1759 << kNestedVolumeDimension[1] << " x "
1760 << kNestedVolumeDimension[2] << G4endl;
1761
1762 G4int id[3];
1763 std::map<G4int, G4double*> * map = hits.GetMap();
1764 std::map<G4int, G4double*>::const_iterator itr = map->begin();
1765 for(; itr != map->end(); itr++) {
1766 GetNestedVolumeIndex(itr->first, id);
1767 G4cout << "[" << itr->first << "] "
1768 << "("<< id[0] << "," << id[1] << "," << id[2] << ")"
1769 << *itr->second << ", ";
1770 }
1771 G4cout << G4endl;
1772 }
1773
1774}
1775
1776//-----
1777G4bool G4GMocrenFileSceneHandler::IsVisible()
1778{
1779 //-----
1780 G4bool visibility = true ;
1781
1782 const G4VisAttributes* pVisAttribs =
1783 fpViewer->GetApplicableVisAttributes( fpVisAttribs );
1784
1785 if(pVisAttribs) {
1786 visibility = pVisAttribs->IsVisible();
1787 }
1788
1789 return visibility ;
1790
1791} // G4GMocrenFileSceneHandler::IsVisible()
1792
1793
1794//-----
1795void G4GMocrenFileSceneHandler::ClearTransientStore()
1796{
1797 // This is typically called after an update and before drawing hits
1798 // of the next event. To simulate the clearing of "transients"
1799 // (hits, etc.) the detector is redrawn...
1800 if (fpViewer) {
1801 fpViewer -> SetView ();
1802 fpViewer -> ClearView ();
1803 fpViewer -> DrawView ();
1804 }
1805}
1806
1807//-----
1808void G4GMocrenFileSceneHandler::AddDetector(const G4VSolid & solid) {
1809
1810 Detector detector;
1811
1812 // detector name
1813 detector.name = solid.GetName();
1814 if(GFDEBUG_DET > 1)
1815 G4cout << "0 Detector name : " << detector.name << G4endl;
1816
1817 const G4VModel* pv_model = GetModel();
1818 if (!pv_model) { return ; }
1819 G4PhysicalVolumeModel* pPVModel =
1820 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
1821 if (!pPVModel) { return ; }
1822
1823 // edge points of the detector
1824 std::vector<G4float *> dedges;
1825 G4Polyhedron * poly = solid.CreatePolyhedron();
1826 detector.polyhedron = poly;
1827 detector.transform3D = fObjectTransformation;
1828
1829 // retrieve color
1830 unsigned char uccolor[3] = {30, 30, 30};
1831 if(pPVModel->GetCurrentLV()->GetVisAttributes()) {
1832 G4Color color = pPVModel->GetCurrentLV()->GetVisAttributes()->GetColor();
1833 uccolor[0] = (unsigned char)(color.GetRed()*255);
1834 uccolor[1] = (unsigned char)(color.GetGreen()*255);
1835 uccolor[2] = (unsigned char)(color.GetBlue()*255);
1836 //if(uccolor[0] < 2 && uccolor[1] < 2 && uccolor[2] < 2)
1837 //uccolor[0] = uccolor[1] = uccolor[2] = 30; // dark grey
1838 }
1839 for(G4int i = 0; i < 3; i++) detector.color[i] = uccolor[i];
1840 //
1841 kDetectors.push_back(detector);
1842
1843 if(GFDEBUG_DET > 1) {
1844 G4cout << "0 color: (" << (G4int)uccolor[0] << ", "
1845 << (G4int)uccolor[1] << ", " << (G4int)uccolor[2] << ")"
1846 << G4endl;
1847 }
1848
1849}
1850
1851//-----
1852void G4GMocrenFileSceneHandler::ExtractDetector() {
1853
1854 std::vector<Detector>::iterator itr = kDetectors.begin();
1855
1856 for(; itr != kDetectors.end(); itr++) {
1857
1858 // detector name
1859 G4String detname = itr->name;
1860 if(GFDEBUG_DET > 1)
1861 G4cout << "Detector name : " << detname << G4endl;
1862
1863 // edge points of the detector
1864 std::vector<G4float *> dedges;
1865 G4Polyhedron * poly = itr->polyhedron;
1866 poly->Transform(itr->transform3D);
1867 G4Transform3D invVolTrans = kVolumeTrans3D.inverse();
1868 poly->Transform(invVolTrans);
1869
1870 G4Point3D v1, v2;
1871 G4bool bnext = true;
1872 G4int next;
1873 G4int nedges = 0;
1874 //
1875 while(bnext) {
1876 if(!(poly->GetNextEdge(v1, v2, next))) bnext =false;
1877 G4float * edge = new G4float[6];
1878 edge[0] = v1.x()/mm;
1879 edge[1] = v1.y()/mm;
1880 edge[2] = v1.z()/mm;
1881 edge[3] = v2.x()/mm;
1882 edge[4] = v2.y()/mm;
1883 edge[5] = v2.z()/mm;
1884 dedges.push_back(edge);
1885 nedges++;
1886 }
1887 //delete poly;
1888 // detector color
1889 unsigned char uccolor[3] = {itr->color[0],
1890 itr->color[1],
1891 itr->color[2]};
1892 //
1893 kgMocrenIO->addDetector(detname, dedges, uccolor);
1894 for(G4int i = 0; i < nedges; i++) { // # of edges is 12.
1895 delete [] dedges[i];
1896 }
1897 dedges.clear();
1898
1899 if(GFDEBUG_DET > 1) {
1900 G4cout << " color: (" << (G4int)uccolor[0] << ", "
1901 << (G4int)uccolor[1] << ", " << (G4int)uccolor[2] << ")"
1902 << G4endl;
1903 }
1904 }
1905}
1906
1907void G4GMocrenFileSceneHandler::GetNestedVolumeIndex(G4int _idx, G4int _idx3d[3]) {
1908 if(kNestedVolumeDimension[0] == 0 ||
1909 kNestedVolumeDimension[1] == 0 ||
1910 kNestedVolumeDimension[2] == 0) {
1911 for(G4int i = 0; i < 3; i++) _idx3d[i] = 0;
1912 return;
1913 }
1914
1915
1916 if(kFlagParameterization == 0) {
1917
1918 G4int plane = kNestedVolumeDimension[2]*kNestedVolumeDimension[1];
1919 G4int line = kNestedVolumeDimension[2];
1920
1921 /*
1922 G4int idx3d[3];
1923 idx3d[0] = _idx/plane;
1924 idx3d[1] = (_idx%plane)/line;
1925 idx3d[2] = (_idx%plane)%line;
1926 _idx3d[0] = idx3d[kNestedVolumeDirAxis[0]];
1927 _idx3d[1] = idx3d[kNestedVolumeDirAxis[1]];
1928 _idx3d[2] = idx3d[kNestedVolumeDirAxis[2]];
1929 */
1930
1931 _idx3d[kNestedVolumeDirAxis[0]] = _idx/plane;
1932 _idx3d[kNestedVolumeDirAxis[1]] = (_idx%plane)/line;
1933 _idx3d[kNestedVolumeDirAxis[2]] = (_idx%plane)%line;
1934
1935
1936
1937 /*
1938
1939 G4cout << "G4GMocrenFileSceneHandler::GetNestedVolumeIndex : " << G4endl;
1940 G4cout << "(depi, depj, depk) : "
1941 << kNestedVolumeDirAxis[0] << ", "
1942 << kNestedVolumeDirAxis[1] << ", "
1943 << kNestedVolumeDirAxis[2] << G4endl;
1944 G4cout << "(ni, nj, nk) :"
1945 << kNestedVolumeDimension[0] << ", "
1946 << kNestedVolumeDimension[1] << ", "
1947 << kNestedVolumeDimension[2] << " - " << G4endl;
1948
1949 G4cout << " _idx = " << _idx << " : plane = "
1950 << plane << " , line = " << line << G4endl;
1951 G4cout << "(idx,idy,idz) + " << _idx3d[0] << ", "
1952 << _idx3d[1] << ", " << _idx3d[2] << " + " << G4endl;
1953
1954 */
1955
1956
1957
1958 } else {
1959
1960 G4int plane = kNestedVolumeDimension[0]*kNestedVolumeDimension[1];
1961 G4int line = kNestedVolumeDimension[0];
1962 _idx3d[kNestedVolumeDirAxis[2]] = _idx/plane;
1963 _idx3d[kNestedVolumeDirAxis[1]] = (_idx%plane)/line;
1964 _idx3d[kNestedVolumeDirAxis[0]] = (_idx%plane)%line;
1965
1966 }
1967
1968}
1969
1970
1971//-- --//
1972G4GMocrenFileSceneHandler::Detector::Detector()
1973 : polyhedron(0) {
1974 color[0] = color[1] = color[2] = 255;
1975}
1976G4GMocrenFileSceneHandler::Detector::~Detector() {
1977 if(!polyhedron) delete polyhedron;
1978}
1979void G4GMocrenFileSceneHandler::Detector::clear() {
1980 name.clear();
1981 if(!polyhedron) delete polyhedron;
1982 color[0] = color[1] = color[2] = 255;
1983 transform3D = G4Transform3D::Identity;
1984}
1985
1986//-- --//
1987G4GMocrenFileSceneHandler::Index3D::Index3D()
1988 : x(0), y(0), z(0) {
1989 ;
1990}
1991
1992G4GMocrenFileSceneHandler::Index3D::Index3D(const Index3D & _index3D)
1993 : x(_index3D.x), y(_index3D.y), z(_index3D.z) {
1994 //: x(_index3D.X()),
1995 //y(_index3D.Y()),
1996 //z(_index3D.Z()) {
1997 // : x(static_cast<Index3D>(_index3D).x),
1998 // y(static_cast<Index3D>(_index3D).y),
1999 // z(static_cast<Index3D>(_index3D).z) {
2000 ;
2001}
2002
2003G4GMocrenFileSceneHandler::Index3D::Index3D(G4int _x, G4int _y, G4int _z)
2004 : x(_x), y(_y), z(_z) {
2005 ;
2006}
2007G4bool G4GMocrenFileSceneHandler::Index3D::operator < (const Index3D & _right) const {
2008 if(z < static_cast<Index3D>(_right).z) {
2009 return true;
2010 } else if(z == _right.z) {
2011 if(y < static_cast<Index3D>(_right).y) return true;
2012 else if(y == _right.y)
2013 if(x < static_cast<Index3D>(_right).x) return true;
2014 }
2015 return false;
2016}
2017G4bool G4GMocrenFileSceneHandler::Index3D::operator == (const Index3D & _right) const {
2018 if(z == _right.z && y == _right.y && x == _right.x) return true;
2019 return false;
2020}
FR_MAX_FILE_NUM
const int FR_MAX_FILE_NUM
Definition: G4DAWNFILESceneHandler.cc:76
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:64
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
GFDEBUG
const G4bool GFDEBUG
Definition: G4GMocrenFileSceneHandler.cc:99
GFDEBUG_TRK
const G4bool GFDEBUG_TRK
Definition: G4GMocrenFileSceneHandler.cc:100
GFDEBUG_DIGI
const G4bool GFDEBUG_DIGI
Definition: G4GMocrenFileSceneHandler.cc:102
GFDEBUG_HIT
const G4bool GFDEBUG_HIT
Definition: G4GMocrenFileSceneHandler.cc:101
FR_MAX_FILE_NUM
const G4int FR_MAX_FILE_NUM
Definition: G4GMocrenFileSceneHandler.cc:95
GFDEBUG_DET
const G4int GFDEBUG_DET
Definition: G4GMocrenFileSceneHandler.cc:103
GDD_FILE_HEADER
const char GDD_FILE_HEADER[]
Definition: G4GMocrenFileSceneHandler.cc:92
DEFAULT_GDD_FILE_NAME
const char DEFAULT_GDD_FILE_NAME[]
Definition: G4GMocrenFileSceneHandler.cc:93
MAX_NUM_TRAJECTORIES
const G4int MAX_NUM_TRAJECTORIES
Definition: G4GMocrenFileSceneHandler.cc:96
G4double
double G4double
Definition: G4Types.hh:64
G4float
float G4float
Definition: G4Types.hh:65
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
CLHEP::Hep3Vector::transform
Hep3Vector & transform(const HepRotation &)
Definition: ThreeVectorR.cc:24
CLHEP::Hep3Vector::set
void set(double x, double y, double z)
CLHEP::HepRotation::inverse
HepRotation inverse() const
CLHEP::HepRotation::isIdentity
bool isIdentity() const
Definition: Rotation.cc:172
G4Box
Definition: G4Box.hh:55
G4Box::GetYHalfLength
G4double GetYHalfLength() const
G4Box::GetZHalfLength
G4double GetZHalfLength() const
G4Box::GetXHalfLength
G4double GetXHalfLength() const
G4Box::CreatePolyhedron
G4Polyhedron * CreatePolyhedron() const
Definition: G4Box.cc:1052
G4Colour::GetBlue
G4double GetBlue() const
Definition: G4Colour.hh:140
G4Colour::GetRed
G4double GetRed() const
Definition: G4Colour.hh:138
G4Colour::GetGreen
G4double GetGreen() const
Definition: G4Colour.hh:139
G4Cons
Definition: G4Cons.hh:75
G4GMocrenFileCTtoDensityMap::GetDensity
G4double GetDensity(G4int &_ct) const
Definition: G4GMocrenFileCTtoDensityMap.cc:661
G4GMocrenFileSceneHandler::G4GMocrenFileSceneHandler
G4GMocrenFileSceneHandler(G4GMocrenFile &system, G4GMocrenMessenger &messenger, const G4String &name="")
Definition: G4GMocrenFileSceneHandler.cc:118
G4GMocrenFileSceneHandler::AddCompound
void AddCompound(const G4VTrajectory &traj)
Definition: G4GMocrenFileSceneHandler.cc:1558
G4GMocrenFileSceneHandler::BeginPrimitives
virtual void BeginPrimitives(const G4Transform3D &objectTransformation)
Definition: G4GMocrenFileSceneHandler.cc:810
G4GMocrenFileSceneHandler::AddPrimitive
void AddPrimitive(const G4Polyline &line)
Definition: G4GMocrenFileSceneHandler.cc:525
G4GMocrenIO::setModalityImageSize
void setModalityImageSize(int _size[3])
Definition: G4GMocrenIO.cc:3370
G4GMocrenIO::setDoseDistUnit
void setDoseDistUnit(std::string &_unit, int _num=0)
Definition: G4GMocrenIO.cc:3485
G4GMocrenIO::convertDensityToHU
short convertDensityToHU(float &_dens)
Definition: G4GMocrenIO.cc:3449
G4GMocrenIO::setDoseDistMinMax
void setDoseDistMinMax(short _minmax[2], int _num=0)
Definition: G4GMocrenIO.cc:3508
G4GMocrenIO::setDoseDistScale
void setDoseDistScale(double &_scale, int _num=0)
Definition: G4GMocrenIO.cc:3539
G4GMocrenIO::setModalityImageDensityMap
void setModalityImageDensityMap(std::vector< float > &_map)
Definition: G4GMocrenIO.cc:3399
G4GMocrenIO::translateDetector
void translateDetector(std::vector< float > &_translate)
Definition: G4GMocrenIO.cc:3996
G4GMocrenIO::clearDetector
void clearDetector()
Definition: G4GMocrenIO.hh:451
G4GMocrenIO::clearROIAll
void clearROIAll()
Definition: G4GMocrenIO.cc:3812
G4GMocrenIO::setVoxelSpacing
void setVoxelSpacing(float _spacing[3])
Definition: G4GMocrenIO.cc:3132
G4GMocrenIO::setDoseDistName
void setDoseDistName(std::string _name, int _num=0)
Definition: G4GMocrenIO.cc:3663
G4GMocrenIO::storeData
bool storeData(char *_filename)
Definition: G4GMocrenIO.cc:457
G4GMocrenIO::setModalityImage
void setModalityImage(short *_image)
Definition: G4GMocrenIO.cc:3386
G4GMocrenIO::setDoseDistSize
void setDoseDistSize(int _size[3], int _num=0)
Definition: G4GMocrenIO.cc:3501
G4GMocrenIO::setModalityImageMinMax
void setModalityImageMinMax(short _minmax[2])
Definition: G4GMocrenIO.cc:3406
G4GMocrenIO::newDoseDist
void newDoseDist()
Definition: G4GMocrenIO.cc:3470
G4GMocrenIO::clearDoseDistAll
void clearDoseDistAll()
Definition: G4GMocrenIO.cc:3706
G4GMocrenIO::clearTracks
void clearTracks()
Definition: G4GMocrenIO.hh:439
G4GMocrenIO::addDetector
void addDetector(std::string &_name, std::vector< float * > &_det, unsigned char _color[3])
Definition: G4GMocrenIO.cc:3947
G4GMocrenIO::setDoseDist
void setDoseDist(double *_image, int _num=0)
Definition: G4GMocrenIO.cc:3607
G4GMocrenIO::translateTracks
void translateTracks(std::vector< float > &_translateo)
Definition: G4GMocrenIO.cc:3933
G4GMocrenIO::addTrack
void addTrack(float *_tracks)
Definition: G4GMocrenIO.cc:3842
G4GMocrenMessenger::getHitNames
virtual std::vector< G4String > getHitNames()
Definition: G4GMocrenMessenger.cc:259
G4GMocrenMessenger::getHitScorerNames
virtual std::vector< G4String > getHitScorerNames()
Definition: G4GMocrenMessenger.cc:267
G4GMocrenMessenger::getDrawVolumeGrid
virtual G4bool getDrawVolumeGrid()
Definition: G4GMocrenMessenger.hh:66
G4GMocrenMessenger::getVolumeName
virtual G4String getVolumeName()
Definition: G4GMocrenMessenger.cc:255
G4LogicalVolume::GetSolid
G4VSolid * GetSolid() const
G4LogicalVolume::GetVisAttributes
const G4VisAttributes * GetVisAttributes() const
G4LogicalVolume::GetNoDaughters
G4int GetNoDaughters() const
G4LogicalVolume::GetDaughter
G4VPhysicalVolume * GetDaughter(const G4int i) const
G4Material::GetDensity
G4double GetDensity() const
Definition: G4Material.hh:179
G4Material::GetName
const G4String & GetName() const
Definition: G4Material.hh:177
G4Para
Definition: G4Para.hh:77
G4PhantomParameterisation::GetNoVoxelY
size_t GetNoVoxelY() const
G4PhantomParameterisation::GetVoxelHalfZ
G4double GetVoxelHalfZ() const
G4PhantomParameterisation::GetVoxelHalfY
G4double GetVoxelHalfY() const
G4PhantomParameterisation::ComputeMaterial
virtual G4Material * ComputeMaterial(const G4int repNo, G4VPhysicalVolume *currentVol, const G4VTouchable *parentTouch=0)
Definition: G4PhantomParameterisation.cc:129
G4PhantomParameterisation::GetVoxelHalfX
G4double GetVoxelHalfX() const
G4PhantomParameterisation::GetNoVoxelZ
size_t GetNoVoxelZ() const
G4PhantomParameterisation::GetNoVoxelX
size_t GetNoVoxelX() const
G4PhysicalVolumeModel::GetDrawnPVPath
const std::vector< G4PhysicalVolumeNodeID > & GetDrawnPVPath() const
Definition: G4PhysicalVolumeModel.hh:180
G4PhysicalVolumeModel::GetCurrentPV
G4VPhysicalVolume * GetCurrentPV() const
Definition: G4PhysicalVolumeModel.hh:164
G4PhysicalVolumeModel::GetCurrentLV
G4LogicalVolume * GetCurrentLV() const
Definition: G4PhysicalVolumeModel.hh:167
G4PhysicalVolumeModel::GetTopPhysicalVolume
G4VPhysicalVolume * GetTopPhysicalVolume() const
Definition: G4PhysicalVolumeModel.hh:154
G4PhysicalVolumeModel::GetCurrentMaterial
G4Material * GetCurrentMaterial() const
Definition: G4PhysicalVolumeModel.hh:170
G4Scene::GetEndOfEventModelList
const std::vector< Model > & GetEndOfEventModelList() const
G4ScoringManager::FindMesh
G4VScoringMesh * FindMesh(const G4String &)
Definition: G4ScoringManager.cc:94
G4ScoringManager::GetScoringManager
static G4ScoringManager * GetScoringManager()
Definition: G4ScoringManager.cc:43
G4THitsMap::GetMap
std::map< G4int, T * > * GetMap() const
Definition: G4THitsMap.hh:68
G4Text
Definition: G4Text.hh:73
G4TrajectoriesModel::GetCurrentTrajectory
const G4VTrajectory * GetCurrentTrajectory() const
Definition: G4TrajectoriesModel.hh:68
G4Trd
Definition: G4Trd.hh:63
G4Tubs
Definition: G4Tubs.hh:77
G4Tubs::CreatePolyhedron
G4Polyhedron * CreatePolyhedron() const
Definition: G4Tubs.cc:1923
G4VHit
Definition: G4VHit.hh:49
G4VHit::CreateAttValues
virtual std::vector< G4AttValue > * CreateAttValues() const
Definition: G4VHit.hh:67
G4VNestedParameterisation::ComputeDimensions
virtual void ComputeDimensions(G4Box &, const G4int, const G4VPhysicalVolume *) const
Definition: G4VNestedParameterisation.hh:111
G4VNestedParameterisation::ComputeTransformation
virtual void ComputeTransformation(const G4int no, G4VPhysicalVolume *currentPV) const =0
G4VNestedParameterisation::ComputeMaterial
virtual G4Material * ComputeMaterial(G4VPhysicalVolume *currentVol, const G4int repNo, const G4VTouchable *parentTouch=0)=0
G4VPVParameterisation::IsNested
virtual G4bool IsNested() const
Definition: G4VPVParameterisation.cc:62
G4VPhysicalVolume::IsReplicated
virtual G4bool IsReplicated() const =0
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VPhysicalVolume::GetMultiplicity
virtual G4int GetMultiplicity() const
Definition: G4VPhysicalVolume.cc:70
G4VPhysicalVolume::GetReplicationData
virtual void GetReplicationData(EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0
G4VPhysicalVolume::GetCopyNo
virtual G4int GetCopyNo() const =0
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VPhysicalVolume::GetParameterisation
virtual G4VPVParameterisation * GetParameterisation() const =0
G4VPhysicalVolume::GetObjectTranslation
G4ThreeVector GetObjectTranslation() const
G4VPhysicalVolume::IsParameterised
virtual G4bool IsParameterised() const =0
G4VSceneHandler::BeginModeling
virtual void BeginModeling()
Definition: G4VSceneHandler.cc:192
G4VSceneHandler::GetModel
G4VModel * GetModel() const
G4VSceneHandler::GetScene
G4Scene * GetScene() const
G4VSceneHandler::fObjectTransformation
G4Transform3D fObjectTransformation
Definition: G4VSceneHandler.hh:341
G4VSceneHandler::EndPrimitives
virtual void EndPrimitives()
Definition: G4VSceneHandler.cc:157
G4VSceneHandler::EndModeling
virtual void EndModeling()
Definition: G4VSceneHandler.cc:195
G4VSceneHandler::fpViewer
G4VViewer * fpViewer
Definition: G4VSceneHandler.hh:331
G4VSceneHandler::GetName
const G4String & GetName() const
G4VSceneHandler::BeginPrimitives
virtual void BeginPrimitives(const G4Transform3D &objectTransformation)
Definition: G4VSceneHandler.cc:145
G4VSceneHandler::fpVisAttribs
const G4VisAttributes * fpVisAttribs
Definition: G4VSceneHandler.hh:344
G4VSceneHandler::AddSolid
virtual void AddSolid(const G4Box &)
Definition: G4VSceneHandler.cc:204
G4VSceneHandler::AddCompound
virtual void AddCompound(const G4VTrajectory &)
Definition: G4VSceneHandler.cc:259
G4VScoringMesh::GetTranslation
G4ThreeVector GetTranslation() const
Definition: G4VScoringMesh.hh:100
G4VScoringMesh::GetSize
G4ThreeVector GetSize() const
Definition: G4VScoringMesh.cc:83
G4VScoringMesh::GetNumberOfSegments
void GetNumberOfSegments(G4int nSegment[3])
Definition: G4VScoringMesh.cc:103
G4VScoringMesh::GetRotationMatrix
G4RotationMatrix GetRotationMatrix() const
Definition: G4VScoringMesh.hh:108
G4VSolid::GetName
G4String GetName() const
G4VSolid::CreatePolyhedron
virtual G4Polyhedron * CreatePolyhedron() const
Definition: G4VSolid.cc:637
G4VSolid::GetEntityType
virtual G4GeometryType GetEntityType() const =0
G4VTrajectoryPoint::GetPosition
virtual const G4ThreeVector GetPosition() const =0
G4VTrajectory::GetPoint
virtual G4VTrajectoryPoint * GetPoint(G4int i) const =0
G4VTrajectory::GetPointEntries
virtual int GetPointEntries() const =0
G4VTrajectory::GetParticleName
virtual G4String GetParticleName() const =0
G4VTrajectory::GetTrackID
virtual G4int GetTrackID() const =0
G4VTrajectory::DrawTrajectory
virtual void DrawTrajectory(G4int i_mode=0) const
Definition: G4VTrajectory.cc:125
G4VTrajectory::GetInitialMomentum
virtual G4ThreeVector GetInitialMomentum() const =0
G4VTrajectory::GetCharge
virtual G4double GetCharge() const =0
G4VViewer::GetApplicableVisAttributes
const G4VisAttributes * GetApplicableVisAttributes(const G4VisAttributes *) const
Definition: G4VViewer.cc:78
G4VisAttributes::GetColor
const G4Color & GetColor() const
G4VisAttributes::IsVisible
G4bool IsVisible() const
G4VisManager::GetVerbosity
static Verbosity GetVerbosity()
Definition: G4VisManager.cc:1816
G4Visible::GetVisAttributes
const G4VisAttributes * GetVisAttributes() const
HepGeom::Transform3D::Identity
static const Transform3D Identity
Definition: Transform3D.h:197
HepGeom::Transform3D::getRotation
CLHEP::HepRotation getRotation() const
HepGeom::Transform3D::getTranslation
CLHEP::Hep3Vector getTranslation() const
HepGeom::Transform3D::inverse
Transform3D inverse() const
Definition: Transform3D.cc:142
HepPolyhedron::GetVertex
G4Point3D GetVertex(G4int index) const
Definition: HepPolyhedron.cc:883
HepPolyhedron::Transform
HepPolyhedron & Transform(const G4Transform3D &t)
Definition: HepPolyhedron.cc:831
HepPolyhedron::GetNoFacets
G4int GetNoFacets() const
Definition: HepPolyhedron.h:255
HepPolyhedron::GetNextVertexIndex
G4bool GetNextVertexIndex(G4int &index, G4int &edgeFlag) const
Definition: HepPolyhedron.cc:856
HepPolyhedron::GetNoVertices
G4int GetNoVertices() const
Definition: HepPolyhedron.h:252
HepPolyhedron::GetNextEdge
G4bool GetNextEdge(G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag) const
Definition: HepPolyhedron.cc:1022
EAxis
EAxis
Definition: geomdefs.hh:54
kYAxis
@ kYAxis
Definition: geomdefs.hh:54
kXAxis
@ kXAxis
Definition: geomdefs.hh:54
kZAxis
@ kZAxis
Definition: geomdefs.hh:54
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83