source: trunk/source/digits_hits/utils/src/G4ScoreQuantityMessenger.cc@ 1347

Last change on this file since 1347 was 1340, checked in by garnier, 15 years ago

update ti head
File size: 16.8 KB
Line 
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//
27// $Id: G4ScoreQuantityMessenger.cc,v 1.10 2010/11/03 08:28:42 taso Exp $
28// GEANT4 tag $Name: $
29//
30// ---------------------------------------------------------------------
31// Modifications
32// 08-Oct-2010 T.Aso remove unit of G4PSPassageCellCurrent.
33// ---------------------------------------------------------------------
34
35#include "G4ScoreQuantityMessenger.hh"
36#include "G4ScoringManager.hh"
37#include "G4VScoringMesh.hh"
38
39#include "G4PSCellCharge3D.hh"
40#include "G4PSCellFlux3D.hh"
41#include "G4PSPassageCellFlux3D.hh"
42#include "G4PSEnergyDeposit3D.hh"
43#include "G4PSDoseDeposit3D.hh"
44#include "G4PSNofStep3D.hh"
45#include "G4PSNofSecondary3D.hh"
46//
47#include "G4PSTrackLength3D.hh"
48#include "G4PSPassageCellCurrent3D.hh"
49#include "G4PSPassageTrackLength3D.hh"
50#include "G4PSFlatSurfaceCurrent3D.hh"
51#include "G4PSFlatSurfaceFlux3D.hh"
52#include "G4PSSphereSurfaceCurrent3D.hh"
53#include "G4PSSphereSurfaceFlux3D.hh"
54#include "G4PSCylinderSurfaceCurrent3D.hh"
55#include "G4PSCylinderSurfaceFlux3D.hh"
56#include "G4PSNofCollision3D.hh"
57#include "G4PSPopulation3D.hh"
58#include "G4PSTrackCounter3D.hh"
59#include "G4PSTermination3D.hh"
60#include "G4PSMinKinEAtGeneration3D.hh"
61
62#include "G4SDChargedFilter.hh"
63#include "G4SDNeutralFilter.hh"
64#include "G4SDKineticEnergyFilter.hh"
65#include "G4SDParticleFilter.hh"
66#include "G4SDParticleWithEnergyFilter.hh"
67
68#include "G4UIdirectory.hh"
69#include "G4UIcmdWithoutParameter.hh"
70#include "G4UIcmdWithAnInteger.hh"
71#include "G4UIcmdWithAString.hh"
72#include "G4UIcmdWithABool.hh"
73#include "G4UIcmdWithADoubleAndUnit.hh"
74#include "G4UIcmdWith3VectorAndUnit.hh"
75#include "G4UIcommand.hh"
76#include "G4Tokenizer.hh"
77#include "G4UnitsTable.hh"
78
79G4ScoreQuantityMessenger::G4ScoreQuantityMessenger(G4ScoringManager* SManager)
80:fSMan(SManager)
81{
82 QuantityCommands();
83 FilterCommands();
84}
85
86void G4ScoreQuantityMessenger::FilterCommands()
87{
88 G4UIparameter* param;
89
90 //
91 // Filter commands
92 filterDir = new G4UIdirectory("/score/filter/");
93 filterDir->SetGuidance(" Scoring filter commands.");
94 //
95 fchargedCmd = new G4UIcmdWithAString("/score/filter/charged",this);
96 fchargedCmd->SetGuidance("Charged particle filter.");
97 fchargedCmd->SetParameterName("fname",false);
98 //
99 fneutralCmd = new G4UIcmdWithAString("/score/filter/neutral",this);
100 fneutralCmd->SetGuidance("Neutral particle filter.");
101 fneutralCmd->SetParameterName("fname",false);
102 //
103 fkinECmd = new G4UIcommand("/score/filter/kineticEnergy",this);
104 fkinECmd->SetGuidance("Kinetic energy filter.");
105 fkinECmd->SetGuidance("[usage] /score/filter/kineticEnergy fname Elow Ehigh unit");
106 fkinECmd->SetGuidance(" fname :(String) Filter Name ");
107 fkinECmd->SetGuidance(" Elow :(Double) Lower edge of kinetic energy");
108 fkinECmd->SetGuidance(" Ehigh :(Double) Higher edge of kinetic energy");
109 fkinECmd->SetGuidance(" unit :(String) unit of given kinetic energy");
110 param = new G4UIparameter("fname",'s',false);
111 fkinECmd->SetParameter(param);
112 param = new G4UIparameter("elow",'d',true);
113 param->SetDefaultValue("0.0");
114 fkinECmd->SetParameter(param);
115 param = new G4UIparameter("ehigh",'d',false);
116 fkinECmd->SetParameter(param);
117 G4String smax = DtoS(DBL_MAX);
118 param->SetDefaultValue(smax);
119 param = new G4UIparameter("unit",'s',false);
120 param->SetDefaultValue("keV");
121 fkinECmd->SetParameter(param);
122 //
123 fparticleCmd = new G4UIcommand("/score/filter/particle",this);
124 fparticleCmd->SetGuidance("Particle filter.");
125 fparticleCmd->SetGuidance("[usage] /score/filter/particle fname p0 .. pn");
126 fparticleCmd->SetGuidance(" fname :(String) Filter Name ");
127 fparticleCmd->SetGuidance(" p0 .. pn :(String) particle names");
128 param = new G4UIparameter("fname",'s',false);
129 fparticleCmd->SetParameter(param);
130 param = new G4UIparameter("particlelist",'s',false);
131 param->SetDefaultValue("");
132 fparticleCmd->SetParameter(param);
133 //
134 //
135 //
136 fparticleKinECmd = new G4UIcommand("/score/filter/particleWithKineticEnergy",this);
137 fparticleKinECmd->SetGuidance("Particle with kinetic energy filter.");
138 fparticleKinECmd->SetGuidance("[usage] /score/filter/particleWithKineticEnergy fname Elow Ehigh unit p0 .. pn");
139 fparticleKinECmd->SetGuidance(" fname :(String) Filter Name ");
140 fparticleKinECmd->SetGuidance(" Elow :(Double) Lower edge of kinetic energy");
141 fparticleKinECmd->SetGuidance(" Ehigh :(Double) Higher edge of kinetic energy");
142 fparticleKinECmd->SetGuidance(" unit :(String) unit of given kinetic energy");
143 fparticleKinECmd->SetGuidance(" p0 .. pn :(String) particle names");
144 param = new G4UIparameter("fname",'s',false);
145 fparticleKinECmd->SetParameter(param);
146 param = new G4UIparameter("elow",'d',false);
147 param->SetDefaultValue("0.0");
148 fparticleKinECmd->SetParameter(param);
149 param = new G4UIparameter("ehigh",'d',true);
150 param->SetDefaultValue(smax);
151 fparticleKinECmd->SetParameter(param);
152 param = new G4UIparameter("unit",'s',true);
153 param->SetDefaultValue("keV");
154 fparticleKinECmd->SetParameter(param);
155 param = new G4UIparameter("particlelist",'s',false);
156 param->SetDefaultValue("");
157 fparticleKinECmd->SetParameter(param);
158 //
159 //
160}
161
162G4ScoreQuantityMessenger::~G4ScoreQuantityMessenger()
163{
164 delete quantityDir;
165 delete qTouchCmd;
166 delete qGetUnitCmd;
167 delete qSetUnitCmd;
168
169 //
170 delete qCellChgCmd;
171 delete qCellFluxCmd;
172 delete qPassCellFluxCmd;
173 delete qeDepCmd;
174 delete qdoseDepCmd;
175 delete qnOfStepCmd;
176 delete qnOfSecondaryCmd;
177 //
178 delete qTrackLengthCmd;
179 delete qPassCellCurrCmd;
180 delete qPassTrackLengthCmd;
181 delete qFlatSurfCurrCmd;
182 delete qFlatSurfFluxCmd;
183// delete qSphereSurfCurrCmd;
184// delete qSphereSurfFluxCmd;
185// delete qCylSurfCurrCmd;
186// delete qCylSurfFluxCmd;
187 delete qNofCollisionCmd;
188 delete qPopulationCmd;
189 delete qTrackCountCmd;
190 delete qTerminationCmd;
191 delete qMinKinEAtGeneCmd;
192 //
193 delete filterDir;
194 delete fchargedCmd;
195 delete fneutralCmd;
196 delete fkinECmd;
197 delete fparticleCmd;
198 delete fparticleKinECmd;
199}
200
201void G4ScoreQuantityMessenger::SetNewValue(G4UIcommand * command,G4String newVal)
202{
203 //
204 // Get Current Mesh
205 //
206 G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
207 if(!mesh)
208 {
209 G4cerr << "ERROR : No mesh is currently open. Open/create a mesh first. Command ignored." << G4endl;
210 return;
211 }
212 // Tokens
213 G4TokenVec token;
214 FillTokenVec(newVal,token);
215 //
216 // Commands for Current Mesh
217 if(command==qTouchCmd) {
218 mesh->SetCurrentPrimitiveScorer(newVal);
219 } else if(command == qGetUnitCmd ){
220 G4cout << "Unit: "<< mesh->GetCurrentPSUnit() <<G4endl;
221 } else if(command == qSetUnitCmd ){
222 mesh->SetCurrentPSUnit(newVal);
223 } else if(command== qCellChgCmd) {
224 if ( CheckMeshPS(mesh,token[0]) ){
225 G4PSCellCharge3D* ps = new G4PSCellCharge3D(token[0]);
226 ps->SetUnit(token[1]);
227 mesh->SetPrimitiveScorer(ps);
228 }
229 } else if(command== qCellFluxCmd) {
230 if ( CheckMeshPS(mesh,token[0]) ){
231 G4PSCellFlux3D* ps = new G4PSCellFlux3D(token[0]);
232 ps->SetUnit(token[1]);
233 mesh->SetPrimitiveScorer(ps);
234 }
235 } else if(command== qPassCellFluxCmd) {
236 if ( CheckMeshPS(mesh,token[0]) ){
237 G4PSPassageCellFlux3D* ps = new G4PSPassageCellFlux3D(token[0]);
238 ps->SetUnit(token[1]);
239 mesh->SetPrimitiveScorer(ps);
240 }
241 } else if(command==qeDepCmd) {
242 if ( CheckMeshPS(mesh,token[0]) ){
243 G4PSEnergyDeposit3D* ps =new G4PSEnergyDeposit3D(token[0]);
244 ps->SetUnit(token[1]);
245 mesh->SetPrimitiveScorer(ps);
246 }
247 } else if(command== qdoseDepCmd) {
248 if ( CheckMeshPS(mesh,token[0]) ){
249 G4PSDoseDeposit3D* ps = new G4PSDoseDeposit3D(token[0]);
250 ps->SetUnit(token[1]);
251 mesh->SetPrimitiveScorer(ps);
252 }
253 } else if(command== qnOfStepCmd) {
254 if ( CheckMeshPS(mesh,token[0]) ){
255 G4PSNofStep3D* ps = new G4PSNofStep3D(token[0]);
256 mesh->SetPrimitiveScorer(ps);
257 }
258 } else if(command== qnOfSecondaryCmd) {
259 if ( CheckMeshPS(mesh,token[0]) ){
260 G4PSNofSecondary3D* ps =new G4PSNofSecondary3D(token[0]);
261 mesh->SetPrimitiveScorer(ps);
262 }
263 } else if(command== qTrackLengthCmd) {
264 if ( CheckMeshPS(mesh,token[0]) ){
265 G4PSTrackLength3D* ps = new G4PSTrackLength3D(token[0]);
266 ps->Weighted(StoB(token[1]));
267 ps->MultiplyKineticEnergy(StoB(token[2]));
268 ps->DivideByVelocity(StoB(token[3]));
269 ps->SetUnit(token[4]);
270 mesh->SetPrimitiveScorer(ps);
271 }
272 } else if(command== qPassCellCurrCmd){
273 if( CheckMeshPS(mesh,token[0]) ) {
274 G4PSPassageCellCurrent* ps = new G4PSPassageCellCurrent3D(token[0]);
275 ps->Weighted(StoB(token[1]));
276 //ps->SetUnit(token[2]);
277 mesh->SetPrimitiveScorer(ps);
278 }
279 } else if(command== qPassTrackLengthCmd){
280 if( CheckMeshPS(mesh,token[0]) ) {
281 G4PSPassageTrackLength* ps = new G4PSPassageTrackLength3D(token[0]);
282 ps->Weighted(StoB(token[1]));
283 mesh->SetPrimitiveScorer(ps);
284 }
285 } else if(command== qFlatSurfCurrCmd){
286 if( CheckMeshPS(mesh,token[0])) {
287 G4PSFlatSurfaceCurrent3D* ps =
288 new G4PSFlatSurfaceCurrent3D(token[0],StoI(token[1]));
289 ps->Weighted(StoB(token[2]));
290 ps->DivideByArea(StoB(token[3]));
291 ps->SetUnit(token[4]);
292 mesh->SetPrimitiveScorer(ps);
293 }
294 } else if(command== qFlatSurfFluxCmd){
295 if( CheckMeshPS(mesh, token[0] )) {
296 G4PSFlatSurfaceFlux3D* ps = new G4PSFlatSurfaceFlux3D(token[0],StoI(token[1]));
297 ps->SetUnit(token[2]);
298 mesh->SetPrimitiveScorer(ps);
299 }
300// } else if(command== qSphereSurfCurrCmd){
301// if( CheckMeshPS(mesh, token[0] )) {
302// G4PSSphereSurfaceCurrent3D* ps =
303// new G4PSSphereSurfaceCurrent3D(token[0],StoI(token[1]));
304// ps->Weighted(StoB(token[2]));
305// ps->DivideByArea(StoB(token[3]));
306// ps->SetUnit(token[4]);
307// mesh->SetPrimitiveScorer(ps);
308// }
309// } else if(command== qSphereSurfFluxCmd){
310// if( CheckMeshPS(mesh,token[0])) {
311// G4PSSphereSurfaceFlux3D* ps = new G4PSSphereSurfaceFlux3D(token[0], StoI(token[1]));
312// ps->SetUnit(token[2]);
313// mesh->SetPrimitiveScorer(ps);
314// }
315// } else if(command== qCylSurfCurrCmd){
316// if( CheckMeshPS(mesh, token[0] ) ) {
317// G4PSCylinderSurfaceCurrent3D* ps =
318// new G4PSCylinderSurfaceCurrent3D(token[0],StoI(token[1]));
319// ps->Weighted(StoB(token[2]));
320// ps->DivideByArea(StoB(token[3]));
321// ps->SetUnit(token[4]);
322// mesh->SetPrimitiveScorer(ps);
323// }
324// } else if(command== qCylSurfFluxCmd){
325// if( CheckMeshPS(mesh, token[0] ) {
326// G4PSCylinerSurfaceFlux3D* ps =new G4PSCylinderSurfaceFlux3D(token[0], StoI(token[1]));
327// ps->SetUnit(token[2]);
328// mesh->SetPrimitiveScorer(ps);
329// }
330 } else if(command== qNofCollisionCmd){
331 if( CheckMeshPS(mesh,token[0])) {
332 G4PSNofCollision3D* ps =new G4PSNofCollision3D(token[0]);
333 ps->Weighted(StoB(token[1]));
334 mesh->SetPrimitiveScorer(ps);
335 }
336 } else if(command== qPopulationCmd){
337 if( CheckMeshPS(mesh,token[0]) ) {
338 G4PSPopulation3D* ps =new G4PSPopulation3D(token[0]);
339 ps->Weighted(StoB(token[1]));
340 mesh->SetPrimitiveScorer(ps);
341 }
342 } else if(command== qTrackCountCmd){
343 if( CheckMeshPS(mesh,token[0])) {
344 G4PSTrackCounter3D* ps =new G4PSTrackCounter3D(token[0],StoI(token[1]));
345 mesh->SetPrimitiveScorer(ps);
346 }
347 } else if(command== qTerminationCmd){
348 if( CheckMeshPS(mesh,token[0])) {
349 G4PSTermination3D* ps =new G4PSTermination3D(token[0]);
350 ps->Weighted(StoB(token[1]));
351 mesh->SetPrimitiveScorer(ps);
352 }
353
354 } else if(command== qMinKinEAtGeneCmd){
355 if( CheckMeshPS(mesh,token[0]) ){
356 G4PSMinKinEAtGeneration3D* ps =new G4PSMinKinEAtGeneration3D(token[0]);
357 ps->SetUnit(token[1]);
358 mesh->SetPrimitiveScorer(ps);
359 }
360
361 //
362 // Filters
363 //
364 }else if(command== fchargedCmd){
365 if(!mesh->IsCurrentPrimitiveScorerNull()) {
366 mesh->SetFilter(new G4SDChargedFilter(token[0]));
367 } else {
368 G4cout << "WARNING[" << fchargedCmd->GetCommandPath()
369 << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
370 }
371 }else if(command== fneutralCmd){
372 if(!mesh->IsCurrentPrimitiveScorerNull()) {
373 mesh->SetFilter(new G4SDNeutralFilter(token[0]));
374 } else {
375 G4cout << "WARNING[" << fneutralCmd->GetCommandPath()
376 << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
377 }
378 }else if(command== fkinECmd){
379 if(!mesh->IsCurrentPrimitiveScorerNull()) {
380 G4String& name = token[0];
381 G4double elow = StoD(token[1]);
382 G4double ehigh = StoD(token[2]);
383 mesh->SetFilter(new G4SDKineticEnergyFilter(name,elow,ehigh));
384 } else {
385 G4cout << "WARNING[" << fkinECmd->GetCommandPath()
386 << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
387 }
388 }else if(command== fparticleKinECmd){
389 if(!mesh->IsCurrentPrimitiveScorerNull()) {
390 FParticleWithEnergyCommand(mesh,token);
391 } else {
392 G4cout << "WARNING[" << fparticleKinECmd->GetCommandPath()
393 << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
394 }
395 } else if(command==fparticleCmd) {
396 if(!mesh->IsCurrentPrimitiveScorerNull()) {
397 FParticleCommand(mesh,token);
398 } else {
399 G4cout << "WARNING[" << fparticleCmd->GetCommandPath()
400 << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
401 }
402 }
403}
404
405G4String G4ScoreQuantityMessenger::GetCurrentValue(G4UIcommand * /*command*/)
406{
407 G4String val;
408
409 return val;
410}
411
412void G4ScoreQuantityMessenger::FillTokenVec(G4String newValues, G4TokenVec& token){
413
414 G4Tokenizer next(newValues);
415 G4String val;
416 while ( !(val = next()).isNull() ) {
417 token.push_back(val);
418 }
419}
420
421
422void G4ScoreQuantityMessenger::FParticleCommand(G4VScoringMesh* mesh, G4TokenVec& token){
423 //
424 // Filter name
425 G4String name = token[0];
426 //
427 // particle list
428 std::vector<G4String> pnames;
429 for ( G4int i = 1; i<(G4int)token.size(); i++){
430 pnames.push_back(token[i]);
431 }
432 //
433 // Attach Filter
434 mesh->SetFilter(new G4SDParticleFilter(name,pnames));
435}
436
437void G4ScoreQuantityMessenger::FParticleWithEnergyCommand(G4VScoringMesh* mesh,G4TokenVec& token){
438 G4String& name = token[0];
439 G4double elow = StoD(token[1]);
440 G4double ehigh= StoD(token[2]);
441 G4double unitVal = G4UnitDefinition::GetValueOf(token[3]);
442 G4SDParticleWithEnergyFilter* filter =
443 new G4SDParticleWithEnergyFilter(name,elow*unitVal,ehigh*unitVal);
444 for ( G4int i = 4; i < (G4int)token.size(); i++){
445 filter->add(token[i]);
446 }
447 mesh->SetFilter(filter);
448}
449
450G4bool G4ScoreQuantityMessenger::CheckMeshPS(G4VScoringMesh* mesh, G4String& psname){
451 if(!mesh->FindPrimitiveScorer(psname)) {
452 return true;
453 } else {
454 G4cout << "WARNING[" << qTouchCmd->GetCommandPath()
455 << "] : Quantity name, \"" << psname << "\", is already existing." << G4endl;
456 mesh->SetNullToCurrentPrimitiveScorer();
457 return false;
458 }
459}
Note: See TracBrowser for help on using the repository browser.