Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
G4ScoringMessenger Class Reference

#include <G4ScoringMessenger.hh>

+ Inheritance diagram for G4ScoringMessenger:

Public Member Functions

 G4ScoringMessenger (G4ScoringManager *SManager)
 
 ~G4ScoringMessenger ()
 
void SetNewValue (G4UIcommand *command, G4String newValues)
 
G4String GetCurrentValue (G4UIcommand *command)
 
- Public Member Functions inherited from G4UImessenger
 G4UImessenger ()
 
 G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
virtual ~G4UImessenger ()
 
virtual G4String GetCurrentValue (G4UIcommand *command)
 
virtual void SetNewValue (G4UIcommand *command, G4String newValue)
 
G4bool operator== (const G4UImessenger &messenger) const
 
G4bool operator!= (const G4UImessenger &messenger) const
 
G4bool CommandsShouldBeInMaster () const
 

Protected Member Functions

void FillTokenVec (G4String newValues, G4TokenVec &token)
 
void MeshBinCommand (G4VScoringMesh *mesh, G4TokenVec &token)
 
void Fill1D (G4UIcommand *cmd, G4String newValues)
 
- Protected Member Functions inherited from G4UImessenger
G4String ItoS (G4int i)
 
G4String DtoS (G4double a)
 
G4String BtoS (G4bool b)
 
G4int StoI (G4String s)
 
G4long StoL (G4String s)
 
G4double StoD (G4String s)
 
G4bool StoB (G4String s)
 
void AddUIcommand (G4UIcommand *newCommand)
 
void CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
template<typename T >
T * CreateCommand (const G4String &cname, const G4String &dsc)
 

Additional Inherited Members

- Protected Attributes inherited from G4UImessenger
G4UIdirectory * baseDir = nullptr
 
G4String baseDirName = ""
 
G4bool commandsShouldBeInMaster = false
 

Detailed Description

Definition at line 62 of file G4ScoringMessenger.hh.

Constructor & Destructor Documentation

◆ G4ScoringMessenger()

G4ScoringMessenger::G4ScoringMessenger ( G4ScoringManager *  SManager)

Definition at line 50 of file G4ScoringMessenger.cc.

