Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/gMocren/src/G4GMocrenFileSceneHandler.cc

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

Diff markup

Differences between /visualization/gMocren/src/G4GMocrenFileSceneHandler.cc (Version 11.3.0) and /visualization/gMocren/src/G4GMocrenFileSceneHandler.cc (Version 10.7.p2)


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