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