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.0.p3)


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