51:fSMan(SManager)
52{
53 G4UIparameter* param = nullptr;
54
55 scoreDir = new G4UIdirectory("/score/");
56 scoreDir->SetGuidance("Interactive scoring commands.");
57
58 listCmd = new G4UIcmdWithoutParameter("/score/list",this);
59 listCmd->SetGuidance("List scoring worlds.");
60
61 dumpCmd = new G4UIcmdWithoutParameter("/score/dump",this);
62 dumpCmd->SetGuidance("Dump results of scorers.");
63
64 verboseCmd = new G4UIcmdWithAnInteger("/score/verbose",this);
65 verboseCmd->SetGuidance("Verbosity.");
66 verboseCmd->SetGuidance(" 0) errors or warnings,");
67 verboseCmd->SetGuidance(" 1) information with 0)");
68
69 meshCreateDir = new G4UIdirectory("/score/create/");
70 meshCreateDir->SetGuidance(" Mesh creation commands.");
71 //
72 // Mesh commands
73 meshBoxCreateCmd = new G4UIcmdWithAString("/score/create/boxMesh",this);
74 meshBoxCreateCmd->SetGuidance("Create scoring box mesh.");
75 meshBoxCreateCmd->SetParameterName("MeshName",false);
76 //
77 meshCylinderCreateCmd = new G4UIcmdWithAString("/score/create/cylinderMesh",this);
78 meshCylinderCreateCmd->SetGuidance("Create scoring mesh.");
79 meshCylinderCreateCmd->SetParameterName("MeshName",false);
80 //
81// meshSphereCreateCmd = new G4UIcmdWithAString("/score/create/sphereMesh",this);
82// meshSphereCreateCmd->SetGuidance("Create scoring mesh.");
83// meshSphereCreateCmd->SetParameterName("MeshName",false);
84 //
85 meshRWLogVolCreateCmd = new G4UIcommand("/score/create/realWorldLogVol",this);
86 meshRWLogVolCreateCmd->SetGuidance("Define scorers to a logical volume defined in the real world.");
87 meshRWLogVolCreateCmd->SetGuidance(" - Name of the specified logical volume is used as the mesh name.");
88 meshRWLogVolCreateCmd->SetGuidance(" - /score/mesh commands do not affect for this mesh.");
89 meshRWLogVolCreateCmd->SetGuidance(" - If copyNumberLevel is set, the copy number of that-level higher");
90 meshRWLogVolCreateCmd->SetGuidance(" in the geometrical hierarchy is used as the index.");
91 param = new G4UIparameter("logVol",'s',false);
92 meshRWLogVolCreateCmd->SetParameter(param);
93 param = new G4UIparameter("copyNumberLevel",'i',true);
94 param->SetParameterRange("copyNumberLevel>=0");
95 param->SetDefaultValue(0);
96 meshRWLogVolCreateCmd->SetParameter(param);
97 //
98 probeCreateCmd = new G4UIcommand("/score/create/probe",this);
99 probeCreateCmd->SetGuidance("Define scoring probe.");
100 probeCreateCmd->SetGuidance(" halfSize defines the half-width of the probing cube.");
101 param = new G4UIparameter("pname",'s',false);
102 probeCreateCmd->SetParameter(param);
103 param = new G4UIparameter("halfSize",'d',false);
104 probeCreateCmd->SetParameter(param);
105 param = new G4UIparameter("unit",'s',true);
106 param->SetDefaultUnit("mm");
107 probeCreateCmd->SetParameter(param);
108 param = new G4UIparameter("checkOverlap",'b',true);
109 param->SetDefaultValue(false);
110 probeCreateCmd->SetParameter(param);
111 //
112 meshOpnCmd = new G4UIcmdWithAString("/score/open",this);
113 meshOpnCmd->SetGuidance("Open scoring mesh.");
114 meshOpnCmd->SetParameterName("MeshName",false);
115 //
116 meshClsCmd = new G4UIcmdWithoutParameter("/score/close",this);
117 meshClsCmd->SetGuidance("Close scoring mesh.");
118 //
119// meshActCmd = new G4UIcmdWithABool("/score/mesh/activate",this);
120// meshActCmd->SetGuidance("Activate scoring mesh.");
121// meshActCmd->SetParameterName("MeshName",false);
122 //
123 meshDir = new G4UIdirectory("/score/mesh/");
124 meshDir->SetGuidance(" Mesh processing commands.");
125 //
126 mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/boxSize",this);
127 mBoxSizeCmd->SetGuidance("Define size of the scoring mesh.");
128 mBoxSizeCmd->SetGuidance("Dx Dy Dz unit");
129 mBoxSizeCmd->SetParameterName("Di","Dj","Dk",false,false);
130 mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>0.");
131 mBoxSizeCmd->SetDefaultUnit("mm");
132 //
133 mCylinderSizeCmd = new G4UIcommand("/score/mesh/cylinderSize",this);
134 mCylinderSizeCmd->SetGuidance("Define size of the scoring mesh.");
135 mCylinderSizeCmd->SetGuidance("R Dz unit");
136 param = new G4UIparameter("R",'d',false);
137 param->SetParameterRange("R>0");
138 mCylinderSizeCmd->SetParameter(param);
139 param = new G4UIparameter("Dz",'d',false);
140 param->SetParameterRange("Dz>0");
141 mCylinderSizeCmd->SetParameter(param);
142 param = new G4UIparameter("unit",'s',true);
143 param->SetDefaultUnit("mm");
144 mCylinderSizeCmd->SetParameter(param);
145 //
146 // Division command
147 mBinCmd = new G4UIcommand("/score/mesh/nBin",this);
148 mBinCmd->SetGuidance("Define segments of the scoring mesh.");
149 mBinCmd->SetGuidance("[usage] /score/mesh/nBin");
150 mBinCmd->SetGuidance(" In case of boxMesh, parameters are given in");
151 mBinCmd->SetGuidance(" Ni :(int) Number of bins i (in x-axis) ");
152 mBinCmd->SetGuidance(" Nj :(int) Number of bins j (in y-axis) ");
153 mBinCmd->SetGuidance(" Nk :(int) Number of bins k (in z-axis) ");
154 mBinCmd->SetGuidance(" In case of cylinderMesh, parameters are given in");
155 mBinCmd->SetGuidance(" Nr :(int) Number of bins in radial axis ");
156 mBinCmd->SetGuidance(" Nz :(int) Number of bins in z axis ");
157 mBinCmd->SetGuidance(" Nphi:(int) Number of bins in phi axis ");
158 //mBinCmd->SetGuidance(" Axis:(int) Axis of division ");
159// mBinCmd->SetGuidance(" P1..Pn-1 :(double) \"paramter from P1 to Pn-1 for division.\"");
160 param = new G4UIparameter("Ni",'i',false);
161 param->SetDefaultValue("1");
162 param->SetParameterRange("Ni>0");
163 mBinCmd->SetParameter(param);
164 param = new G4UIparameter("Nj",'i',false);
165 param->SetDefaultValue("1");
166 param->SetParameterRange("Nj>0");
167 mBinCmd->SetParameter(param);
168 param = new G4UIparameter("Nk",'i',false);
169 param->SetDefaultValue("1");
170 mBinCmd->SetParameter(param);
171 param->SetParameterRange("Nk>0");
172 //param = new G4UIparameter("Axis",'i',true);
173 //param->SetDefaultValue("3");
174 //mBinCmd->SetParameter(param);
175 //
176 // Placement command
177 mTransDir = new G4UIdirectory("/score/mesh/translate/");
178 mTransDir->SetGuidance("Mesh translation commands.");
179 //
180 mTResetCmd = new G4UIcmdWithoutParameter("/score/mesh/translate/reset",this);
181 mTResetCmd->SetGuidance("Reset translated position of the scoring mesh.");
182 //
183 mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/translate/xyz",this);
184 mTXyzCmd->SetGuidance("Translate the scoring mesh.");
185 mTXyzCmd->SetParameterName("X","Y","Z",false,false);
186 mTXyzCmd->SetDefaultUnit("mm");
187 //
188 mRotDir = new G4UIdirectory("/score/mesh/rotate/");
189 mRotDir->SetGuidance("Mesh rotation commands.");
190 //
191 //mRResetCmd = new G4UIcmdWithoutParameter("/score/mesh/rotate/reset",this);
192 //mRResetCmd->SetGuidance("Reset rotation angles of the scoring mesh.");
193 //
194 mRotXCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateX",this);
195 mRotXCmd->SetGuidance("Rotate the scoring mesh in X axis.");
196 mRotXCmd->SetParameterName("Rx",false);
197 mRotXCmd->SetDefaultUnit("deg");
198 //
199 mRotYCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateY",this);
200 mRotYCmd->SetGuidance("Rotate the scoring mesh in Y axis.");
201 mRotYCmd->SetParameterName("Ry",false);
202 mRotYCmd->SetDefaultUnit("deg");
203 //
204 mRotZCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateZ",this);
205 mRotZCmd->SetGuidance("Rotate the scoring mesh in Z axis.");
206 mRotZCmd->SetParameterName("Rz",false);
207 mRotZCmd->SetDefaultUnit("deg");
208 //
209 probeDir = new G4UIdirectory("/score/probe/");
210 probeDir->SetGuidance("Probe commands");
211
212 probeMatCmd = new G4UIcmdWithAString("/score/probe/material",this);
213 probeMatCmd->SetGuidance("Specify a material to the probe cube.");
214 probeMatCmd->SetGuidance("Material name has to be taken from G4NistManager.");
215 probeMatCmd->SetGuidance("Once this command is used, the specified material overlays the material in the mass geometry");
216 probeMatCmd->SetGuidance("with \"Layered Mass Geometry\" mechanism so that physics quantities such as energy deposition");
217 probeMatCmd->SetGuidance("or dose will be calculated with this material.");
218 probeMatCmd->SetGuidance("To switch-off this overlaying, use \"none\".");
219 probeMatCmd->SetParameterName("matName",true);
220 probeMatCmd->SetDefaultValue("none");
221
222 probeLocateCmd = new G4UIcmdWith3VectorAndUnit("/score/probe/locate",this);
223 probeLocateCmd->SetGuidance("Locate a probe in the global coordinate system.");
224 probeLocateCmd->SetParameterName("x","y","z",false);
225 probeLocateCmd->SetDefaultUnit("mm");
226
227 // Draw Scoring result
228 drawCmd = new G4UIcommand("/score/drawProjection",this);
229 drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
230 drawCmd->SetGuidance("Parameter <proj> specified which projection(s) to be drawn.");
231 drawCmd->SetGuidance(" 100 : xy-plane, 010 : yz-plane, 001 : zx-plane -- default 111");
232 drawCmd->SetGuidance(" 100 : N/A, 010 : z_phi-plane, 001 : r_phi-plane -- default 111");
233 param = new G4UIparameter("meshName",'s',false);
234 drawCmd->SetParameter(param);
235 param = new G4UIparameter("psName",'s',false);
236 drawCmd->SetParameter(param);
237 param = new G4UIparameter("colorMapName",'s',true);
238 param->SetDefaultValue("defaultLinearColorMap");
239 drawCmd->SetParameter(param);
240 param = new G4UIparameter("proj",'i',true);
241 param->SetDefaultValue(111);
242 drawCmd->SetParameter(param);
243 drawCmd->SetToBeBroadcasted(false);
244
245 // Draw column
246 drawColumnCmd = new G4UIcommand("/score/drawColumn",this);
247 drawColumnCmd->SetGuidance("Draw a cell column.");
248 drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x for box mesh");
249 drawColumnCmd->SetGuidance(" 0 : z-phi, 1: r-phi, 2: r-z for cylinder mesh");
250 param = new G4UIparameter("meshName",'s',false);
251 drawColumnCmd->SetParameter(param);
252 param = new G4UIparameter("psName",'s',false);
253 drawColumnCmd->SetParameter(param);
254 param = new G4UIparameter("plane",'i',false);
255 param->SetParameterRange("plane>=0 && plane<=2");
256 drawColumnCmd->SetParameter(param);
257 param = new G4UIparameter("column",'i',false);
258 drawColumnCmd->SetParameter(param);
259 param = new G4UIparameter("colorMapName",'s',true);
260 param->SetDefaultValue("defaultLinearColorMap");
261 drawColumnCmd->SetParameter(param);
262 drawColumnCmd->SetToBeBroadcasted(false);
263
264 colorMapDir = new G4UIdirectory("/score/colorMap/");
265 colorMapDir->SetGuidance("Color map commands.");
266
267 listColorMapCmd = new G4UIcmdWithoutParameter("/score/colorMap/listScoreColorMaps",this);
268 listColorMapCmd->SetGuidance("List registered score color maps.");
269 listColorMapCmd->SetToBeBroadcasted(false);
270
271 floatMinMaxCmd = new G4UIcmdWithAString("/score/colorMap/floatMinMax",this);
272 floatMinMaxCmd->SetGuidance("Min/Max of the color map is calculated according to the actual scores.");
273 floatMinMaxCmd->SetParameterName("colorMapName",true,false);
274 floatMinMaxCmd->SetDefaultValue("defaultLinearColorMap");
275 floatMinMaxCmd->SetToBeBroadcasted(false);
276
277 colorMapMinMaxCmd = new G4UIcommand("/score/colorMap/setMinMax",this);
278 colorMapMinMaxCmd->SetGuidance("Define min/max value of the color map.");
279 param = new G4UIparameter("colorMapMame",'s',true);
280 param->SetDefaultValue("defaultLinearColorMap");
281 colorMapMinMaxCmd->SetParameter(param);
282 param = new G4UIparameter("minValue",'d',false);
283 colorMapMinMaxCmd->SetParameter(param);
284 param = new G4UIparameter("maxValue",'d',false);
285 colorMapMinMaxCmd->SetParameter(param);
286 colorMapMinMaxCmd->SetToBeBroadcasted(false);
287
288 /*
289 chartCmd = new G4UIcommand("/score/drawChart",this);
290 chartCmd->SetGuidance("Draw color chart on the screen.");
291 chartCmd->SetGuidance("[usage] /score/drawChart");
292 chartCmd->SetGuidance(" mesh :(String) Mesh name.");
293 chartCmd->SetGuidance(" psname :(String) PS name.");
294 chartCmd->SetGuidance(" On/Off :(boolean) On or Off the color chart.");
295 chartCmd->SetGuidance(" scale :(String) default=linear, or log ");
296 param = new G4UIparameter("meshName",'s',false);
297 chartCmd->SetParameter(param);
298 param = new G4UIparameter("psName",'s',false);
299 chartCmd->SetParameter(param);
300 param = new G4UIparameter("On",'s',true);
301 param->SetDefaultValue("true");
302 chartCmd->SetParameter(param);
303 param = new G4UIparameter("scale",'s',true);
304 param->SetDefaultValue("linear");
305 chartCmd->SetParameter(param);
306 */
307
308 // Dump a scored quantity
309 dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
310 dumpQtyToFileCmd->SetGuidance("Dump one scored quantity to file.");
311 param = new G4UIparameter("meshName", 's', false);
312 dumpQtyToFileCmd->SetParameter(param);
313 param = new G4UIparameter("psName", 's', false);
314 dumpQtyToFileCmd->SetParameter(param);
315 param = new G4UIparameter("fileName", 's', false);
316 dumpQtyToFileCmd->SetParameter(param);
317 param = new G4UIparameter("option", 's', true);
318 dumpQtyToFileCmd->SetParameter(param);
319 dumpQtyToFileCmd->SetToBeBroadcasted(false);
320
321 dumpQtyWithFactorCmd = new G4UIcommand("/score/dumpQuantityWithFactor", this);
322 dumpQtyWithFactorCmd->SetGuidance("Dump one scored quantity to file.");
323 dumpQtyWithFactorCmd->SetGuidance("Each value is multiplied by the specified factor.");
324 param = new G4UIparameter("meshName", 's', false);
325 dumpQtyWithFactorCmd->SetParameter(param);
326 param = new G4UIparameter("psName", 's', false);
327 dumpQtyWithFactorCmd->SetParameter(param);
328 param = new G4UIparameter("fileName", 's', false);
329 dumpQtyWithFactorCmd->SetParameter(param);
330 param = new G4UIparameter("factor", 'd', false);
331 param->SetParameterRange("factor>0.");
332 dumpQtyWithFactorCmd->SetParameter(param);
333 param = new G4UIparameter("option", 's', true);
334 dumpQtyWithFactorCmd->SetParameter(param);
335 dumpQtyWithFactorCmd->SetToBeBroadcasted(false);
336
337 // Dump all scored quantities
338 dumpAllQtsToFileCmd = new G4UIcommand("/score/dumpAllQuantitiesToFile", this);
339 dumpAllQtsToFileCmd->SetGuidance("Dump all quantities of the mesh to file.");
340 param = new G4UIparameter("meshName", 's', false);
341 dumpAllQtsToFileCmd->SetParameter(param);
342 param = new G4UIparameter("fileName", 's', false);
343 dumpAllQtsToFileCmd->SetParameter(param);
344 param = new G4UIparameter("option", 's', true);
345 dumpAllQtsToFileCmd->SetParameter(param);
346 dumpAllQtsToFileCmd->SetToBeBroadcasted(false);
347
348 dumpAllQtsWithFactorCmd = new G4UIcommand("/score/dumpAllQuantitiesWithFactor", this);
349 dumpAllQtsWithFactorCmd->SetGuidance("Dump all quantities of the mesh to file.");
350 dumpAllQtsWithFactorCmd->SetGuidance("Each value is multiplied by the specified factor.");
351 param = new G4UIparameter("meshName", 's', false);
352 dumpAllQtsWithFactorCmd->SetParameter(param);
353 param = new G4UIparameter("fileName", 's', false);
354 dumpAllQtsWithFactorCmd->SetParameter(param);
355 param = new G4UIparameter("factor", 'd', false);
356 param->SetParameterRange("factor>0.");
357 dumpAllQtsWithFactorCmd->SetParameter(param);
358 param = new G4UIparameter("option", 's', true);
359 dumpAllQtsWithFactorCmd->SetParameter(param);
360 dumpAllQtsWithFactorCmd->SetToBeBroadcasted(false);
361
362 fill1DCmd = new G4UIcommand("/score/fill1D", this);
363 fill1DCmd->SetGuidance("Let a primitive scorer fill 1-D histogram");
364 fill1DCmd->SetGuidance("Before using this command, primitive scorer must be defined and assigned.");
365 fill1DCmd->SetGuidance("Also before using this command, a histogram has to be defined by /analysis/h1/create command.");
366 fill1DCmd->SetGuidance("This command is available only for real-world volume or probe.");
367 fill1DCmd->SetGuidance("Please note that this command has to be applied to each copy number of the scoring volume.");
368 fill1DCmd->SetGuidance("If same histogram ID is used more than once, more than one scorers fill that histogram.");
369 param = new G4UIparameter("histID", 'i', false);
370 fill1DCmd->SetParameter(param);
371 param = new G4UIparameter("meshName", 's', false);
372 fill1DCmd->SetParameter(param);
373 param = new G4UIparameter("scorerName", 's', false);
374 fill1DCmd->SetParameter(param);
375 param = new G4UIparameter("copyNo", 'i', true);
376 param->SetDefaultValue(0);
377 fill1DCmd->SetParameter(param);
378
379}
G4UIcmdWith3VectorAndUnit::SetDefaultUnit
void SetDefaultUnit(const char *defUnit)
Definition: G4UIcmdWith3VectorAndUnit.cc:214
G4UIcmdWith3VectorAndUnit::SetParameterName
void SetParameterName(const char *theNameX, const char *theNameY, const char *theNameZ, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWith3VectorAndUnit.cc:168
G4UIcmdWithADoubleAndUnit::SetDefaultUnit
void SetDefaultUnit(const char *defUnit)
Definition: G4UIcmdWithADoubleAndUnit.cc:187
G4UIcmdWithADoubleAndUnit::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithADoubleAndUnit.cc:155
G4UIcmdWithAString::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAString.cc:43
G4UIcmdWithAString::SetDefaultValue
void SetDefaultValue(const char *defVal)
Definition: G4UIcmdWithAString.cc:61
G4UIcommand::SetToBeBroadcasted
void SetToBeBroadcasted(G4bool val)
Definition: G4UIcommand.hh:172
G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:146
G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:156
G4UIcommand::SetRange
void SetRange(const char *rs)
Definition: G4UIcommand.hh:120
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:70
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:87
G4UIparameter::SetDefaultUnit
void SetDefaultUnit(const char *theDefaultUnit)
Definition: G4UIparameter.cc:133

◆ ~G4ScoringMessenger()

G4ScoringMessenger::~G4ScoringMessenger ( )

Definition at line 381 of file G4ScoringMessenger.cc.

382{
383 delete listCmd;
384 delete verboseCmd;
385 //
386 delete meshBoxCreateCmd;
387 delete meshCylinderCreateCmd;
388 delete meshRWLogVolCreateCmd;
389 delete probeCreateCmd;
390 delete meshCreateDir;
391// delete meshSphereCreateCmd;
392 //
393 delete meshOpnCmd;
394 //
395 delete meshClsCmd;
396// delete meshActCmd;
397 delete meshDir;
398 //
399 delete mBoxSizeCmd;
400 delete mCylinderSizeCmd;
401// delete mSphereSizeCmd;
402 //
403 delete mBinCmd;
404 //
405 delete mTResetCmd;
406 delete mTXyzCmd;
407 delete mTransDir;
408// delete mRResetCmd;
409 delete mRotXCmd;
410 delete mRotYCmd;
411 delete mRotZCmd;
412 delete mRotDir;
413 //
414 delete probeLocateCmd;
415 delete probeMatCmd;
416 delete probeDir;
417 //
418 //delete chartCmd;
419 delete dumpCmd;
420 delete drawCmd;
421 delete drawColumnCmd;
422 delete listColorMapCmd;
423 delete floatMinMaxCmd;
424 delete colorMapMinMaxCmd;
425 delete colorMapDir;
426 delete dumpQtyToFileCmd;
427 delete dumpQtyWithFactorCmd;
428 delete dumpAllQtsToFileCmd;
429 delete dumpAllQtsWithFactorCmd;
430 delete fill1DCmd;
431 //
432 delete scoreDir;
433}

Member Function Documentation

◆ Fill1D()

void G4ScoringMessenger::Fill1D ( G4UIcommand *  cmd,
G4String  newValues 
)
protected

Definition at line 852 of file G4ScoringMessenger.cc.

853{
854 using MeshShape = G4VScoringMesh::MeshShape;
855
856 G4Tokenizer next(newVal);
857 G4int histID = StoI(next());
858 G4String meshName = next();
859 G4String primName = next();
860 G4int copyNo = StoI(next());
861
862 auto filler = G4VScoreHistFiller::Instance();
863 if(!filler)
864 {
865 G4ExceptionDescription ed;
866 ed << "G4TScoreHistFiller is not instantiated in this application.";
867 cmd->CommandFailed(ed);
868 return;
869 }
870 //
871 // To do : check the validity of histID
872 //
873
874 auto sm = G4ScoringManager::GetScoringManagerIfExist();
875 auto mesh = sm->FindMesh(meshName);
876 if(mesh==nullptr)
877 {
878 G4ExceptionDescription ed;
879 ed << "Mesh name <" << meshName << "> is not found.";
880 cmd->CommandFailed(ed);
881 return;
882 }
883 auto shape = mesh->GetShape();
884 if(shape!=MeshShape::realWorldLogVol && shape!=MeshShape::probe)
885 {
886 G4ExceptionDescription ed;
887 ed << "Mesh <" << meshName << "> is not real-world logical volume or probe.";
888 cmd->CommandFailed(ed);
889 return;
890 }
891
892 auto prim = mesh->GetPrimitiveScorer(primName);
893 if(prim==nullptr)
894 {
895 G4ExceptionDescription ed;
896 ed << "Primitive scorer name <" << primName << "> is not found.";
897 cmd->CommandFailed(ed);
898 return;
899 }
900 auto pp = dynamic_cast<G4VPrimitivePlotter*>(prim);
901 if(pp==nullptr)
902 {
903 G4ExceptionDescription ed;
904 ed << "Primitive scorer <" << primName << "> does not support direct histogram filling.";
905 cmd->CommandFailed(ed);
906 return;
907 }
908
909 pp->Plot(copyNo,histID);
910}
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
G4int
int G4int
Definition: G4Types.hh:85
G4ScoringManager::GetScoringManagerIfExist
static G4ScoringManager * GetScoringManagerIfExist()
Definition: G4ScoringManager.cc:51
G4UIcommand::CommandFailed
void CommandFailed(G4int errCode, G4ExceptionDescription &ed)
Definition: G4UIcommand.hh:179
G4UImessenger::StoI
G4int StoI(G4String s)
Definition: G4UImessenger.cc:107
G4VScoreHistFiller::Instance
static G4VScoreHistFiller * Instance()
Definition: G4VScoreHistFiller.cc:43

Referenced by SetNewValue().

◆ FillTokenVec()

void G4ScoringMessenger::FillTokenVec ( G4String  newValues,
G4TokenVec &  token 
)
protected

Definition at line 815 of file G4ScoringMessenger.cc.

815 {
816
817 G4Tokenizer next(newValues);
818 G4String val;
819 while ( !(val = next()).isNull() ) { // Loop checking 12.18.2015 M.Asai
820 token.push_back(val);
821 }
822}

Referenced by SetNewValue().

◆ GetCurrentValue()

G4String G4ScoringMessenger::GetCurrentValue ( G4UIcommand *  command)
virtual

Reimplemented from G4UImessenger.

Definition at line 806 of file G4ScoringMessenger.cc.

807{
808 G4String val;
809 if(command==verboseCmd)
810 { val = verboseCmd->ConvertToString(fSMan->GetVerboseLevel()); }
811
812 return val;
813}
G4ScoringManager::GetVerboseLevel
G4int GetVerboseLevel() const
Definition: G4ScoringManager.hh:133
G4UIcommand::ConvertToString
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:430

◆ MeshBinCommand()

void G4ScoringMessenger::MeshBinCommand ( G4VScoringMesh *  mesh,
G4TokenVec &  token 
)
protected

Definition at line 825 of file G4ScoringMessenger.cc.

825 {
826 G4int Ni = StoI(token[0]);
827 G4int Nj = StoI(token[1]);
828 G4int Nk = StoI(token[2]);
829 G4int nSegment[3];
830
831 if(dynamic_cast<G4ScoringBox*>(mesh)) {
832 G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox" << G4endl;
833 nSegment[0] = Ni;
834 nSegment[1] = Nj;
835 nSegment[2] = Nk;
836 } else if(dynamic_cast<G4ScoringCylinder*>(mesh)) {
837 G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder" << G4endl;
838 nSegment[0] = Nj;
839 nSegment[1] = Nk;
840 nSegment[2] = Ni;
841 } else {
842 G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException, "invalid mesh type");
843 return;
844 }
845 //
846 mesh->SetNumberOfSegments(nSegment);
847}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4VScoringMesh::SetNumberOfSegments
void SetNumberOfSegments(G4int nSegment[3])
Definition: G4VScoringMesh.cc:94

