Geant4 Cross Reference |
1 // 2 // ******************************************************************** 3 // * License and Disclaimer * 4 // * * 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. * 10 // * * 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitation of liability. * 17 // * * 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************************************** 25 // 26 // G4ScoreQuantityMessenger 27 // 28 // --------------------------------------------------------------------- 29 // Modifications 30 // 08-Oct-2010 T.Aso Remove unit of G4PSPassageCellCurrent. 31 // 24-Mar-2011 T.Aso Add StepChecker for debugging. 32 // 24-Mar-2011 T.Aso Size and segmentation for replicated cylinder. 33 // 01-Jun-2012 T.Aso Support weighted/dividedByArea options 34 // in flatCurrent and flatFulx commands. 35 // 27-Mar-2013 T.Aso Unit option in the kineticEnergy filter was supported. 36 // --------------------------------------------------------------------- 37 38 #include "G4ScoreQuantityMessenger.hh" 39 #include "G4ScoringManager.hh" 40 #include "G4VScoringMesh.hh" 41 #include "G4VPrimitiveScorer.hh" 42 43 #include "G4PSCellCharge3D.hh" 44 #include "G4PSCellFlux3D.hh" 45 #include "G4PSCellFluxForCylinder3D.hh" 46 #include "G4PSPassageCellFlux3D.hh" 47 #include "G4PSPassageCellFluxForCylinder3D.hh" 48 #include "G4PSEnergyDeposit3D.hh" 49 #include "G4PSDoseDeposit3D.hh" 50 #include "G4PSDoseDepositForCylinder3D.hh" 51 #include "G4PSNofStep3D.hh" 52 #include "G4PSNofSecondary3D.hh" 53 // 54 #include "G4PSTrackLength3D.hh" 55 #include "G4PSPassageCellCurrent3D.hh" 56 #include "G4PSPassageTrackLength3D.hh" 57 #include "G4PSFlatSurfaceCurrent3D.hh" 58 #include "G4PSFlatSurfaceFlux3D.hh" 59 #include "G4PSSphereSurfaceCurrent3D.hh" 60 #include "G4PSSphereSurfaceFlux3D.hh" 61 #include "G4PSCylinderSurfaceCurrent3D.hh" 62 #include "G4PSCylinderSurfaceFlux3D.hh" 63 #include "G4PSVolumeFlux3D.hh" 64 #include "G4PSNofCollision3D.hh" 65 #include "G4PSPopulation3D.hh" 66 #include "G4PSTrackCounter3D.hh" 67 #include "G4PSTermination3D.hh" 68 #include "G4PSMinKinEAtGeneration3D.hh" 69 70 #include "G4PSCellCharge.hh" 71 #include "G4PSCellFlux.hh" 72 #include "G4PSPassageCellFlux.hh" 73 #include "G4PSEnergyDeposit.hh" 74 #include "G4PSDoseDeposit.hh" 75 #include "G4PSNofStep.hh" 76 #include "G4PSNofSecondary.hh" 77 // 78 #include "G4PSTrackLength.hh" 79 #include "G4PSPassageCellCurrent.hh" 80 #include "G4PSPassageTrackLength.hh" 81 #include "G4PSFlatSurfaceCurrent.hh" 82 #include "G4PSFlatSurfaceFlux.hh" 83 #include "G4PSSphereSurfaceCurrent.hh" 84 #include "G4PSSphereSurfaceFlux.hh" 85 #include "G4PSCylinderSurfaceCurrent.hh" 86 #include "G4PSCylinderSurfaceFlux.hh" 87 #include "G4PSNofCollision.hh" 88 #include "G4PSPopulation.hh" 89 #include "G4PSTrackCounter.hh" 90 #include "G4PSTermination.hh" 91 #include "G4PSMinKinEAtGeneration.hh" 92 93 // 94 // For debug purpose 95 #include "G4PSStepChecker3D.hh" 96 97 #include "G4SDChargedFilter.hh" 98 #include "G4SDNeutralFilter.hh" 99 #include "G4SDKineticEnergyFilter.hh" 100 #include "G4SDParticleFilter.hh" 101 #include "G4SDParticleWithEnergyFilter.hh" 102 103 #include "G4UIdirectory.hh" 104 #include "G4UIcmdWithoutParameter.hh" 105 #include "G4UIcmdWithAnInteger.hh" 106 #include "G4UIcmdWithAString.hh" 107 #include "G4UIcmdWithABool.hh" 108 #include "G4UIcmdWithADoubleAndUnit.hh" 109 #include "G4UIcmdWith3VectorAndUnit.hh" 110 #include "G4UIcommand.hh" 111 #include "G4UIparameter.hh" 112 #include "G4Tokenizer.hh" 113 #include "G4UnitsTable.hh" 114 115 G4ScoreQuantityMessenger::G4ScoreQuantityMessenger(G4ScoringManager* SManager) 116 : fSMan(SManager) 117 { 118 QuantityCommands(); 119 FilterCommands(); 120 } 121 122 void G4ScoreQuantityMessenger::QuantityCommands() 123 { 124 G4UIparameter* param; 125 126 // 127 // Quantity commands 128 quantityDir = new G4UIdirectory("/score/quantity/"); 129 quantityDir->SetGuidance("Scoring quantity of the mesh."); 130 // 131 qTouchCmd = new G4UIcmdWithAString("/score/quantity/touch", this); 132 qTouchCmd->SetGuidance( 133 "Assign previously defined quantity to the current quantity."); 134 qTouchCmd->SetParameterName("qname", false); 135 // 136 qGetUnitCmd = new G4UIcmdWithoutParameter("/score/quantity/get/unit", this); 137 qGetUnitCmd->SetGuidance("Print output unit of the current quantity."); 138 // 139 qSetUnitCmd = new G4UIcmdWithAString("/score/quantity/set/unit", this); 140 qSetUnitCmd->SetGuidance("Set output unit of the current quantity."); 141 qSetUnitCmd->SetParameterName("unit", false); 142 143 // Primitive Scorers 144 qeDepCmd = new G4UIcommand("/score/quantity/energyDeposit", this); 145 qeDepCmd->SetGuidance("Energy deposit scorer."); 146 qeDepCmd->SetGuidance("[usage] /score/quantity/energyDeposit qname unit"); 147 qeDepCmd->SetGuidance(" qname :(String) scorer name"); 148 qeDepCmd->SetGuidance(" unit :(String) unit"); 149 param = new G4UIparameter("qname", 's', false); 150 qeDepCmd->SetParameter(param); 151 param = new G4UIparameter("unit", 's', true); 152 param->SetDefaultUnit("MeV"); 153 qeDepCmd->SetParameter(param); 154 // 155 qCellChgCmd = new G4UIcommand("/score/quantity/cellCharge", this); 156 qCellChgCmd->SetGuidance("Cell charge scorer."); 157 qCellChgCmd->SetGuidance("[usage] /score/quantity/cellCharge qname unit"); 158 qCellChgCmd->SetGuidance(" qname :(String) scorer name"); 159 qCellChgCmd->SetGuidance(" unit :(String) unit"); 160 param = new G4UIparameter("qname", 's', false); 161 qCellChgCmd->SetParameter(param); 162 param = new G4UIparameter("unit", 's', true); 163 param->SetDefaultUnit("e+"); 164 qCellChgCmd->SetParameter(param); 165 // 166 qCellFluxCmd = new G4UIcommand("/score/quantity/cellFlux", this); 167 qCellFluxCmd->SetGuidance("Cell flux scorer."); 168 qCellFluxCmd->SetGuidance("[usage] /score/quantity/cellFlux qname unit"); 169 qCellFluxCmd->SetGuidance(" qname :(String) scorer name"); 170 qCellFluxCmd->SetGuidance(" unit :(String) unit"); 171 param = new G4UIparameter("qname", 's', false); 172 qCellFluxCmd->SetParameter(param); 173 param = new G4UIparameter("unit", 's', true); 174 param->SetDefaultValue("percm2"); 175 qCellFluxCmd->SetParameter(param); 176 // 177 qPassCellFluxCmd = new G4UIcommand("/score/quantity/passageCellFlux", this); 178 qPassCellFluxCmd->SetGuidance("Passage cell flux scorer"); 179 qPassCellFluxCmd->SetGuidance( 180 "[usage] /score/quantity/passageCellFlux qname unit"); 181 qPassCellFluxCmd->SetGuidance(" qname :(String) scorer name"); 182 qPassCellFluxCmd->SetGuidance(" unit :(String) unit"); 183 param = new G4UIparameter("qname", 's', false); 184 qPassCellFluxCmd->SetParameter(param); 185 param = new G4UIparameter("unit", 's', true); 186 param->SetDefaultValue("percm2"); 187 qPassCellFluxCmd->SetParameter(param); 188 // 189 qdoseDepCmd = new G4UIcommand("/score/quantity/doseDeposit", this); 190 qdoseDepCmd->SetGuidance("Dose deposit scorer."); 191 qdoseDepCmd->SetGuidance("[usage] /score/quantity/doseDeposit qname unit"); 192 qdoseDepCmd->SetGuidance(" qname :(String) scorer name"); 193 qdoseDepCmd->SetGuidance(" unit :(String) unit"); 194 param = new G4UIparameter("qname", 's', false); 195 qdoseDepCmd->SetParameter(param); 196 param = new G4UIparameter("unit", 's', true); 197 param->SetDefaultUnit("Gy"); 198 qdoseDepCmd->SetParameter(param); 199 // 200 qnOfStepCmd = new G4UIcommand("/score/quantity/nOfStep", this); 201 qnOfStepCmd->SetGuidance("Number of step scorer."); 202 qnOfStepCmd->SetGuidance("[usage] /score/quantity/nOfStep qname"); 203 qnOfStepCmd->SetGuidance("[usage] /score/quantity/nOfStep qname bflag"); 204 qnOfStepCmd->SetGuidance(" qname :(String) scorer name"); 205 qnOfStepCmd->SetGuidance(" bflag :(Bool) Skip zero step "); 206 qnOfStepCmd->SetGuidance(" at geometry boundary if true"); 207 param = new G4UIparameter("qname", 's', false); 208 qnOfStepCmd->SetParameter(param); 209 param = new G4UIparameter("bflag", 'b', true); 210 param->SetDefaultValue("false"); 211 qnOfStepCmd->SetParameter(param); 212 // 213 qnOfSecondaryCmd = new G4UIcommand("/score/quantity/nOfSecondary", this); 214 qnOfSecondaryCmd->SetGuidance("Number of secondary scorer."); 215 qnOfSecondaryCmd->SetGuidance("[usage] /score/quantity/nOfSecondary qname"); 216 qnOfSecondaryCmd->SetGuidance(" qname :(String) scorer name"); 217 param = new G4UIparameter("qname", 's', false); 218 qnOfSecondaryCmd->SetParameter(param); 219 // 220 qTrackLengthCmd = new G4UIcommand("/score/quantity/trackLength", this); 221 qTrackLengthCmd->SetGuidance("Track length scorer."); 222 qTrackLengthCmd->SetGuidance( 223 "[usage] /score/quantity/trackLength qname wflag kflag vflag unit"); 224 qTrackLengthCmd->SetGuidance(" qname :(String) scorer name"); 225 qTrackLengthCmd->SetGuidance(" wflag :(Bool) weighted"); 226 qTrackLengthCmd->SetGuidance(" kflag :(Bool) multiply kinetic energy"); 227 qTrackLengthCmd->SetGuidance(" vflag :(Bool) divide by velocity"); 228 qTrackLengthCmd->SetGuidance(" unit :(String) unit"); 229 param = new G4UIparameter("qname", 's', false); 230 qTrackLengthCmd->SetParameter(param); 231 param = new G4UIparameter("wflag", 'b', true); 232 param->SetDefaultValue("false"); 233 qTrackLengthCmd->SetParameter(param); 234 param = new G4UIparameter("kflag", 'b', true); 235 param->SetDefaultValue("false"); 236 qTrackLengthCmd->SetParameter(param); 237 param = new G4UIparameter("vflag", 'b', true); 238 param->SetDefaultValue("false"); 239 qTrackLengthCmd->SetParameter(param); 240 param = new G4UIparameter("unit", 's', true); 241 param->SetDefaultValue("mm"); 242 qTrackLengthCmd->SetParameter(param); 243 // 244 qPassCellCurrCmd = 245 new G4UIcommand("/score/quantity/passageCellCurrent", this); 246 qPassCellCurrCmd->SetGuidance("Passage cell current scorer."); 247 qPassCellCurrCmd->SetGuidance( 248 "[usage] /score/quantity/passageCellCurrent qname wflag"); 249 qPassCellCurrCmd->SetGuidance(" qname :(String) scorer name"); 250 qPassCellCurrCmd->SetGuidance(" wflag :(Bool) weighted"); 251 param = new G4UIparameter("qname", 's', false); 252 qPassCellCurrCmd->SetParameter(param); 253 param = new G4UIparameter("wflag", 'b', true); 254 param->SetDefaultValue("true"); 255 qPassCellCurrCmd->SetParameter(param); 256 // 257 qPassTrackLengthCmd = 258 new G4UIcommand("/score/quantity/passageTrackLength", this); 259 qPassTrackLengthCmd->SetGuidance("Passage track length scorer."); 260 qPassTrackLengthCmd->SetGuidance( 261 "[usage] /score/quantity/passageTrackLength qname wflag unit"); 262 qPassTrackLengthCmd->SetGuidance(" qname :(String) scorer name"); 263 qPassTrackLengthCmd->SetGuidance(" wflag :(Bool) weighted"); 264 qPassTrackLengthCmd->SetGuidance(" unit :(Bool) unit"); 265 param = new G4UIparameter("qname", 's', false); 266 qPassTrackLengthCmd->SetParameter(param); 267 param = new G4UIparameter("wflag", 'b', true); 268 param->SetDefaultValue("true"); 269 qPassTrackLengthCmd->SetParameter(param); 270 param = new G4UIparameter("unit", 's', true); 271 param->SetDefaultUnit("mm"); 272 qPassTrackLengthCmd->SetParameter(param); 273 // 274 qFlatSurfCurrCmd = 275 new G4UIcommand("/score/quantity/flatSurfaceCurrent", this); 276 qFlatSurfCurrCmd->SetGuidance("Flat surface current Scorer."); 277 qFlatSurfCurrCmd->SetGuidance( 278 "[usage] /score/quantity/flatSurfaceCurrent qname dflag wflag aflag unit"); 279 qFlatSurfCurrCmd->SetGuidance(" qname :(String) scorer name"); 280 qFlatSurfCurrCmd->SetGuidance(" dflag :(Int) direction flag"); 281 qFlatSurfCurrCmd->SetGuidance(" : 0 = Both In and Out"); 282 qFlatSurfCurrCmd->SetGuidance(" : 1 = In only"); 283 qFlatSurfCurrCmd->SetGuidance(" : 2 = Out only"); 284 qFlatSurfCurrCmd->SetGuidance(" wflag :(Bool) weighted"); 285 qFlatSurfCurrCmd->SetGuidance(" aflag :(Bool) divide by area"); 286 qFlatSurfCurrCmd->SetGuidance(" unit :(String) unit"); 287 param = new G4UIparameter("qname", 's', false); 288 qFlatSurfCurrCmd->SetParameter(param); 289 param = new G4UIparameter("dflag", 'i', true); 290 param->SetDefaultValue("0"); 291 qFlatSurfCurrCmd->SetParameter(param); 292 param = new G4UIparameter("wflag", 'b', true); 293 param->SetDefaultValue("true"); 294 qFlatSurfCurrCmd->SetParameter(param); 295 param = new G4UIparameter("aflag", 'b', true); 296 param->SetDefaultValue("true"); 297 qFlatSurfCurrCmd->SetParameter(param); 298 param = new G4UIparameter("unit", 's', true); 299 param->SetDefaultValue("percm2"); 300 qFlatSurfCurrCmd->SetParameter(param); 301 // 302 qFlatSurfFluxCmd = new G4UIcommand("/score/quantity/flatSurfaceFlux", this); 303 qFlatSurfFluxCmd->SetGuidance("Flat surface flux scorer."); 304 qFlatSurfFluxCmd->SetGuidance( 305 "[usage] /score/quantity/flatSurfaceFlux qname dflag unit"); 306 qFlatSurfFluxCmd->SetGuidance(" qname :(String) scorer name"); 307 qFlatSurfFluxCmd->SetGuidance(" dflag :(Int) direction flag"); 308 qFlatSurfFluxCmd->SetGuidance(" : 0 = Both In and Out"); 309 qFlatSurfFluxCmd->SetGuidance(" : 1 = In only"); 310 qFlatSurfFluxCmd->SetGuidance(" : 2 = Out only"); 311 qFlatSurfFluxCmd->SetGuidance(" wflag :(Bool) weighted"); 312 qFlatSurfFluxCmd->SetGuidance(" aflag :(Bool) divide by area"); 313 qFlatSurfFluxCmd->SetGuidance(" unit :(String) unit"); 314 param = new G4UIparameter("qname", 's', false); 315 qFlatSurfFluxCmd->SetParameter(param); 316 param = new G4UIparameter("dflag", 'i', true); 317 param->SetDefaultValue("0"); 318 qFlatSurfFluxCmd->SetParameter(param); 319 param = new G4UIparameter("wflag", 'b', true); 320 param->SetDefaultValue("true"); 321 qFlatSurfFluxCmd->SetParameter(param); 322 param = new G4UIparameter("aflag", 'b', true); 323 param->SetDefaultValue("true"); 324 qFlatSurfFluxCmd->SetParameter(param); 325 param = new G4UIparameter("unit", 's', true); 326 param->SetDefaultValue("percm2"); 327 qFlatSurfFluxCmd->SetParameter(param); 328 // 329 330 qVolFluxCmd = new G4UIcommand("/score/quantity/volumeFlux", this); 331 qVolFluxCmd->SetGuidance("Volume flux scorer."); 332 qVolFluxCmd->SetGuidance( 333 "This scorer scores the number of particles getting into the volume " 334 "without normalized by the surface area."); 335 qVolFluxCmd->SetGuidance( 336 "[usage] /score/quantity/volumeFlux qname divcos dflag"); 337 qVolFluxCmd->SetGuidance(" qname :(String) scorer name"); 338 qVolFluxCmd->SetGuidance(" divcos :(Bool) divide by cos(theta), where theta " 339 "is the incident angle (default : false)"); 340 qVolFluxCmd->SetGuidance( 341 " dflag :(Int) direction, 1 : inward (default), 2 : outward"); 342 param = new G4UIparameter("qname", 's', false); 343 qVolFluxCmd->SetParameter(param); 344 param = new G4UIparameter("divcos", 'b', true); 345 param->SetDefaultValue(0); 346 qVolFluxCmd->SetParameter(param); 347 param = new G4UIparameter("dflag", 'i', true); 348 param->SetParameterRange("dflag>=1 && dflag<=2"); 349 param->SetDefaultValue(1); 350 qVolFluxCmd->SetParameter(param); 351 352 qNofCollisionCmd = new G4UIcommand("/score/quantity/nOfCollision", this); 353 qNofCollisionCmd->SetGuidance("Number of collision scorer."); 354 qNofCollisionCmd->SetGuidance( 355 "[usage] /score/quantity/nOfCollision qname wflag"); 356 qNofCollisionCmd->SetGuidance(" qname :(String) scorer name"); 357 param = new G4UIparameter("qname", 's', false); 358 qNofCollisionCmd->SetParameter(param); 359 param = new G4UIparameter("wflag", 'b', true); 360 param->SetDefaultValue("false"); 361 qNofCollisionCmd->SetParameter(param); 362 // 363 qPopulationCmd = new G4UIcommand("/score/quantity/population", this); 364 qPopulationCmd->SetGuidance("Population scorer."); 365 qPopulationCmd->SetGuidance("[usage] /score/quantity/population qname wflag"); 366 qPopulationCmd->SetGuidance(" qname :(String) scorer name"); 367 qPopulationCmd->SetGuidance(" wflag :(Bool) weighted"); 368 param = new G4UIparameter("qname", 's', false); 369 qPopulationCmd->SetParameter(param); 370 param = new G4UIparameter("wflag", 'b', true); 371 param->SetDefaultValue("false"); 372 qPopulationCmd->SetParameter(param); 373 374 // 375 qTrackCountCmd = new G4UIcommand("/score/quantity/nOfTrack", this); 376 qTrackCountCmd->SetGuidance("Number of track scorer."); 377 qTrackCountCmd->SetGuidance( 378 "[usage] /score/quantity/nOfTrack qname dflag wflag"); 379 qTrackCountCmd->SetGuidance(" qname :(String) scorer name"); 380 qTrackCountCmd->SetGuidance(" dflag :(Int) direction"); 381 qTrackCountCmd->SetGuidance(" : 0 = Both In and Out"); 382 qTrackCountCmd->SetGuidance(" : 1 = In only"); 383 qTrackCountCmd->SetGuidance(" : 2 = Out only"); 384 qTrackCountCmd->SetGuidance(" wflag :(Bool) weighted"); 385 param = new G4UIparameter("qname", 's', false); 386 qTrackCountCmd->SetParameter(param); 387 param = new G4UIparameter("dflag", 'i', true); 388 param->SetDefaultValue("0"); 389 qTrackCountCmd->SetParameter(param); 390 param = new G4UIparameter("wflag", 'b', true); 391 param->SetDefaultValue("false"); 392 qTrackCountCmd->SetParameter(param); 393 394 // 395 qTerminationCmd = new G4UIcommand("/score/quantity/nOfTerminatedTrack", this); 396 qTerminationCmd->SetGuidance("Number of terminated tracks scorer."); 397 qTerminationCmd->SetGuidance( 398 "[usage] /score/quantity/nOfTerminatedTrack qname wflag"); 399 qTerminationCmd->SetGuidance(" qname :(String) scorer name"); 400 qTerminationCmd->SetGuidance(" wflag :(Bool) weighted"); 401 param = new G4UIparameter("qname", 's', false); 402 qTerminationCmd->SetParameter(param); 403 param = new G4UIparameter("wflag", 'b', true); 404 param->SetDefaultValue("false"); 405 qTerminationCmd->SetParameter(param); 406 407 // 408 qMinKinEAtGeneCmd = 409 new G4UIcommand("/score/quantity/minKinEAtGeneration", this); 410 qMinKinEAtGeneCmd->SetGuidance("Min Kinetic Energy at Generation"); 411 qMinKinEAtGeneCmd->SetGuidance( 412 "[usage] /score/quantity/minKinEAtGeneration qname unit"); 413 qMinKinEAtGeneCmd->SetGuidance(" qname :(String) scorer name"); 414 qMinKinEAtGeneCmd->SetGuidance(" unit :(String) unit name"); 415 param = new G4UIparameter("qname", 's', false); 416 qMinKinEAtGeneCmd->SetParameter(param); 417 param = new G4UIparameter("unit", 's', true); 418 param->SetDefaultUnit("MeV"); 419 qMinKinEAtGeneCmd->SetParameter(param); 420 // 421 qStepCheckerCmd = new G4UIcommand("/score/quantity/stepChecker", this); 422 qStepCheckerCmd->SetGuidance("Display a comment when this PS is invoked"); 423 qStepCheckerCmd->SetGuidance("[usage] /score/quantity/stepChecker qname"); 424 qStepCheckerCmd->SetGuidance(" qname :(String) scorer name"); 425 param = new G4UIparameter("qname", 's', false); 426 qStepCheckerCmd->SetParameter(param); 427 } 428 429 void G4ScoreQuantityMessenger::FilterCommands() 430 { 431 G4UIparameter* param; 432 433 // 434 // Filter commands 435 filterDir = new G4UIdirectory("/score/filter/"); 436 filterDir->SetGuidance(" Scoring filter commands."); 437 // 438 fchargedCmd = new G4UIcmdWithAString("/score/filter/charged", this); 439 fchargedCmd->SetGuidance("Charged particle filter."); 440 fchargedCmd->SetParameterName("fname", false); 441 // 442 fneutralCmd = new G4UIcmdWithAString("/score/filter/neutral", this); 443 fneutralCmd->SetGuidance("Neutral particle filter."); 444 fneutralCmd->SetParameterName("fname", false); 445 // 446 fkinECmd = new G4UIcommand("/score/filter/kineticEnergy", this); 447 fkinECmd->SetGuidance("Kinetic energy filter."); 448 fkinECmd->SetGuidance( 449 "[usage] /score/filter/kineticEnergy fname Elow Ehigh unit"); 450 fkinECmd->SetGuidance(" fname :(String) Filter Name "); 451 fkinECmd->SetGuidance(" Elow :(Double) Lower edge of kinetic energy"); 452 fkinECmd->SetGuidance(" Ehigh :(Double) Higher edge of kinetic energy"); 453 fkinECmd->SetGuidance(" unit :(String) unit of given kinetic energy"); 454 param = new G4UIparameter("fname", 's', false); 455 fkinECmd->SetParameter(param); 456 param = new G4UIparameter("elow", 'd', true); 457 param->SetDefaultValue("0.0"); 458 fkinECmd->SetParameter(param); 459 param = new G4UIparameter("ehigh", 'd', true); 460 fkinECmd->SetParameter(param); 461 G4String smax = DtoS(DBL_MAX); 462 param->SetDefaultValue(smax); 463 param = new G4UIparameter("unit", 's', true); 464 param->SetDefaultUnit("keV"); 465 fkinECmd->SetParameter(param); 466 // 467 fparticleCmd = new G4UIcommand("/score/filter/particle", this); 468 fparticleCmd->SetGuidance("Particle filter."); 469 fparticleCmd->SetGuidance("[usage] /score/filter/particle fname p0 .. pn"); 470 fparticleCmd->SetGuidance(" fname :(String) Filter Name "); 471 fparticleCmd->SetGuidance(" p0 .. pn :(String) particle names"); 472 param = new G4UIparameter("fname", 's', false); 473 fparticleCmd->SetParameter(param); 474 param = new G4UIparameter("particlelist", 's', false); 475 param->SetDefaultValue(""); 476 fparticleCmd->SetParameter(param); 477 // 478 // 479 // 480 fparticleKinECmd = 481 new G4UIcommand("/score/filter/particleWithKineticEnergy", this); 482 fparticleKinECmd->SetGuidance("Particle with kinetic energy filter."); 483 fparticleKinECmd->SetGuidance( 484 "[usage] /score/filter/particleWithKineticEnergy fname Elow Ehigh unit p0 " 485 ".. pn"); 486 fparticleKinECmd->SetGuidance(" fname :(String) Filter Name "); 487 fparticleKinECmd->SetGuidance( 488 " Elow :(Double) Lower edge of kinetic energy"); 489 fparticleKinECmd->SetGuidance( 490 " Ehigh :(Double) Higher edge of kinetic energy"); 491 fparticleKinECmd->SetGuidance( 492 " unit :(String) unit of given kinetic energy"); 493 fparticleKinECmd->SetGuidance(" p0 .. pn :(String) particle names"); 494 param = new G4UIparameter("fname", 's', false); 495 fparticleKinECmd->SetParameter(param); 496 param = new G4UIparameter("elow", 'd', false); 497 param->SetDefaultValue("0.0"); 498 fparticleKinECmd->SetParameter(param); 499 param = new G4UIparameter("ehigh", 'd', true); 500 param->SetDefaultValue(smax); 501 fparticleKinECmd->SetParameter(param); 502 param = new G4UIparameter("unit", 's', true); 503 param->SetDefaultUnit("keV"); 504 fparticleKinECmd->SetParameter(param); 505 param = new G4UIparameter("particlelist", 's', false); 506 param->SetDefaultValue(""); 507 fparticleKinECmd->SetParameter(param); 508 // 509 // 510 } 511 512 G4ScoreQuantityMessenger::~G4ScoreQuantityMessenger() 513 { 514 delete quantityDir; 515 delete qTouchCmd; 516 delete qGetUnitCmd; 517 delete qSetUnitCmd; 518 519 // 520 delete qCellChgCmd; 521 delete qCellFluxCmd; 522 delete qPassCellFluxCmd; 523 delete qeDepCmd; 524 delete qdoseDepCmd; 525 delete qnOfStepCmd; 526 delete qnOfSecondaryCmd; 527 // 528 delete qTrackLengthCmd; 529 delete qPassCellCurrCmd; 530 delete qPassTrackLengthCmd; 531 delete qFlatSurfCurrCmd; 532 delete qFlatSurfFluxCmd; 533 delete qVolFluxCmd; 534 535 delete qNofCollisionCmd; 536 delete qPopulationCmd; 537 delete qTrackCountCmd; 538 delete qTerminationCmd; 539 delete qMinKinEAtGeneCmd; 540 // 541 delete qStepCheckerCmd; 542 // 543 delete filterDir; 544 delete fchargedCmd; 545 delete fneutralCmd; 546 delete fkinECmd; 547 delete fparticleCmd; 548 delete fparticleKinECmd; 549 } 550 551 void G4ScoreQuantityMessenger::SetNewValue(G4UIcommand* command, 552 G4String newVal) 553 { 554 using MeshShape = G4VScoringMesh::MeshShape; 555 556 G4ExceptionDescription ed; 557 558 // 559 // Get Current Mesh 560 // 561 G4VScoringMesh* mesh = fSMan->GetCurrentMesh(); 562 if(mesh == nullptr) 563 { 564 ed << "ERROR : No mesh is currently open. Open/create a mesh first. " 565 "Command ignored."; 566 command->CommandFailed(ed); 567 return; 568 } 569 // Mesh type 570 auto shape = mesh->GetShape(); 571 // Tokens 572 G4TokenVec token; 573 FillTokenVec(newVal, token); 574 // 575 // Commands for Current Mesh 576 if(command == qTouchCmd) 577 { 578 mesh->SetCurrentPrimitiveScorer(newVal); 579 } 580 else if(command == qGetUnitCmd) 581 { 582 G4cout << "Unit: " << mesh->GetCurrentPSUnit() << G4endl; 583 } 584 else if(command == qSetUnitCmd) 585 { 586 mesh->SetCurrentPSUnit(newVal); 587 } 588 else if(command == qCellChgCmd) 589 { 590 if(CheckMeshPS(mesh, token[0], command)) 591 { 592 G4PSCellCharge* ps = nullptr; 593 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 594 { 595 ps = new G4PSCellCharge(token[0], mesh->GetCopyNumberLevel()); 596 } 597 else 598 { 599 ps = new G4PSCellCharge3D(token[0]); 600 } 601 ps->SetUnit(token[1]); 602 mesh->SetPrimitiveScorer(ps); 603 } 604 } 605 else if(command == qCellFluxCmd) 606 { 607 if(CheckMeshPS(mesh, token[0], command)) 608 { 609 G4PSCellFlux* ps = nullptr; 610 if(shape == MeshShape::box) 611 { 612 ps = new G4PSCellFlux3D(token[0]); 613 } 614 else if(shape == MeshShape::cylinder) 615 { 616 auto pps = 617 new G4PSCellFluxForCylinder3D(token[0]); 618 pps->SetCylinderSize(mesh->GetSize(),mesh->GetStartAngle(),mesh->GetAngleSpan()); 619 G4int nSeg[3]; 620 mesh->GetNumberOfSegments(nSeg); 621 pps->SetNumberOfSegments(nSeg); 622 ps = pps; 623 } 624 else if(shape == MeshShape::realWorldLogVol) 625 { 626 ed << "Cell flux for real world volume is not yet supported. Command " 627 "ignored."; 628 command->CommandFailed(ed); 629 return; 630 } 631 else if(shape == MeshShape::probe) 632 { 633 ps = new G4PSCellFlux(token[0]); 634 } 635 ps->SetUnit(token[1]); 636 mesh->SetPrimitiveScorer(ps); 637 } 638 } 639 else if(command == qPassCellFluxCmd) 640 { 641 if(CheckMeshPS(mesh, token[0], command)) 642 { 643 G4PSPassageCellFlux* ps = nullptr; 644 if(shape == MeshShape::box) 645 { 646 ps = new G4PSPassageCellFlux3D(token[0]); 647 } 648 else if(shape == MeshShape::cylinder) 649 { 650 auto pps = 651 new G4PSPassageCellFluxForCylinder3D(token[0]); 652 pps->SetCylinderSize(mesh->GetSize(),mesh->GetStartAngle(),mesh->GetAngleSpan()); 653 G4int nSeg[3]; 654 mesh->GetNumberOfSegments(nSeg); 655 pps->SetNumberOfSegments(nSeg); 656 ps = pps; 657 } 658 else if(shape == MeshShape::realWorldLogVol) 659 { 660 ed << "Passing cell flux for real world volume is not yet supported. " 661 "Command ignored."; 662 command->CommandFailed(ed); 663 return; 664 } 665 else if(shape == MeshShape::probe) 666 { 667 ps = new G4PSPassageCellFlux(token[0]); 668 } 669 ps->SetUnit(token[1]); 670 mesh->SetPrimitiveScorer(ps); 671 } 672 } 673 else if(command == qeDepCmd) 674 { 675 if(CheckMeshPS(mesh, token[0], command)) 676 { 677 G4PSEnergyDeposit* ps = nullptr; 678 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 679 { 680 ps = new G4PSEnergyDeposit(token[0], mesh->GetCopyNumberLevel()); 681 } 682 else 683 { 684 ps = new G4PSEnergyDeposit3D(token[0]); 685 } 686 ps->SetUnit(token[1]); 687 mesh->SetPrimitiveScorer(ps); 688 } 689 } 690 else if(command == qdoseDepCmd) 691 { 692 if(CheckMeshPS(mesh, token[0], command)) 693 { 694 G4PSDoseDeposit* ps = nullptr; 695 if(shape == MeshShape::box) 696 { 697 ps = new G4PSDoseDeposit3D(token[0]); 698 } 699 else if(shape == MeshShape::cylinder) 700 { 701 auto pps = 702 new G4PSDoseDepositForCylinder3D(token[0]); 703 pps->SetUnit(token[1]); 704 pps->SetCylinderSize(mesh->GetSize(),mesh->GetStartAngle(),mesh->GetAngleSpan()); 705 G4int nSeg[3]; 706 mesh->GetNumberOfSegments(nSeg); 707 pps->SetNumberOfSegments(nSeg); 708 ps = pps; 709 } 710 else if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 711 { 712 ps = new G4PSDoseDeposit(token[0], mesh->GetCopyNumberLevel()); 713 } 714 ps->SetUnit(token[1]); 715 mesh->SetPrimitiveScorer(ps); 716 } 717 } 718 else if(command == qnOfStepCmd) 719 { 720 if(CheckMeshPS(mesh, token[0], command)) 721 { 722 G4PSNofStep* ps = nullptr; 723 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 724 { 725 ps = new G4PSNofStep(token[0], mesh->GetCopyNumberLevel()); 726 } 727 else 728 { 729 ps = new G4PSNofStep3D(token[0]); 730 } 731 ps->SetBoundaryFlag(StoB(token[1])); 732 mesh->SetPrimitiveScorer(ps); 733 } 734 } 735 else if(command == qnOfSecondaryCmd) 736 { 737 if(CheckMeshPS(mesh, token[0], command)) 738 { 739 G4PSNofSecondary* ps = nullptr; 740 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 741 { 742 ps = new G4PSNofSecondary(token[0], mesh->GetCopyNumberLevel()); 743 } 744 else 745 { 746 ps = new G4PSNofSecondary3D(token[0]); 747 } 748 mesh->SetPrimitiveScorer(ps); 749 } 750 } 751 else if(command == qTrackLengthCmd) 752 { 753 if(CheckMeshPS(mesh, token[0], command)) 754 { 755 G4PSTrackLength* ps = nullptr; 756 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 757 { 758 ps = new G4PSTrackLength(token[0], mesh->GetCopyNumberLevel()); 759 } 760 else 761 { 762 ps = new G4PSTrackLength3D(token[0]); 763 } 764 ps->Weighted(StoB(token[1])); 765 ps->MultiplyKineticEnergy(StoB(token[2])); 766 ps->DivideByVelocity(StoB(token[3])); 767 ps->SetUnit(token[4]); 768 mesh->SetPrimitiveScorer(ps); 769 } 770 } 771 else if(command == qPassCellCurrCmd) 772 { 773 if(CheckMeshPS(mesh, token[0], command)) 774 { 775 G4PSPassageCellCurrent* ps = nullptr; 776 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 777 { 778 ps = new G4PSPassageCellCurrent(token[0], mesh->GetCopyNumberLevel()); 779 } 780 else 781 { 782 ps = new G4PSPassageCellCurrent3D(token[0]); 783 } 784 ps->Weighted(StoB(token[1])); 785 mesh->SetPrimitiveScorer(ps); 786 } 787 } 788 else if(command == qPassTrackLengthCmd) 789 { 790 if(CheckMeshPS(mesh, token[0], command)) 791 { 792 G4PSPassageTrackLength* ps = nullptr; 793 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 794 { 795 ps = new G4PSPassageTrackLength(token[0], mesh->GetCopyNumberLevel()); 796 } 797 else 798 { 799 ps = new G4PSPassageTrackLength3D(token[0]); 800 } 801 ps->Weighted(StoB(token[1])); 802 ps->SetUnit(token[2]); 803 mesh->SetPrimitiveScorer(ps); 804 } 805 } 806 else if(command == qFlatSurfCurrCmd) 807 { 808 if(CheckMeshPS(mesh, token[0], command)) 809 { 810 G4PSFlatSurfaceCurrent* ps = nullptr; 811 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 812 { 813 ps = new G4PSFlatSurfaceCurrent(token[0], StoI(token[1]), 814 mesh->GetCopyNumberLevel()); 815 } 816 else 817 { 818 ps = new G4PSFlatSurfaceCurrent3D(token[0], StoI(token[1])); 819 } 820 ps->Weighted(StoB(token[2])); 821 ps->DivideByArea(StoB(token[3])); 822 if(StoB(token[3])) 823 { 824 ps->SetUnit(token[4]); 825 } 826 else 827 { 828 ps->SetUnit(""); 829 } 830 mesh->SetPrimitiveScorer(ps); 831 } 832 } 833 else if(command == qFlatSurfFluxCmd) 834 { 835 if(CheckMeshPS(mesh, token[0], command)) 836 { 837 G4PSFlatSurfaceFlux* ps = nullptr; 838 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 839 { 840 ps = new G4PSFlatSurfaceFlux(token[0], StoI(token[1]), 841 mesh->GetCopyNumberLevel()); 842 } 843 else 844 { 845 ps = new G4PSFlatSurfaceFlux3D(token[0], StoI(token[1])); 846 } 847 ps->Weighted(StoB(token[2])); 848 ps->DivideByArea(StoB(token[3])); 849 if(StoB(token[3])) 850 { 851 ps->SetUnit(token[4]); 852 } 853 else 854 { 855 ps->SetUnit(""); 856 } 857 mesh->SetPrimitiveScorer(ps); 858 } 859 } 860 else if(command == qVolFluxCmd) 861 { 862 if(CheckMeshPS(mesh, token[0], command)) 863 { 864 G4PSVolumeFlux* ps = nullptr; 865 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 866 { 867 ps = new G4PSVolumeFlux(token[0], StoI(token[2]), 868 mesh->GetCopyNumberLevel()); 869 } 870 else 871 { 872 ps = new G4PSVolumeFlux3D(token[0], StoI(token[2])); 873 } 874 ps->SetDivCos(StoI(token[1]) != 0); 875 mesh->SetPrimitiveScorer(ps); 876 } 877 } 878 else if(command == qNofCollisionCmd) 879 { 880 if(CheckMeshPS(mesh, token[0], command)) 881 { 882 G4PSNofCollision* ps = nullptr; 883 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 884 { 885 ps = new G4PSNofCollision3D(token[0], mesh->GetCopyNumberLevel()); 886 } 887 else 888 { 889 ps = new G4PSNofCollision3D(token[0]); 890 } 891 ps->Weighted(StoB(token[1])); 892 mesh->SetPrimitiveScorer(ps); 893 } 894 } 895 else if(command == qPopulationCmd) 896 { 897 if(CheckMeshPS(mesh, token[0], command)) 898 { 899 G4PSPopulation* ps = nullptr; 900 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 901 { 902 ps = new G4PSPopulation(token[0], mesh->GetCopyNumberLevel()); 903 } 904 else 905 { 906 ps = new G4PSPopulation3D(token[0]); 907 } 908 ps->Weighted(StoB(token[1])); 909 mesh->SetPrimitiveScorer(ps); 910 } 911 } 912 else if(command == qTrackCountCmd) 913 { 914 if(CheckMeshPS(mesh, token[0], command)) 915 { 916 G4PSTrackCounter* ps = nullptr; 917 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 918 { 919 ps = new G4PSTrackCounter(token[0], StoI(token[1]), 920 mesh->GetCopyNumberLevel()); 921 } 922 else 923 { 924 ps = new G4PSTrackCounter3D(token[0], StoI(token[1])); 925 } 926 ps->Weighted(StoB(token[2])); 927 mesh->SetPrimitiveScorer(ps); 928 } 929 } 930 else if(command == qTerminationCmd) 931 { 932 if(CheckMeshPS(mesh, token[0], command)) 933 { 934 G4PSTermination* ps = nullptr; 935 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 936 { 937 ps = new G4PSTermination(token[0], mesh->GetCopyNumberLevel()); 938 } 939 else 940 { 941 ps = new G4PSTermination3D(token[0]); 942 } 943 ps->Weighted(StoB(token[1])); 944 mesh->SetPrimitiveScorer(ps); 945 } 946 } 947 else if(command == qMinKinEAtGeneCmd) 948 { 949 if(CheckMeshPS(mesh, token[0], command)) 950 { 951 G4PSMinKinEAtGeneration* ps = nullptr; 952 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 953 { 954 ps = new G4PSMinKinEAtGeneration(token[0], mesh->GetCopyNumberLevel()); 955 } 956 else 957 { 958 ps = new G4PSMinKinEAtGeneration3D(token[0]); 959 } 960 ps->SetUnit(token[1]); 961 mesh->SetPrimitiveScorer(ps); 962 } 963 } 964 else if(command == qStepCheckerCmd) 965 { 966 if(CheckMeshPS(mesh, token[0], command)) 967 { 968 G4PSStepChecker* ps = nullptr; 969 if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe) 970 { 971 ps = new G4PSStepChecker(token[0], mesh->GetCopyNumberLevel()); 972 } 973 else 974 { 975 ps = new G4PSStepChecker3D(token[0]); 976 } 977 mesh->SetPrimitiveScorer(ps); 978 } 979 980 // 981 // Filters 982 // 983 } 984 else if(command == fchargedCmd) 985 { 986 if(!mesh->IsCurrentPrimitiveScorerNull()) 987 { 988 mesh->SetFilter(new G4SDChargedFilter(token[0])); 989 } 990 else 991 { 992 ed << "WARNING[" << fchargedCmd->GetCommandPath() 993 << "] : Current quantity is not set. Set or touch a quantity first."; 994 command->CommandFailed(ed); 995 } 996 } 997 else if(command == fneutralCmd) 998 { 999 if(!mesh->IsCurrentPrimitiveScorerNull()) 1000 { 1001 mesh->SetFilter(new G4SDNeutralFilter(token[0])); 1002 } 1003 else 1004 { 1005 ed << "WARNING[" << fneutralCmd->GetCommandPath() 1006 << "] : Current quantity is not set. Set or touch a quantity first."; 1007 command->CommandFailed(ed); 1008 } 1009 } 1010 else if(command == fkinECmd) 1011 { 1012 if(!mesh->IsCurrentPrimitiveScorerNull()) 1013 { 1014 G4String& name = token[0]; 1015 G4double elow = StoD(token[1]); 1016 G4double ehigh = StoD(token[2]); 1017 G4double unitVal = G4UnitDefinition::GetValueOf(token[3]); 1018 mesh->SetFilter( 1019 new G4SDKineticEnergyFilter(name, elow * unitVal, ehigh * unitVal)); 1020 } 1021 else 1022 { 1023 ed << "WARNING[" << fkinECmd->GetCommandPath() 1024 << "] : Current quantity is not set. Set or touch a quantity first."; 1025 command->CommandFailed(ed); 1026 } 1027 } 1028 else if(command == fparticleKinECmd) 1029 { 1030 if(!mesh->IsCurrentPrimitiveScorerNull()) 1031 { 1032 FParticleWithEnergyCommand(mesh, token); 1033 } 1034 else 1035 { 1036 ed << "WARNING[" << fparticleKinECmd->GetCommandPath() 1037 << "] : Current quantity is not set. Set or touch a quantity first."; 1038 command->CommandFailed(ed); 1039 } 1040 } 1041 else if(command == fparticleCmd) 1042 { 1043 if(!mesh->IsCurrentPrimitiveScorerNull()) 1044 { 1045 FParticleCommand(mesh, token); 1046 } 1047 else 1048 { 1049 ed << "WARNING[" << fparticleCmd->GetCommandPath() 1050 << "] : Current quantity is not set. Set or touch a quantity first."; 1051 command->CommandFailed(ed); 1052 } 1053 } 1054 } 1055 1056 G4String G4ScoreQuantityMessenger::GetCurrentValue(G4UIcommand* /*command*/) 1057 { 1058 G4String val; 1059 1060 return val; 1061 } 1062 1063 void G4ScoreQuantityMessenger::FillTokenVec(const G4String& newValues, 1064 G4TokenVec& token) 1065 { 1066 G4Tokenizer next(newValues); 1067 G4String val; 1068 while(!(val = next()).empty()) 1069 { // Loop checking 12.18.2015 M.Asai 1070 token.push_back(val); 1071 } 1072 } 1073 1074 void G4ScoreQuantityMessenger::FParticleCommand(G4VScoringMesh* mesh, 1075 G4TokenVec& token) 1076 { 1077 // 1078 // Filter name 1079 G4String name = token[0]; 1080 // 1081 // particle list 1082 std::vector<G4String> pnames; 1083 for(G4int i = 1; i < (G4int) token.size(); i++) 1084 { 1085 pnames.push_back(token[i]); 1086 } 1087 // 1088 // Attach Filter 1089 mesh->SetFilter(new G4SDParticleFilter(name, pnames)); 1090 } 1091 1092 void G4ScoreQuantityMessenger::FParticleWithEnergyCommand(G4VScoringMesh* mesh, 1093 G4TokenVec& token) 1094 { 1095 G4String& name = token[0]; 1096 G4double elow = StoD(token[1]); 1097 G4double ehigh = StoD(token[2]); 1098 G4double unitVal = G4UnitDefinition::GetValueOf(token[3]); 1099 auto filter = 1100 new G4SDParticleWithEnergyFilter(name, elow * unitVal, ehigh * unitVal); 1101 for(G4int i = 4; i < (G4int) token.size(); i++) 1102 { 1103 filter->add(token[i]); 1104 } 1105 mesh->SetFilter(filter); 1106 } 1107 1108 G4bool G4ScoreQuantityMessenger::CheckMeshPS(G4VScoringMesh* mesh, 1109 const G4String& psname, 1110 G4UIcommand* command) 1111 { 1112 if(!mesh->FindPrimitiveScorer(psname)) 1113 { 1114 return true; 1115 } 1116 1117 G4ExceptionDescription ed; 1118 ed << "WARNING[" << qTouchCmd->GetCommandPath() << "] : Quantity name, \"" 1119 << psname << "\", is already existing."; 1120 command->CommandFailed(ed); 1121 mesh->SetNullToCurrentPrimitiveScorer(); 1122 return false; 1123 } 1124