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