Referenced by SetNewValue().

◆ SetNewValue()

void G4ScoringMessenger::SetNewValue ( G4UIcommand *  command,
G4String  newValues 
)
virtual

Reimplemented from G4UImessenger.

Definition at line 435 of file G4ScoringMessenger.cc.

436{
437 using MeshShape = G4VScoringMesh::MeshShape;
438
439 if(command==listCmd) {
440 fSMan->List();
441 } else if(command==dumpCmd) {
442 fSMan->Dump();
443 } else if(command==drawCmd) {
444 G4Tokenizer next(newVal);
445 G4String meshName = next();
446 G4String psName = next();
447 G4String colorMapName = next();
448 G4int axflg = StoI(next());
449 fSMan->DrawMesh(meshName,psName,colorMapName,axflg);
450 } else if(command==drawColumnCmd) {
451 G4Tokenizer next(newVal);
452 G4String meshName = next();
453 G4String psName = next();
454 G4int iPlane = StoI(next());
455 G4int iColumn = StoI(next());
456 G4String colorMapName = next();
457 fSMan->DrawMesh(meshName,psName,iPlane,iColumn,colorMapName);
458// } else if(command==chartCmd ){
459// G4Tokenizer next(newVal);
460// G4String meshName = next();
461// G4String psName = next();
462// //G4bool onFlag = StoB(next());
463// G4String scaleOption = next();
464// fSMan->DrawChart(meshName,psName,onFlag,scaleOption);
465
466 } else if(command==dumpQtyToFileCmd) {
467 G4Tokenizer next(newVal);
468 G4String meshName = next();
469 G4String psName = next();
470 G4String fileName = next();
471 G4String option = next("\n");
472 auto mesh = fSMan->FindMesh(meshName);
473 if(!mesh)
474 {
475 G4ExceptionDescription ed;
476 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
477 command->CommandFailed(ed);
478 return;
479 }
480 fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
481 } else if(command==dumpQtyWithFactorCmd) {
482 G4Tokenizer next(newVal);
483 G4String meshName = next();
484 G4String psName = next();
485 G4String fileName = next();
486 G4double fac = StoD(next());
487 G4String option = next("\n");
488 auto mesh = fSMan->FindMesh(meshName);
489 if(!mesh)
490 {
491 G4ExceptionDescription ed;
492 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
493 command->CommandFailed(ed);
494 return;
495 }
496 fSMan->SetFactor(fac);
497 fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
498 fSMan->SetFactor(1.0);
499 } else if(command==dumpAllQtsToFileCmd) {
500 G4Tokenizer next(newVal);
501 G4String meshName = next();
502 G4String fileName = next();
503 G4String option = next("\n");
504 auto mesh = fSMan->FindMesh(meshName);
505 if(!mesh)
506 {
507 G4ExceptionDescription ed;
508 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
509 command->CommandFailed(ed);
510 return;
511 }
512 fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
513 } else if(command==dumpAllQtsWithFactorCmd) {
514 G4Tokenizer next(newVal);
515 G4String meshName = next();
516 G4String fileName = next();
517 G4double fac = StoD(next());
518 G4String option = next("\n");
519 auto mesh = fSMan->FindMesh(meshName);
520 if(!mesh)
521 {
522 G4ExceptionDescription ed;
523 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
524 command->CommandFailed(ed);
525 return;
526 }
527 fSMan->SetFactor(fac);
528 fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
529 fSMan->SetFactor(1.0);
530 } else if(command==fill1DCmd) {
531 Fill1D(command,newVal);
532 } else if(command==verboseCmd) {
533 fSMan->SetVerboseLevel(verboseCmd->GetNewIntValue(newVal));
534 } else if(command==meshBoxCreateCmd) {
535 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
536 if ( currentmesh ){
537 G4ExceptionDescription ed;
538 ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
539 << "] : Mesh <" << currentmesh->GetWorldName()
540 << "> is still open. Close it first. Command ignored.";
541 command->CommandFailed(ed);
542 } else {
543
544 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
545 if ( !mesh ){
546 mesh = new G4ScoringBox(newVal);
547 fSMan->RegisterScoringMesh(mesh);
548 }else{
549 G4ExceptionDescription ed;
550 ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
551 << "] : Scoring mesh <" << newVal
552 << "> already exists. Command ignored.";
553 command->CommandFailed(ed);
554 }
555 }
556 } else if(command==meshCylinderCreateCmd) {
557 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
558 if ( currentmesh ){
559 G4ExceptionDescription ed;
560 ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
561 << "] : Mesh <" << currentmesh->GetWorldName()
562 << "> is still open. Close it first. Command ignored.";
563 command->CommandFailed(ed);
564 } else {
565
566 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
567 if ( !mesh ){
568 mesh = new G4ScoringCylinder(newVal);
569 fSMan->RegisterScoringMesh(mesh);
570 }else{
571 G4ExceptionDescription ed;
572 ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
573 << "] : Scoring mesh <" << newVal
574 << "> already exists. Command ignored.";
575 command->CommandFailed(ed);
576 }
577 }
578 } else if(command==meshRWLogVolCreateCmd) {
579 auto mesh = fSMan->GetCurrentMesh();
580 if ( mesh ){
581 G4ExceptionDescription ed;
582 ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath()
583 << "] : Mesh <" << mesh->GetWorldName()
584 << "> is still open. Close it first. Command ignored.";
585 command->CommandFailed(ed);
586 }
587 else
588 {
589 G4Tokenizer next(newVal);
590 G4String meshName = next();
591 G4int idx = StoI(next());
592 mesh = fSMan->FindMesh(meshName);
593 if ( !mesh ){
594 mesh = new G4ScoringRealWorld(meshName);
595 mesh->SetCopyNumberLevel(idx);
596 fSMan->RegisterScoringMesh(mesh);
597 }else{
598 G4ExceptionDescription ed;
599 ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath()
600 << "] : Scoring mesh <" << meshName << "> already exists. Command ignored.";
601 command->CommandFailed(ed);
602 }
603 }
604 } else if(command==probeCreateCmd) {
605 auto mesh = fSMan->GetCurrentMesh();
606 if ( mesh ){
607 G4ExceptionDescription ed;
608 ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath()
609 << "] : Mesh <" << mesh->GetWorldName()
610 << "> is still open. Close it first. Command ignored.";
611 command->CommandFailed(ed);
612 }
613 else
614 {
615 G4Tokenizer next(newVal);
616 G4String qname = next();
617 G4double halfSize = StoD(next());
618 halfSize *= G4UIcommand::ValueOf(next());
619 G4bool checkOverlap = StoB(next());
620 mesh = fSMan->FindMesh(qname);
621 if(!mesh)
622 {
623 mesh = new G4ScoringProbe(qname,halfSize,checkOverlap);
624 fSMan->RegisterScoringMesh(mesh);
625 }
626 else
627 {
628 G4ExceptionDescription ed;
629 ed << "ERROR[" << probeCreateCmd->GetCommandPath()
630 << "] : Mesh name <" << qname << "> already exists. Use another name.";
631 command->CommandFailed(ed);
632 }
633 }
634 } else if(command==probeMatCmd || command==probeLocateCmd) {
635 auto mesh = fSMan->GetCurrentMesh();
636 if(!mesh)
637 {
638 G4ExceptionDescription ed;
639 ed << "ERROR : No mesh is currently open. Open/create a mesh first. Command ignored.";
640 command->CommandFailed(ed);
641 return;
642 }
643 if(mesh->GetShape() != MeshShape::probe)
644 {
645 G4ExceptionDescription ed;
646 ed << "ERROR : Inconsistent mesh type. Close current mesh and open Scoring Probe.";
647 command->CommandFailed(ed);
648 return;
649 }
650
651 if(command==probeMatCmd)
652 {
653 G4bool succ = static_cast<G4ScoringProbe*>(mesh)->SetMaterial(newVal);
654 if(!succ)
655 {
656 G4ExceptionDescription ed;
657 ed << "Material <" << newVal << "> is not defind in G4NistManager. Command is ignored.\n"
658 << "Use /material/nist/listMaterials command to see the available materials.";
659 command->CommandFailed(ed);
660 return;
661 }
662 }
663 else if(command==probeLocateCmd)
664 {
665 G4ThreeVector loc = probeLocateCmd->GetNew3VectorValue(newVal);
666 static_cast<G4ScoringProbe*>(mesh)->LocateProbe(loc);
667 }
668 } else if(command==listColorMapCmd) {
669 fSMan->ListScoreColorMaps();
670 } else if(command==floatMinMaxCmd) {
671 G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(newVal);
672 if(colorMap)
673 { colorMap->SetFloatingMinMax(true); }
674 else
675 {
676 G4ExceptionDescription ed;
677 ed << "ERROR[" << floatMinMaxCmd->GetCommandPath()
678 << "] : color map <" << newVal << "> is not defined. Command ignored." ;
679 command->CommandFailed(ed);
680 }
681 } else if(command==colorMapMinMaxCmd) {
682 G4Tokenizer next(newVal);
683 G4String mapName = next();
684 G4double minVal = StoD(next());
685 G4double maxVal = StoD(next());
686 G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(mapName);
687 if(colorMap)
688 { colorMap->SetFloatingMinMax(false);
689 colorMap->SetMinMax(minVal,maxVal); }
690 else
691 {
692 G4ExceptionDescription ed;
693 ed << "ERROR[" << colorMapMinMaxCmd->GetCommandPath()
694 << "] : color map <" << newVal << "> is not defined. Command ignored."
695 << G4endl;
696 command->CommandFailed(ed);
697 }
698 } else if(command==meshOpnCmd) {
699 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
700 if ( currentmesh ){
701 G4ExceptionDescription ed;
702 ed << "ERROR[" << meshOpnCmd->GetCommandPath()
703 << "] : Mesh <" << currentmesh->GetWorldName()
704 << "> is still open. Close it first. Command ignored.";
705 command->CommandFailed(ed);
706 } else {
707 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
708 if ( !mesh ){
709 G4ExceptionDescription ed;
710 ed << "ERROR[" << meshOpnCmd->GetCommandPath()
711 << "] : Scoring mesh <" << newVal << "> does not exist. Command ignored.";
712 command->CommandFailed(ed);
713 } else {
714 fSMan->SetCurrentMesh(mesh);
715 }
716 }
717 } else if(command==meshClsCmd) {
718 fSMan->CloseCurrentMesh();
719 } else {
720 //
721 // Get Current Mesh
722 //
723 G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
724 //
725 // Commands for Current Mesh
726 if ( mesh ){
727 MeshShape shape = mesh->GetShape();
728 if ( shape == MeshShape::realWorldLogVol ) {
729 G4ExceptionDescription ed;
730 ed << "ERROR[" << mBinCmd->GetCommandPath()
731 << "] : Number of mesh command cannot be set for this type of mesh. Command ignored.";
732 command->CommandFailed(ed);
733 } else {
734
735 // Tokens
736 G4TokenVec token;
737 FillTokenVec(newVal,token);
738 //
739 // Mesh Geometry
740 //
741// if(command==meshActCmd) {
742// mesh->Activate(meshActCmd->GetNewBoolValue(newVal));
743// } else
744 if(command==mBoxSizeCmd) {
745 if ( shape == MeshShape::box){
746 G4ThreeVector size = mBoxSizeCmd->GetNew3VectorValue(newVal);
747 G4double vsize[3];
748 vsize[0] = size.x();
749 vsize[1] = size.y();
750 vsize[2] = size.z();
751 mesh->SetSize(vsize);
752 } else {
753 G4ExceptionDescription ed;
754 ed << "ERROR[" << mBoxSizeCmd->GetCommandPath()
755 << "] : This mesh is not Box. Command ignored.";
756 command->CommandFailed(ed);
757 }
758 }else if(command==mCylinderSizeCmd) {
759 if ( shape == MeshShape::cylinder ){
760 G4double vsize[3];
761 vsize[0] = StoD(token[0]);
762 vsize[1] = StoD(token[1]);
763 G4double unt = mCylinderSizeCmd->ValueOf(token[2]);
764 vsize[0] *= unt;
765 vsize[1] *= unt;
766 vsize[2] = 0.0;
767 mesh->SetSize(vsize);
768 } else {
769 G4ExceptionDescription ed;
770 ed << "ERROR[" << mBoxSizeCmd->GetCommandPath()
771 << "] : This mesh is not Box. Command ignored.";
772 command->CommandFailed(ed);
773 }
774 } else if(command==mBinCmd) {
775 MeshBinCommand(mesh,token);
776 } else if(command==mTResetCmd) {
777 G4double centerPosition[3] ={ 0., 0., 0.};
778 mesh->SetCenterPosition(centerPosition);
779 } else if(command==mTXyzCmd) {
780 G4ThreeVector xyz = mTXyzCmd->GetNew3VectorValue(newVal);
781 G4double centerPosition[3];
782 centerPosition[0] = xyz.x();
783 centerPosition[1] = xyz.y();
784 centerPosition[2] = xyz.z();
785 mesh->SetCenterPosition(centerPosition);
786// } else if(command==mRResetCmd) {
787 } else if(command==mRotXCmd) {
788 G4double value = mRotXCmd->GetNewDoubleValue(newVal);
789 mesh->RotateX(value);
790 } else if(command==mRotYCmd) {
791 G4double value = mRotYCmd->GetNewDoubleValue(newVal);
792 mesh->RotateY(value);
793 } else if(command==mRotZCmd) {
794 G4double value = mRotZCmd->GetNewDoubleValue(newVal);
795 mesh->RotateZ(value);
796 }
797 }
798 }else{
799 G4ExceptionDescription ed;
800 ed << "ERROR: No mesh is currently open. Open/create a mesh first. Command ignored.";
801 command->CommandFailed(ed);
802 }
803 }
804}
G4TokenVec
std::vector< G4String > G4TokenVec
Definition: G4ScoreQuantityMessenger.hh:50
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4ScoringManager::RegisterScoringMesh
void RegisterScoringMesh(G4VScoringMesh *scm)
Definition: G4ScoringManager.hh:137
G4ScoringManager::SetVerboseLevel
void SetVerboseLevel(G4int vl)
Definition: G4ScoringManager.hh:125
G4ScoringManager::GetScoreColorMap
G4VScoreColorMap * GetScoreColorMap(const G4String &mapName)
Definition: G4ScoringManager.cc:212
G4ScoringManager::DumpAllQuantitiesToFile
void DumpAllQuantitiesToFile(const G4String &meshName, const G4String &fileName, const G4String &option="")
Definition: G4ScoringManager.cc:185
G4ScoringManager::FindMesh
G4VScoringMesh * FindMesh(G4VHitsCollection *map)
Definition: G4ScoringManager.cc:92
G4ScoringManager::SetCurrentMesh
void SetCurrentMesh(G4VScoringMesh *scm)
Definition: G4ScoringManager.hh:119
G4ScoringManager::DrawMesh
void DrawMesh(const G4String &meshName, const G4String &psName, const G4String &colorMapName, G4int axflg=111)
Definition: G4ScoringManager.cc:129
G4ScoringManager::SetFactor
void SetFactor(G4double val=1.0)
Definition: G4ScoringManager.hh:158
G4ScoringManager::GetCurrentMesh
G4VScoringMesh * GetCurrentMesh() const
Definition: G4ScoringManager.hh:121
G4ScoringManager::DumpQuantityToFile
void DumpQuantityToFile(const G4String &meshName, const G4String &psName, const G4String &fileName, const G4String &option="")
Definition: G4ScoringManager.cc:170
G4ScoringMessenger::FillTokenVec
void FillTokenVec(G4String newValues, G4TokenVec &token)
Definition: G4ScoringMessenger.cc:815
G4ScoringMessenger::MeshBinCommand
void MeshBinCommand(G4VScoringMesh *mesh, G4TokenVec &token)
Definition: G4ScoringMessenger.cc:825
G4ScoringMessenger::Fill1D
void Fill1D(G4UIcommand *cmd, G4String newValues)
Definition: G4ScoringMessenger.cc:852
G4UIcmdWith3VectorAndUnit::GetNew3VectorValue
static G4ThreeVector GetNew3VectorValue(const char *paramString)
Definition: G4UIcmdWith3VectorAndUnit.cc:102
G4UIcmdWithADoubleAndUnit::GetNewDoubleValue
static G4double GetNewDoubleValue(const char *paramString)
Definition: G4UIcmdWithADoubleAndUnit.cc:93
G4UIcmdWithAnInteger::GetNewIntValue
static G4int GetNewIntValue(const char *paramString)
Definition: G4UIcmdWithAnInteger.cc:43
G4UIcommand::ValueOf
static G4double ValueOf(const char *unitName)
Definition: G4UIcommand.cc:348
G4UIcommand::GetCommandPath
const G4String & GetCommandPath() const
Definition: G4UIcommand.hh:136
G4UImessenger::StoD
G4double StoD(G4String s)
Definition: G4UImessenger.cc:127
G4UImessenger::StoB
G4bool StoB(G4String s)
Definition: G4UImessenger.cc:137
G4VScoreColorMap::SetMinMax
void SetMinMax(G4double minVal, G4double maxVal)
Definition: G4VScoreColorMap.hh:52
G4VScoreColorMap::SetFloatingMinMax
void SetFloatingMinMax(G4bool vl=true)
Definition: G4VScoreColorMap.hh:48
G4VScoringMesh::GetShape
MeshShape GetShape() const
Definition: G4VScoringMesh.hh:91
G4VScoringMesh::RotateY
void RotateY(G4double delta)
Definition: G4VScoringMesh.cc:113
G4VScoringMesh::GetWorldName
const G4String & GetWorldName() const
Definition: G4VScoringMesh.hh:82
G4VScoringMesh::SetCenterPosition
void SetCenterPosition(G4double centerPosition[3])
Definition: G4VScoringMesh.cc:91
G4VScoringMesh::SetCopyNumberLevel
void SetCopyNumberLevel(G4int val)
Definition: G4VScoringMesh.hh:234
G4VScoringMesh::RotateX
void RotateX(G4double delta)
Definition: G4VScoringMesh.cc:108
G4VScoringMesh::SetSize
void SetSize(G4double size[3])
Definition: G4VScoringMesh.cc:74
G4VScoringMesh::RotateZ
void RotateZ(G4double delta)
Definition: G4VScoringMesh.cc:118
The documentation for this class was generated from the following files: