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 // Gorad (Geant4 Open-source Radiation Analys 26 // Gorad (Geant4 Open-source Radiation Analysis and Design) 27 // 27 // 28 // Author : Makoto Asai (SLAC National Accele 28 // Author : Makoto Asai (SLAC National Accelerator Laboratory) 29 // 29 // 30 // Development of Gorad is funded by NASA Joh 30 // Development of Gorad is funded by NASA Johnson Space Center (JSC) 31 // under the contract NNJ15HK11B. 31 // under the contract NNJ15HK11B. 32 // 32 // 33 // ******************************************* 33 // ******************************************************************** 34 // 34 // 35 // GRDetectorConstructionMessenger.cc 35 // GRDetectorConstructionMessenger.cc 36 // A messenger class that handles geometry c 36 // A messenger class that handles geometry configuration. 37 // 37 // 38 // History 38 // History 39 // September 8th, 2020 : first implementatio 39 // September 8th, 2020 : first implementation 40 // 40 // 41 // ******************************************* 41 // ******************************************************************** 42 42 43 #include "GRDetectorConstructionMessenger.hh" 43 #include "GRDetectorConstructionMessenger.hh" 44 44 45 #include "GRDetectorConstruction.hh" 45 #include "GRDetectorConstruction.hh" 46 #include "G4UIcommand.hh" 46 #include "G4UIcommand.hh" 47 #include "G4UIparameter.hh" 47 #include "G4UIparameter.hh" 48 #include "G4UIdirectory.hh" 48 #include "G4UIdirectory.hh" 49 #include "G4UIcmdWithAString.hh" 49 #include "G4UIcmdWithAString.hh" 50 #include "G4UIcmdWithAnInteger.hh" 50 #include "G4UIcmdWithAnInteger.hh" 51 #include "G4UIcmdWithoutParameter.hh" 51 #include "G4UIcmdWithoutParameter.hh" 52 52 53 GRDetectorConstructionMessenger::GRDetectorCon 53 GRDetectorConstructionMessenger::GRDetectorConstructionMessenger(GRDetectorConstruction* dc) 54 : pDC(dc) 54 : pDC(dc) 55 { 55 { 56 G4UIparameter* para = nullptr; 56 G4UIparameter* para = nullptr; 57 57 58 geomDir = new G4UIdirectory("/gorad/geometry 58 geomDir = new G4UIdirectory("/gorad/geometry/"); 59 geomDir->SetGuidance("GORAD geometry selecti 59 geomDir->SetGuidance("GORAD geometry selection"); 60 60 61 selectCmd = new G4UIcmdWithAString("/gorad/g 61 selectCmd = new G4UIcmdWithAString("/gorad/geometry/selectGDML",this); 62 selectCmd->SetGuidance("Select GDML file"); 62 selectCmd->SetGuidance("Select GDML file"); 63 selectCmd->SetParameterName("gdml",false); 63 selectCmd->SetParameterName("gdml",false); 64 selectCmd->AvailableForStates(G4State_PreIni 64 selectCmd->AvailableForStates(G4State_PreInit); 65 selectCmd->SetToBeBroadcasted(false); 65 selectCmd->SetToBeBroadcasted(false); 66 66 67 listSolidCmd = new G4UIcmdWithAnInteger("/go 67 listSolidCmd = new G4UIcmdWithAnInteger("/gorad/geometry/listSolids",this); 68 listSolidCmd->SetGuidance("List all the regi 68 listSolidCmd->SetGuidance("List all the registered solids"); 69 listSolidCmd->SetParameterName("level",true) 69 listSolidCmd->SetParameterName("level",true); 70 listSolidCmd->SetDefaultValue(0); 70 listSolidCmd->SetDefaultValue(0); 71 listSolidCmd->SetRange("level>=0 && level<=2 71 listSolidCmd->SetRange("level>=0 && level<=2"); 72 listSolidCmd->AvailableForStates(G4State_Idl 72 listSolidCmd->AvailableForStates(G4State_Idle); 73 listSolidCmd->SetToBeBroadcasted(false); 73 listSolidCmd->SetToBeBroadcasted(false); 74 74 75 listLogVolCmd = new G4UIcmdWithAnInteger("/g 75 listLogVolCmd = new G4UIcmdWithAnInteger("/gorad/geometry/listLogicalVolumes",this); 76 listLogVolCmd->SetGuidance("List all the reg 76 listLogVolCmd->SetGuidance("List all the registered logical volumes"); 77 listLogVolCmd->SetParameterName("level",true 77 listLogVolCmd->SetParameterName("level",true); 78 listLogVolCmd->SetDefaultValue(0); 78 listLogVolCmd->SetDefaultValue(0); 79 listLogVolCmd->SetRange("level>=0 && level<= 79 listLogVolCmd->SetRange("level>=0 && level<=2"); 80 listLogVolCmd->AvailableForStates(G4State_Id 80 listLogVolCmd->AvailableForStates(G4State_Idle); 81 listLogVolCmd->SetToBeBroadcasted(false); 81 listLogVolCmd->SetToBeBroadcasted(false); 82 82 83 listPhysVolCmd = new G4UIcmdWithAnInteger("/ 83 listPhysVolCmd = new G4UIcmdWithAnInteger("/gorad/geometry/listPhysicalVolumes",this); 84 listPhysVolCmd->SetGuidance("List all the re 84 listPhysVolCmd->SetGuidance("List all the registered physical volumes"); 85 listPhysVolCmd->SetParameterName("level",tru 85 listPhysVolCmd->SetParameterName("level",true); 86 listPhysVolCmd->SetDefaultValue(0); 86 listPhysVolCmd->SetDefaultValue(0); 87 listPhysVolCmd->SetRange("level>=0 && level< 87 listPhysVolCmd->SetRange("level>=0 && level<=2"); 88 listPhysVolCmd->AvailableForStates(G4State_I 88 listPhysVolCmd->AvailableForStates(G4State_Idle); 89 listPhysVolCmd->SetToBeBroadcasted(false); 89 listPhysVolCmd->SetToBeBroadcasted(false); 90 90 91 listRegionCmd = new G4UIcmdWithAnInteger("/g 91 listRegionCmd = new G4UIcmdWithAnInteger("/gorad/geometry/listRegions",this); 92 listRegionCmd->SetGuidance("List all the reg 92 listRegionCmd->SetGuidance("List all the registered regions"); 93 listRegionCmd->SetParameterName("level",true 93 listRegionCmd->SetParameterName("level",true); 94 listRegionCmd->SetDefaultValue(0); 94 listRegionCmd->SetDefaultValue(0); 95 listRegionCmd->SetRange("level>=0 && level<= 95 listRegionCmd->SetRange("level>=0 && level<=2"); 96 listRegionCmd->AvailableForStates(G4State_Id 96 listRegionCmd->AvailableForStates(G4State_Idle); 97 listRegionCmd->SetToBeBroadcasted(false); 97 listRegionCmd->SetToBeBroadcasted(false); 98 98 99 createRegionCmd = new G4UIcommand("/gorad/ge 99 createRegionCmd = new G4UIcommand("/gorad/geometry/createRegion",this); 100 createRegionCmd->SetGuidance("Create a regio 100 createRegionCmd->SetGuidance("Create a region and set the root logical volume to it."); 101 createRegionCmd->SetGuidance("Region propaga 101 createRegionCmd->SetGuidance("Region propagates to the daughter volumes. So, only the root logical volume (i.e. top of the hierarchy) should be defined."); 102 createRegionCmd->SetGuidance("If two isolate 102 createRegionCmd->SetGuidance("If two isolated root logical volumes should share the same region, the same region name can be used."); 103 createRegionCmd->SetGuidance("Region must no 103 createRegionCmd->SetGuidance("Region must not be set to the world volume."); 104 para = new G4UIparameter("regionName",'s',fa 104 para = new G4UIparameter("regionName",'s',false); 105 para->SetGuidance("Name of the region to be 105 para->SetGuidance("Name of the region to be created"); 106 createRegionCmd->SetParameter(para); 106 createRegionCmd->SetParameter(para); 107 para = new G4UIparameter("logVolName",'s',fa 107 para = new G4UIparameter("logVolName",'s',false); 108 para->SetGuidance("Name of the root logical 108 para->SetGuidance("Name of the root logical volume"); 109 createRegionCmd->SetParameter(para); 109 createRegionCmd->SetParameter(para); 110 createRegionCmd->AvailableForStates(G4State_ 110 createRegionCmd->AvailableForStates(G4State_Idle); 111 createRegionCmd->SetToBeBroadcasted(false); 111 createRegionCmd->SetToBeBroadcasted(false); 112 112 113 //// This command is fragile for large-scale 113 //// This command is fragile for large-scale geometry - temporally disabled 114 ////checkOverlapCmd = new G4UIcommand("/gora 114 ////checkOverlapCmd = new G4UIcommand("/gorad/geometry/checkOverlap",this); 115 ////checkOverlapCmd->SetGuidance("Check volu 115 ////checkOverlapCmd->SetGuidance("Check volume overlap with existing volumes"); 116 ////checkOverlapCmd->SetGuidance(" i.e. with 116 ////checkOverlapCmd->SetGuidance(" i.e. with mother volume for protrusion and with other siblings for overlap."); 117 ////checkOverlapCmd->SetGuidance(" - This co 117 ////checkOverlapCmd->SetGuidance(" - This command is valid only for placement and parameterized volumes. If this command is"); 118 ////checkOverlapCmd->SetGuidance(" used fo 118 ////checkOverlapCmd->SetGuidance(" used for other physical volume type, e.g. replica, command will be simply ignored."); 119 ////checkOverlapCmd->SetGuidance(" If \"** 119 ////checkOverlapCmd->SetGuidance(" If \"**ALL**\" is used as the volume name, all physical volumes are examined (SLOW!!)."); 120 ////checkOverlapCmd->SetGuidance(" - nSpots 120 ////checkOverlapCmd->SetGuidance(" - nSpots specifies number of spots on the surface of the volume to be examined."); 121 ////checkOverlapCmd->SetGuidance(" The mor 121 ////checkOverlapCmd->SetGuidance(" The more spots used, the more chances to detect overlaps, but the more time it takes."); 122 ////checkOverlapCmd->SetGuidance(" - maxErr 122 ////checkOverlapCmd->SetGuidance(" - maxErr specifies maximum number of errors to be generated (default 1) before quiting."); 123 ////para = new G4UIparameter("physVol",'s',t 123 ////para = new G4UIparameter("physVol",'s',true); 124 ////para->SetDefaultValue("**ALL**"); 124 ////para->SetDefaultValue("**ALL**"); 125 ////checkOverlapCmd->SetParameter(para); 125 ////checkOverlapCmd->SetParameter(para); 126 ////para = new G4UIparameter("nSpots",'i',tr 126 ////para = new G4UIparameter("nSpots",'i',true); 127 ////para->SetDefaultValue(1000); 127 ////para->SetDefaultValue(1000); 128 ////para->SetGuidance("Number of trial spots 128 ////para->SetGuidance("Number of trial spots on the volume surface"); 129 ////checkOverlapCmd->SetParameter(para); 129 ////checkOverlapCmd->SetParameter(para); 130 ////para = new G4UIparameter("maxErr",'i',tr 130 ////para = new G4UIparameter("maxErr",'i',true); 131 ////para->SetDefaultValue(1); 131 ////para->SetDefaultValue(1); 132 ////para->SetParameterRange("maxErr > 0"); 132 ////para->SetParameterRange("maxErr > 0"); 133 ////para->SetGuidance("Maxinum number of rep 133 ////para->SetGuidance("Maxinum number of report to be generated"); 134 ////checkOverlapCmd->SetParameter(para); 134 ////checkOverlapCmd->SetParameter(para); 135 ////para = new G4UIparameter("tolerance",'d' 135 ////para = new G4UIparameter("tolerance",'d',true); 136 ////para->SetDefaultValue(0.); 136 ////para->SetDefaultValue(0.); 137 ////para->SetParameterRange("tolerance >= 0. 137 ////para->SetParameterRange("tolerance >= 0."); 138 ////para->SetGuidance("Tolerance (default 0. 138 ////para->SetGuidance("Tolerance (default 0.)"); 139 ////checkOverlapCmd->SetParameter(para); 139 ////checkOverlapCmd->SetParameter(para); 140 ////para = new G4UIparameter("unit",'s',true 140 ////para = new G4UIparameter("unit",'s',true); 141 ////para->SetDefaultUnit("mm"); 141 ////para->SetDefaultUnit("mm"); 142 ////checkOverlapCmd->SetParameter(para); 142 ////checkOverlapCmd->SetParameter(para); 143 ////checkOverlapCmd->AvailableForStates(G4St 143 ////checkOverlapCmd->AvailableForStates(G4State_Idle); 144 ////checkOverlapCmd->SetToBeBroadcasted(fals 144 ////checkOverlapCmd->SetToBeBroadcasted(false); 145 145 146 materialDir = new G4UIdirectory("/gorad/mate 146 materialDir = new G4UIdirectory("/gorad/material/"); 147 materialDir->SetGuidance("GORAD material com 147 materialDir->SetGuidance("GORAD material commands"); 148 148 149 listMatCmd = new G4UIcmdWithAString("/gorad/ 149 listMatCmd = new G4UIcmdWithAString("/gorad/material/list",this); 150 listMatCmd->SetGuidance("List material prope 150 listMatCmd->SetGuidance("List material property"); 151 listMatCmd->SetGuidance(" If material name i 151 listMatCmd->SetGuidance(" If material name is not specified, this command list all registered materials"); 152 listMatCmd->SetParameterName("matName",true) 152 listMatCmd->SetParameterName("matName",true); 153 listMatCmd->SetDefaultValue("**ALL**"); 153 listMatCmd->SetDefaultValue("**ALL**"); 154 listMatCmd->AvailableForStates(G4State_Idle) 154 listMatCmd->AvailableForStates(G4State_Idle); 155 listMatCmd->SetToBeBroadcasted(false); 155 listMatCmd->SetToBeBroadcasted(false); 156 156 157 dumpMatCmd = new G4UIcmdWithoutParameter("/g 157 dumpMatCmd = new G4UIcmdWithoutParameter("/gorad/material/dumpNistMaterials",this); 158 dumpMatCmd->SetGuidance("List all pre-define 158 dumpMatCmd->SetGuidance("List all pre-defined material names in G4NistManager."); 159 dumpMatCmd->SetGuidance(" Note : a material 159 dumpMatCmd->SetGuidance(" Note : a material has to be instantiated with /gorad/material/create before setting it to a logical volume"); 160 dumpMatCmd->AvailableForStates(G4State_Idle) 160 dumpMatCmd->AvailableForStates(G4State_Idle); 161 dumpMatCmd->SetToBeBroadcasted(false); 161 dumpMatCmd->SetToBeBroadcasted(false); 162 162 163 createMatCmd = new G4UIcmdWithAString("/gora 163 createMatCmd = new G4UIcmdWithAString("/gorad/material/create",this); 164 createMatCmd->SetGuidance("Instantiate a mat 164 createMatCmd->SetGuidance("Instantiate a material defined in G4NistManager"); 165 createMatCmd->SetGuidance(" If the material 165 createMatCmd->SetGuidance(" If the material has already existed, this command does nothing."); 166 createMatCmd->SetParameterName("matName",fal 166 createMatCmd->SetParameterName("matName",false); 167 createMatCmd->AvailableForStates(G4State_Idl 167 createMatCmd->AvailableForStates(G4State_Idle); 168 createMatCmd->SetToBeBroadcasted(false); 168 createMatCmd->SetToBeBroadcasted(false); 169 169 170 getMatCmd = new G4UIcmdWithAString("/gorad/m 170 getMatCmd = new G4UIcmdWithAString("/gorad/material/show",this); 171 getMatCmd->SetGuidance("Show the current mat 171 getMatCmd->SetGuidance("Show the current material of the specified logical volume"); 172 getMatCmd->SetParameterName("logVol",false); 172 getMatCmd->SetParameterName("logVol",false); 173 getMatCmd->AvailableForStates(G4State_Idle); 173 getMatCmd->AvailableForStates(G4State_Idle); 174 getMatCmd->SetToBeBroadcasted(false); 174 getMatCmd->SetToBeBroadcasted(false); 175 175 176 setMatCmd = new G4UIcommand("/gorad/material 176 setMatCmd = new G4UIcommand("/gorad/material/set",this); 177 setMatCmd->SetGuidance("Set the material to 177 setMatCmd->SetGuidance("Set the material to the logical volume. The material has to be instantiated in advance."); 178 setMatCmd->SetGuidance(" [usage] /gorad/mat 178 setMatCmd->SetGuidance(" [usage] /gorad/material/set logicalVolumeName materialName"); 179 para = new G4UIparameter("logVol",'s',false) 179 para = new G4UIparameter("logVol",'s',false); 180 setMatCmd->SetParameter(para); 180 setMatCmd->SetParameter(para); 181 para = new G4UIparameter("matName",'s',false 181 para = new G4UIparameter("matName",'s',false); 182 setMatCmd->SetParameter(para); 182 setMatCmd->SetParameter(para); 183 setMatCmd->AvailableForStates(G4State_Idle); 183 setMatCmd->AvailableForStates(G4State_Idle); 184 setMatCmd->SetToBeBroadcasted(false); 184 setMatCmd->SetToBeBroadcasted(false); 185 } 185 } 186 186 187 GRDetectorConstructionMessenger::~GRDetectorCo 187 GRDetectorConstructionMessenger::~GRDetectorConstructionMessenger() 188 { 188 { 189 delete selectCmd; 189 delete selectCmd; 190 delete listSolidCmd; 190 delete listSolidCmd; 191 delete listLogVolCmd; 191 delete listLogVolCmd; 192 delete listPhysVolCmd; 192 delete listPhysVolCmd; 193 delete listRegionCmd; 193 delete listRegionCmd; 194 delete createRegionCmd; 194 delete createRegionCmd; 195 ////delete checkOverlapCmd; 195 ////delete checkOverlapCmd; 196 delete geomDir; 196 delete geomDir; 197 197 198 delete listMatCmd; 198 delete listMatCmd; 199 delete dumpMatCmd; 199 delete dumpMatCmd; 200 delete createMatCmd; 200 delete createMatCmd; 201 delete getMatCmd; 201 delete getMatCmd; 202 delete setMatCmd; 202 delete setMatCmd; 203 delete materialDir; 203 delete materialDir; 204 } 204 } 205 205 206 #include "G4Tokenizer.hh" 206 #include "G4Tokenizer.hh" 207 207 208 void GRDetectorConstructionMessenger::SetNewVa 208 void GRDetectorConstructionMessenger::SetNewValue(G4UIcommand* cmd, G4String val) 209 { 209 { 210 if(cmd==selectCmd) 210 if(cmd==selectCmd) 211 { 211 { 212 auto valid = pDC->SetGDMLFile(val); 212 auto valid = pDC->SetGDMLFile(val); 213 if(!valid) 213 if(!valid) 214 { 214 { 215 G4ExceptionDescription ed; 215 G4ExceptionDescription ed; 216 ed << "<" << val << "> is not a valid GD 216 ed << "<" << val << "> is not a valid GDML file."; 217 cmd->CommandFailed(ed); 217 cmd->CommandFailed(ed); 218 } 218 } 219 } 219 } 220 else if(cmd==listSolidCmd) 220 else if(cmd==listSolidCmd) 221 { pDC->ListSolids(listSolidCmd->GetNewIntVal 221 { pDC->ListSolids(listSolidCmd->GetNewIntValue(val)); } 222 else if(cmd==listLogVolCmd) 222 else if(cmd==listLogVolCmd) 223 { pDC->ListLogVols(listLogVolCmd->GetNewIntV 223 { pDC->ListLogVols(listLogVolCmd->GetNewIntValue(val)); } 224 else if(cmd==listPhysVolCmd) 224 else if(cmd==listPhysVolCmd) 225 { pDC->ListPhysVols(listPhysVolCmd->GetNewIn 225 { pDC->ListPhysVols(listPhysVolCmd->GetNewIntValue(val)); } 226 else if(cmd==listRegionCmd) 226 else if(cmd==listRegionCmd) 227 { pDC->ListRegions(listRegionCmd->GetNewIntV 227 { pDC->ListRegions(listRegionCmd->GetNewIntValue(val)); } 228 else if(cmd==createRegionCmd) 228 else if(cmd==createRegionCmd) 229 { 229 { 230 G4Tokenizer next(val); 230 G4Tokenizer next(val); 231 G4String regionName = next(); 231 G4String regionName = next(); 232 G4String logVolName = next(); 232 G4String logVolName = next(); 233 auto valid = pDC->CreateRegion(regionName, 233 auto valid = pDC->CreateRegion(regionName,logVolName); 234 if(!valid) 234 if(!valid) 235 { 235 { 236 G4ExceptionDescription ed; 236 G4ExceptionDescription ed; 237 ed << "Logical volume <" << logVolName < 237 ed << "Logical volume <" << logVolName << "> is not defined. Command ignored."; 238 cmd->CommandFailed(ed); 238 cmd->CommandFailed(ed); 239 } 239 } 240 } 240 } 241 ////else if(cmd==checkOverlapCmd) 241 ////else if(cmd==checkOverlapCmd) 242 ////{ 242 ////{ 243 ////G4Tokenizer next(val); 243 ////G4Tokenizer next(val); 244 ////G4String physVolName = next(); 244 ////G4String physVolName = next(); 245 ////G4int nSpots = StoI(next()); 245 ////G4int nSpots = StoI(next()); 246 ////G4int maxErr = StoI(next()); 246 ////G4int maxErr = StoI(next()); 247 ////G4String tolStr = next(); 247 ////G4String tolStr = next(); 248 ////G4double tol = StoD(tolStr); 248 ////G4double tol = StoD(tolStr); 249 ////if(tol>0.) 249 ////if(tol>0.) 250 ////{ 250 ////{ 251 ////tolStr += " "; 251 ////tolStr += " "; 252 ////tolStr += next(); 252 ////tolStr += next(); 253 ////tol = checkOverlapCmd->ConvertToDime 253 ////tol = checkOverlapCmd->ConvertToDimensionedDouble(tolStr); 254 ////} 254 ////} 255 ////auto valid = pDC->CheckOverlap(physVol 255 ////auto valid = pDC->CheckOverlap(physVolName,nSpots,maxErr,tol); 256 ////if(!valid) 256 ////if(!valid) 257 ////{ 257 ////{ 258 ////G4ExceptionDescription ed; 258 ////G4ExceptionDescription ed; 259 ////ed << "Physical volume <" << physVol 259 ////ed << "Physical volume <" << physVolName << "> is not defined. Command ignored."; 260 ////cmd->CommandFailed(ed); 260 ////cmd->CommandFailed(ed); 261 ////} 261 ////} 262 ////} 262 ////} 263 263 264 else if(cmd==listMatCmd) 264 else if(cmd==listMatCmd) 265 { 265 { 266 if(val=="**ALL**") 266 if(val=="**ALL**") 267 { pDC->ListAllMaterial(); } 267 { pDC->ListAllMaterial(); } 268 else 268 else 269 { 269 { 270 auto valid = pDC->ListMaterial(val); 270 auto valid = pDC->ListMaterial(val); 271 if(!valid) 271 if(!valid) 272 { 272 { 273 G4ExceptionDescription ed; 273 G4ExceptionDescription ed; 274 ed << "<" << val << "> is not defined. 274 ed << "<" << val << "> is not defined. If necessary, create it with /gorad/material/create command."; 275 cmd->CommandFailed(ed); 275 cmd->CommandFailed(ed); 276 } 276 } 277 } 277 } 278 } 278 } 279 else if(cmd==dumpMatCmd) 279 else if(cmd==dumpMatCmd) 280 { pDC->DumpNistMaterials(); } 280 { pDC->DumpNistMaterials(); } 281 else if(cmd==createMatCmd) 281 else if(cmd==createMatCmd) 282 { 282 { 283 auto valid = pDC->CreateMaterial(val); 283 auto valid = pDC->CreateMaterial(val); 284 if(!valid) 284 if(!valid) 285 { 285 { 286 G4ExceptionDescription ed; 286 G4ExceptionDescription ed; 287 ed << "The material name <" << val << "> 287 ed << "The material name <" << val << "> is not defined in G4NistManager."; 288 cmd->CommandFailed(ed); 288 cmd->CommandFailed(ed); 289 } 289 } 290 } 290 } 291 else if(cmd==getMatCmd) 291 else if(cmd==getMatCmd) 292 { 292 { 293 auto valid = pDC->GetMaterial(val); 293 auto valid = pDC->GetMaterial(val); 294 if(!valid) 294 if(!valid) 295 { 295 { 296 G4ExceptionDescription ed; 296 G4ExceptionDescription ed; 297 ed << "<" << val << "> is not a name of 297 ed << "<" << val << "> is not a name of registered logical volume.\n" 298 << "Check existing logical volumes wi 298 << "Check existing logical volumes with /gorad/geometry/listLogicalVolumes command."; 299 cmd->CommandFailed(ed); 299 cmd->CommandFailed(ed); 300 } 300 } 301 } 301 } 302 else if(cmd==setMatCmd) 302 else if(cmd==setMatCmd) 303 { 303 { 304 G4Tokenizer next(val); 304 G4Tokenizer next(val); 305 G4String logVolName = next(); 305 G4String logVolName = next(); 306 G4String matName = next(); 306 G4String matName = next(); 307 auto valid = pDC->SetMaterial(logVolName,m 307 auto valid = pDC->SetMaterial(logVolName,matName); 308 if(valid!=0) 308 if(valid!=0) 309 { 309 { 310 G4ExceptionDescription ed; 310 G4ExceptionDescription ed; 311 if(valid==1 || valid==3) 311 if(valid==1 || valid==3) 312 { 312 { 313 ed << "<" << logVolName << "> is not a 313 ed << "<" << logVolName << "> is not a name of registered logical volume.\n" 314 << "Check existing logical volumes 314 << "Check existing logical volumes with /gorad/geometry/listLogicalVolumes command.\n"; 315 } 315 } 316 if(valid==2 || valid==3) 316 if(valid==2 || valid==3) 317 { 317 { 318 ed << "<" << matName << "> is not defi 318 ed << "<" << matName << "> is not defined. If necessary, create it with /gorad/material/create command."; 319 } 319 } 320 cmd->CommandFailed(ed); 320 cmd->CommandFailed(ed); 321 } 321 } 322 } 322 } 323 323 324 } 324 } 325 325 326 G4String GRDetectorConstructionMessenger::GetC 326 G4String GRDetectorConstructionMessenger::GetCurrentValue(G4UIcommand* cmd) 327 { 327 { 328 G4String val(""); 328 G4String val(""); 329 if(cmd==selectCmd) 329 if(cmd==selectCmd) 330 { val = pDC->GetGDMLFile(); } 330 { val = pDC->GetGDMLFile(); } 331 return val; 331 return val; 332 } 332 } 333 333 334 334 335 335