source: trunk/source/digits_hits/utils/src/G4ScoringMessenger.cc @ 1348

Last change on this file since 1348 was 1340, checked in by garnier, 14 years ago

update ti head
File size: 21.5 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: G4ScoringMessenger.cc,v 1.42 2010/07/26 03:52:33 akimura Exp $
28// GEANT4 tag $Name:  $
29//
30// ---------------------------------------------------------------------
31
32#include "G4ScoringMessenger.hh"
33#include "G4ScoringManager.hh"
34#include "G4VScoringMesh.hh"
35#include "G4ScoringBox.hh"
36#include "G4ScoringCylinder.hh"
37
38#include "G4UIdirectory.hh"
39#include "G4UIcmdWithoutParameter.hh"
40#include "G4UIcmdWithAnInteger.hh"
41#include "G4UIcmdWithAString.hh"
42#include "G4UIcmdWithABool.hh"
43#include "G4UIcmdWithADoubleAndUnit.hh"
44#include "G4UIcmdWith3VectorAndUnit.hh"
45#include "G4UIcommand.hh"
46#include "G4Tokenizer.hh"
47#include "G4UnitsTable.hh"
48#include "G4VScoreColorMap.hh"
49
50G4ScoringMessenger::G4ScoringMessenger(G4ScoringManager* SManager)
51:fSMan(SManager)
52{
53  G4UIparameter* param;
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  meshDir = new G4UIdirectory("/score/mesh/");
70  meshDir->SetGuidance("    Mesh processing commands.");
71
72  meshCreateDir = new G4UIdirectory("/score/create/");
73  meshCreateDir->SetGuidance("  Mesh creation commands.");
74  //
75  // Mesh commands
76  meshBoxCreateCmd = new G4UIcmdWithAString("/score/create/boxMesh",this);
77  meshBoxCreateCmd->SetGuidance("Create scoring box mesh.");
78  meshBoxCreateCmd->SetParameterName("MeshName",false);
79  //
80  meshCylinderCreateCmd = new G4UIcmdWithAString("/score/create/cylinderMesh",this);
81  meshCylinderCreateCmd->SetGuidance("Create scoring mesh.");
82  meshCylinderCreateCmd->SetParameterName("MeshName",false);
83  //
84//  meshSphereCreateCmd = new G4UIcmdWithAString("/score/create/sphereMesh",this);
85//  meshSphereCreateCmd->SetGuidance("Create scoring mesh.");
86//  meshSphereCreateCmd->SetParameterName("MeshName",false);
87  //
88  meshOpnCmd = new G4UIcmdWithAString("/score/open",this);
89  meshOpnCmd->SetGuidance("Open scoring mesh.");
90  meshOpnCmd->SetParameterName("MeshName",false);
91  //
92  meshClsCmd = new G4UIcmdWithoutParameter("/score/close",this);
93  meshClsCmd->SetGuidance("Close scoring mesh.");
94  //
95//  meshActCmd = new G4UIcmdWithABool("/score/mesh/activate",this);
96//  meshActCmd->SetGuidance("Activate scoring mesh.");
97//  meshActCmd->SetParameterName("MeshName",false);
98  //
99  mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/boxSize",this);
100  mBoxSizeCmd->SetGuidance("Define size of the scoring mesh.");
101  mBoxSizeCmd->SetGuidance("Dx  Dy  Dz  unit");
102  mBoxSizeCmd->SetParameterName("Di","Dj","Dk",false,false);
103  mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>0.");
104  mBoxSizeCmd->SetDefaultUnit("mm");
105  //
106  mCylinderSizeCmd = new G4UIcommand("/score/mesh/cylinderSize",this);
107  mCylinderSizeCmd->SetGuidance("Define size of the scoring mesh.");
108  mCylinderSizeCmd->SetGuidance("R   Dz  unit");
109  param = new G4UIparameter("R",'d',false);
110  param->SetParameterRange("R>0");
111  mCylinderSizeCmd->SetParameter(param);
112  param = new G4UIparameter("Dz",'d',false);
113  param->SetParameterRange("Dz>0");
114  mCylinderSizeCmd->SetParameter(param);
115  param = new G4UIparameter("unit",'s',true);
116  param->SetDefaultValue("mm");
117  mCylinderSizeCmd->SetParameter(param);
118  //
119  //   Division command
120  mBinCmd = new G4UIcommand("/score/mesh/nBin",this);
121  mBinCmd->SetGuidance("Define segments of the scoring mesh.");
122  mBinCmd->SetGuidance("[usage] /score/mesh/nBin");
123  mBinCmd->SetGuidance(" In case of boxMesh, parameters are given in");
124  mBinCmd->SetGuidance("   Ni  :(int) Number of bins i (in x-axis) ");
125  mBinCmd->SetGuidance("   Nj  :(int) Number of bins j (in y-axis) ");
126  mBinCmd->SetGuidance("   Nk  :(int) Number of bins k (in z-axis) ");
127  mBinCmd->SetGuidance(" In case of cylinderMesh, parameters are given in");
128  mBinCmd->SetGuidance("   Nr  :(int) Number of bins in radial axis ");
129  mBinCmd->SetGuidance("   Nz  :(int) Number of bins in z axis ");
130  mBinCmd->SetGuidance("   Nphi:(int) Number of bins in phi axis ");
131  //mBinCmd->SetGuidance("  Axis:(int) Axis of division ");
132//  mBinCmd->SetGuidance("  P1..Pn-1  :(double) \"paramter from P1 to Pn-1 for division.\"");
133  param = new G4UIparameter("Ni",'i',false);
134  param->SetDefaultValue("1");
135  param->SetParameterRange("Ni>0");
136  mBinCmd->SetParameter(param);
137  param = new G4UIparameter("Nj",'i',false);
138  param->SetDefaultValue("1");
139  param->SetParameterRange("Nj>0");
140  mBinCmd->SetParameter(param);
141  param = new G4UIparameter("Nk",'i',false);
142  param->SetDefaultValue("1");
143  mBinCmd->SetParameter(param);
144  param->SetParameterRange("Nk>0");
145  //param = new G4UIparameter("Axis",'i',true);
146  //param->SetDefaultValue("3");
147  //mBinCmd->SetParameter(param);
148  //
149  //   Placement command
150  mTransDir = new G4UIdirectory("/score/mesh/translate/");
151  mTransDir->SetGuidance("Mesh translation commands.");
152  //
153  mTResetCmd = new G4UIcmdWithoutParameter("/score/mesh/translate/reset",this);
154  mTResetCmd->SetGuidance("Reset translated position of the scoring mesh.");
155  //
156  mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/translate/xyz",this);
157  mTXyzCmd->SetGuidance("Translate the scoring mesh.");
158  mTXyzCmd->SetParameterName("X","Y","Z",false,false);
159  mTXyzCmd->SetDefaultUnit("mm");
160  //
161  mRotDir = new G4UIdirectory("/score/mesh/rotate/");
162  mRotDir->SetGuidance("Mesh rotation commands.");
163  //
164  mRResetCmd = new G4UIcmdWithoutParameter("/score/mesh/rotate/reset",this);
165  mRResetCmd->SetGuidance("Reset rotation angles of the scoring mesh.");
166  //
167  mRotXCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateX",this);
168  mRotXCmd->SetGuidance("Rotate the scoring mesh in X axis.");
169  mRotXCmd->SetParameterName("Rx",false);
170  mRotXCmd->SetDefaultUnit("deg");
171  //
172  mRotYCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateY",this);
173  mRotYCmd->SetGuidance("Rotate the scoring mesh in Y axis.");
174  mRotYCmd->SetParameterName("Ry",false);
175  mRotYCmd->SetDefaultUnit("deg");
176  //
177  mRotZCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateZ",this);
178  mRotZCmd->SetGuidance("Rotate the scoring mesh in Z axis.");
179  mRotZCmd->SetParameterName("Rz",false);
180  mRotZCmd->SetDefaultUnit("deg");
181  //
182
183  // Draw Scoring result
184  drawCmd = new G4UIcommand("/score/drawProjection",this);
185  drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
186  drawCmd->SetGuidance("Parameter <proj> specified which projection(s) to be drawn.");
187  drawCmd->SetGuidance("  100 : xy-plane, 010 : yz-plane,    001 : zx-plane -- default 111");
188  drawCmd->SetGuidance("  100 : N/A,      010 : z_phi-plane, 001 : r_phi-plane -- default 111");
189  param = new G4UIparameter("meshName",'s',false);
190  drawCmd->SetParameter(param);
191  param = new G4UIparameter("psName",'s',false);
192  drawCmd->SetParameter(param);
193  param = new G4UIparameter("colorMapName",'s',true);
194  param->SetDefaultValue("defaultLinearColorMap");
195  drawCmd->SetParameter(param);
196  param = new G4UIparameter("proj",'i',true);
197  param->SetDefaultValue(111);
198  drawCmd->SetParameter(param);
199
200  // Draw column
201  drawColumnCmd = new G4UIcommand("/score/drawColumn",this);
202  drawColumnCmd->SetGuidance("Draw a cell column.");
203  drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x  for box mesh");
204  drawColumnCmd->SetGuidance("         0 : z-phi, 1: r-phi, 2: r-z  for cylinder mesh");
205  param = new G4UIparameter("meshName",'s',false);
206  drawColumnCmd->SetParameter(param);
207  param = new G4UIparameter("psName",'s',false);
208  drawColumnCmd->SetParameter(param);
209  param = new G4UIparameter("plane",'i',false);
210  param->SetParameterRange("plane>=0 && plane<=2");
211  drawColumnCmd->SetParameter(param);
212  param = new G4UIparameter("column",'i',false);
213  drawColumnCmd->SetParameter(param);
214  param = new G4UIparameter("colorMapName",'s',true);
215  param->SetDefaultValue("defaultLinearColorMap");
216  drawColumnCmd->SetParameter(param);
217
218  colorMapDir = new G4UIdirectory("/score/colorMap/");
219  colorMapDir->SetGuidance("Color map commands.");
220
221  listColorMapCmd = new G4UIcmdWithoutParameter("/score/colorMap/listScoreColorMaps",this);
222  listColorMapCmd->SetGuidance("List registered score color maps.");
223
224  floatMinMaxCmd = new G4UIcmdWithAString("/score/colorMap/floatMinMax",this);
225  floatMinMaxCmd->SetGuidance("Min/Max of the color map is calculated accorging to the actual scores.");
226  floatMinMaxCmd->SetParameterName("colorMapName",true,false);
227  floatMinMaxCmd->SetDefaultValue("defaultLinearColorMap");
228
229  colorMapMinMaxCmd = new G4UIcommand("/score/colorMap/setMinMax",this);
230  colorMapMinMaxCmd->SetGuidance("Define min/max value of the color map.");
231  param = new G4UIparameter("colorMapMame",'s',true);
232  param->SetDefaultValue("defaultLinearColorMap");
233  colorMapMinMaxCmd->SetParameter(param);
234  param = new G4UIparameter("minValue",'d',false);
235  colorMapMinMaxCmd->SetParameter(param);
236  param = new G4UIparameter("maxValue",'d',false);
237  colorMapMinMaxCmd->SetParameter(param);
238
239  /*
240  chartCmd = new G4UIcommand("/score/drawChart",this);
241  chartCmd->SetGuidance("Draw color chart on the screen.");
242  chartCmd->SetGuidance("[usage] /score/drawChart");
243  chartCmd->SetGuidance("  mesh    :(String) Mesh name.");
244  chartCmd->SetGuidance("  psname  :(String) PS name.");
245  chartCmd->SetGuidance("  On/Off  :(boolean) On or Off the color chart.");
246  chartCmd->SetGuidance("  scale   :(String) default=linear, or log ");
247  param = new G4UIparameter("meshName",'s',false);
248  chartCmd->SetParameter(param);
249  param = new G4UIparameter("psName",'s',false);
250  chartCmd->SetParameter(param);
251  param = new G4UIparameter("On",'s',true);
252  param->SetDefaultValue("true");
253  chartCmd->SetParameter(param);
254  param = new G4UIparameter("scale",'s',true);
255  param->SetDefaultValue("linear");
256  chartCmd->SetParameter(param);
257  */
258
259  // Dump a scored quantity
260  dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
261  dumpQtyToFileCmd->SetGuidance("Dump one scored quantity to file.");
262  param = new G4UIparameter("meshName", 's', false);
263  dumpQtyToFileCmd->SetParameter(param);
264  param = new G4UIparameter("psName", 's', false);
265  dumpQtyToFileCmd->SetParameter(param);
266  param = new G4UIparameter("fileName", 's', false);
267  dumpQtyToFileCmd->SetParameter(param);
268  param = new G4UIparameter("option", 's', true);
269  dumpQtyToFileCmd->SetParameter(param);
270
271  // Dump all scored quantities
272  dumpAllQtsToFileCmd = new G4UIcommand("/score/dumpAllQuantitiesToFile", this);
273  dumpAllQtsToFileCmd->SetGuidance("Dump all quantities of the mesh to file.");
274  param = new G4UIparameter("meshName", 's', false);
275  dumpAllQtsToFileCmd->SetParameter(param);
276  param = new G4UIparameter("fileName", 's', false);
277  dumpAllQtsToFileCmd->SetParameter(param);
278  param = new G4UIparameter("option", 's', true);
279  dumpAllQtsToFileCmd->SetParameter(param);
280
281}
282
283G4ScoringMessenger::~G4ScoringMessenger()
284{
285    delete listCmd;
286    delete verboseCmd;
287    //
288    delete           meshCreateDir;
289    delete           meshBoxCreateCmd;
290    delete           meshCylinderCreateCmd;
291//    delete           meshSphereCreateCmd;
292    //
293    delete          meshOpnCmd;
294    //
295    delete    meshClsCmd;
296//    delete    meshActCmd;
297    delete          meshDir;
298    //
299    delete  mBoxSizeCmd;
300    delete  mCylinderSizeCmd;
301//    delete  mSphereSizeCmd;
302    //
303    delete      mBinCmd;
304    //
305    delete   mTResetCmd;
306    delete   mTXyzCmd;
307    delete   mTransDir;
308    delete   mRResetCmd;
309    delete   mRotXCmd;
310    delete   mRotYCmd;
311    delete   mRotZCmd;
312    delete   mRotDir;
313    //
314    delete     chartCmd;
315    delete     dumpCmd;
316    delete     drawCmd;
317    delete     drawColumnCmd;
318    delete     listColorMapCmd;
319    delete     floatMinMaxCmd;
320    delete     colorMapMinMaxCmd;
321    delete     colorMapDir;
322    delete     dumpQtyToFileCmd;
323    delete     dumpAllQtsToFileCmd;
324    //
325    delete scoreDir;
326}
327
328void G4ScoringMessenger::SetNewValue(G4UIcommand * command,G4String newVal)
329{
330  if(command==listCmd) { 
331      fSMan->List(); 
332  } else if(command==dumpCmd) { 
333      fSMan->Dump(); 
334  } else if(command==drawCmd) { 
335      G4Tokenizer next(newVal);
336      G4String meshName = next();
337      G4String psName = next();
338      G4String colorMapName = next();
339      G4int axflg = StoI(next());
340      fSMan->DrawMesh(meshName,psName,colorMapName,axflg);
341  } else if(command==drawColumnCmd) { 
342      G4Tokenizer next(newVal);
343      G4String meshName = next();
344      G4String psName = next();
345      G4int iPlane = StoI(next());
346      G4int iColumn = StoI(next());
347      G4String colorMapName = next();
348      fSMan->DrawMesh(meshName,psName,iPlane,iColumn,colorMapName);
349  } else if(command==chartCmd ){
350      G4Tokenizer next(newVal);
351      G4String meshName = next();
352      G4String psName = next();
353      //G4bool   onFlag = StoB(next());
354      G4String scaleOption = next();
355//      fSMan->DrawChart(meshName,psName,onFlag,scaleOption);
356
357  } else if(command==dumpQtyToFileCmd) { 
358      G4Tokenizer next(newVal);
359      G4String meshName = next();
360      G4String psName = next();
361      G4String fileName = next();
362      G4String option = next("\n");
363      fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
364  } else if(command==dumpAllQtsToFileCmd) { 
365      G4Tokenizer next(newVal);
366      G4String meshName = next();
367      G4String fileName = next();
368      G4String option = next("\n");
369      fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
370  } else if(command==verboseCmd) { 
371      fSMan->SetVerboseLevel(verboseCmd->GetNewIntValue(newVal)); 
372  } else if(command==meshBoxCreateCmd) {
373      G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh(); 
374      if ( currentmesh ){
375        G4cerr << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
376               << "] : Mesh <" << currentmesh->GetWorldName() 
377               << "> is still open. Close it first. Command ignored." << G4endl;
378      } else {
379
380        G4VScoringMesh*  mesh = fSMan->FindMesh(newVal);
381        if ( !mesh ){
382          mesh = new G4ScoringBox(newVal);
383          fSMan->RegisterScoringMesh(mesh);
384        }else{
385          G4cerr << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
386                 << "] : Scoring mesh <" << newVal
387                 << "> already exists. Command ignored." << G4endl;
388        }
389      }
390  } else if(command==meshCylinderCreateCmd) {
391      G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh(); 
392      if ( currentmesh ){
393        G4cerr << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
394               << "] : Mesh <" << currentmesh->GetWorldName() 
395               << "> is still open. Close it first. Command ignored." << G4endl;
396      } else {
397
398        G4VScoringMesh*  mesh = fSMan->FindMesh(newVal);
399        if ( !mesh ){
400          mesh = new G4ScoringCylinder(newVal);
401          fSMan->RegisterScoringMesh(mesh);
402        }else{
403          G4cerr << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
404                 << "] : Scoring mesh <" << newVal
405                 << "> already exists. Command ignored." << G4endl;
406        }
407      }
408  } else if(command==listColorMapCmd) {
409      fSMan->ListScoreColorMaps();
410  } else if(command==floatMinMaxCmd) {
411      G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(newVal);
412      if(colorMap)
413      { colorMap->SetFloatingMinMax(true); }
414      else
415      { G4cerr << "ERROR[" << floatMinMaxCmd->GetCommandPath()
416               << "] : color map <" << newVal << "> is not defined. Command ignored." 
417               << G4endl; 
418      }
419  } else if(command==colorMapMinMaxCmd) {
420      G4Tokenizer next(newVal);
421      G4String mapName = next();
422      G4double minVal = StoD(next());
423      G4double maxVal = StoD(next());
424      G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(mapName);
425      if(colorMap)
426      { colorMap->SetFloatingMinMax(false);
427        colorMap->SetMinMax(minVal,maxVal); }
428      else
429      { G4cerr << "ERROR[" << colorMapMinMaxCmd->GetCommandPath()
430               << "] : color map <" << newVal << "> is not defined. Command ignored." 
431               << G4endl; 
432      }
433  } else if(command==meshOpnCmd) {
434      G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh(); 
435      if ( currentmesh ){
436        G4cerr << "ERROR[" << meshOpnCmd->GetCommandPath()
437               << "] : Mesh <" << currentmesh->GetWorldName() << "> is still open. Close it first. Command ignored." << G4endl;
438      } else {
439        G4VScoringMesh* mesh = fSMan->FindMesh(newVal); 
440        if ( !mesh ){
441          G4cerr << "ERROR[" << meshOpnCmd->GetCommandPath()
442                 << "] : Scoring mesh <" << newVal << "> does not exist. Command ignored." << G4endl;
443        } else {
444          fSMan->SetCurrentMesh(mesh);
445        }
446      }
447  } else if(command==meshClsCmd) {
448      fSMan->CloseCurrentMesh();
449  } else {
450      //
451      // Get Current Mesh
452      //
453      G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
454      //
455      // Commands for Current Mesh
456      if ( mesh ){
457          // Tokens
458          G4TokenVec token;
459          FillTokenVec(newVal,token);
460          //
461          // Mesh Geometry
462          //
463//        if(command==meshActCmd) {
464//            mesh->Activate(meshActCmd->GetNewBoolValue(newVal));
465//        } else
466          if(command==mBoxSizeCmd) {
467              MeshShape shape = mesh->GetShape();
468              if ( shape == boxMesh ){
469                  G4ThreeVector size = mBoxSizeCmd->GetNew3VectorValue(newVal);
470                  G4double vsize[3];
471                  vsize[0] = size.x();
472                  vsize[1] = size.y();
473                  vsize[2] = size.z();
474                  mesh->SetSize(vsize);
475              } else {
476                 G4cerr << "ERROR[" << mBoxSizeCmd->GetCommandPath()
477                        << "] : This mesh is not Box. Command ignored." << G4endl;
478              }
479          }else if(command==mCylinderSizeCmd) {
480              MeshShape shape = mesh->GetShape();
481              if ( shape == cylinderMesh ){
482                  G4double vsize[3];
483                  vsize[0]     = StoD(token[0]);
484                  vsize[1]     = StoD(token[1]);
485                  G4double unt = mCylinderSizeCmd->ValueOf(token[2]);
486                  vsize[0] *= unt;
487                  vsize[1] *= unt;
488                  vsize[2]  = 0.0;
489                  mesh->SetSize(vsize);
490              } else {
491                  G4cerr << "ERROR[" << mBoxSizeCmd->GetCommandPath()
492                         << "] : This mesh is not Box. Command ignored." << G4endl;
493              }
494          } else if(command==mBinCmd) {
495              MeshBinCommand(mesh,token);
496          } else if(command==mTResetCmd) {
497              G4double centerPosition[3] ={ 0., 0., 0.};
498              mesh->SetCenterPosition(centerPosition);
499          } else if(command==mTXyzCmd) {
500              G4ThreeVector xyz = mTXyzCmd->GetNew3VectorValue(newVal);
501              G4double centerPosition[3];
502              centerPosition[0] = xyz.x();
503              centerPosition[1] = xyz.y();
504              centerPosition[2] = xyz.z();
505              mesh->SetCenterPosition(centerPosition);
506          } else if(command==mRResetCmd) {
507          } else if(command==mRotXCmd) {
508              G4double value = mRotXCmd->GetNewDoubleValue(newVal);
509              mesh->RotateX(value);
510          } else if(command==mRotYCmd) {
511              G4double value = mRotYCmd->GetNewDoubleValue(newVal);
512              mesh->RotateY(value);
513          } else if(command==mRotZCmd) {
514              G4double value = mRotZCmd->GetNewDoubleValue(newVal);
515              mesh->RotateZ(value);
516          }
517      }else{
518        G4cerr << "ERROR: No mesh is currently open. Open/create a mesh first. Command ignored." << G4endl;
519      }
520  }
521}
522
523G4String G4ScoringMessenger::GetCurrentValue(G4UIcommand * command)
524{
525  G4String val;
526  if(command==verboseCmd)
527  { val = verboseCmd->ConvertToString(fSMan->GetVerboseLevel()); }
528
529  return val;
530}
531
532void G4ScoringMessenger::FillTokenVec(G4String newValues, G4TokenVec& token){
533
534    G4Tokenizer next(newValues);
535    G4String val;
536    while ( !(val = next()).isNull() ) {
537        token.push_back(val);
538    }
539}
540
541
542void G4ScoringMessenger::MeshBinCommand(G4VScoringMesh* mesh,G4TokenVec& token){
543    G4int Ni = StoI(token[0]);
544    G4int Nj = StoI(token[1]);
545    G4int Nk = StoI(token[2]);
546    G4int nSegment[3];
547
548    if(dynamic_cast<G4ScoringBox*>(mesh)) {
549      G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox" << G4endl;
550      nSegment[0] = Ni;
551      nSegment[1] = Nj;
552      nSegment[2] = Nk;
553    } else if(dynamic_cast<G4ScoringCylinder*>(mesh)) {
554      G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder" << G4endl;
555      nSegment[0] = Nj;
556      nSegment[1] = Nk;
557      nSegment[2] = Ni;
558    } else {
559      G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException, "invalid mesh type");
560    }
561    //
562    mesh->SetNumberOfSegments(nSegment);
563}
564
565 
Note: See TracBrowser for help on using the repository browser.