Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/gMocren/src/G4GMocrenMessenger.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/gMocren/src/G4GMocrenMessenger.cc (Version 11.3.0) and /visualization/gMocren/src/G4GMocrenMessenger.cc (Version 11.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
 27 //                                                 27 //
 28 //                                                 28 //
 29 // Created:  Mar. 31, 2009  Akinori Kimura         29 // Created:  Mar. 31, 2009  Akinori Kimura  
 30 //                                                 30 //
 31 #include "G4GMocrenMessenger.hh"                   31 #include "G4GMocrenMessenger.hh"
 32                                                    32 
 33 #include "G4UIdirectory.hh"                        33 #include "G4UIdirectory.hh"
 34 #include "G4UIcmdWithABool.hh"                     34 #include "G4UIcmdWithABool.hh"
 35 #include "G4UIcmdWithAString.hh"                   35 #include "G4UIcmdWithAString.hh"
 36 #include "G4UIcmdWithoutParameter.hh"              36 #include "G4UIcmdWithoutParameter.hh"
 37 #include "G4UIcommand.hh"                          37 #include "G4UIcommand.hh"
 38 #include "G4Tokenizer.hh"                          38 #include "G4Tokenizer.hh"
 39                                                    39 
 40 #include <utility>                             << 
 41                                                << 
 42 G4GMocrenMessenger::G4GMocrenMessenger()           40 G4GMocrenMessenger::G4GMocrenMessenger()
 43   : suffix (""), geometry(true), pointAttribut     41   : suffix (""), geometry(true), pointAttributes(false), solids(true), invisibles(true),
 44     kgMocrenVolumeName("gMocrenVolume"),           42     kgMocrenVolumeName("gMocrenVolume"),
 45     kgMocrenScoringMeshName("gMocrenScoringMes     43     kgMocrenScoringMeshName("gMocrenScoringMesh"),
 46     kDrawVolumeGrid(false) {                       44     kDrawVolumeGrid(false) {
 47                                                    45 
 48   kgMocrenDirectory = new G4UIdirectory("/vis/     46   kgMocrenDirectory = new G4UIdirectory("/vis/gMocren/");
 49   kgMocrenDirectory->SetGuidance("gMocren comm     47   kgMocrenDirectory->SetGuidance("gMocren commands.");
 50                                                    48 
 51   setEventNumberSuffixCommand = new G4UIcmdWit     49   setEventNumberSuffixCommand = new G4UIcmdWithAString("/vis/gMocren/setEventNumberSuffix", this);
 52   setEventNumberSuffixCommand->SetGuidance("Wr     50   setEventNumberSuffixCommand->SetGuidance("Write separate event files, appended with given suffix.");
 53   setEventNumberSuffixCommand->SetGuidance("De     51   setEventNumberSuffixCommand->SetGuidance("Define the suffix with a pattern such as '-0000'.");
 54   setEventNumberSuffixCommand->SetParameterNam     52   setEventNumberSuffixCommand->SetParameterName("suffix",false);
 55   setEventNumberSuffixCommand->SetDefaultValue     53   setEventNumberSuffixCommand->SetDefaultValue("");
 56   setEventNumberSuffixCommand->AvailableForSta     54   setEventNumberSuffixCommand->AvailableForStates(G4State_Idle);
 57                                                    55     
 58   appendGeometryCommand = new G4UIcmdWithABool     56   appendGeometryCommand = new G4UIcmdWithABool("/vis/gMocren/appendGeometry", this);
 59   appendGeometryCommand->SetGuidance("Appends      57   appendGeometryCommand->SetGuidance("Appends copy of geometry to every event.");
 60   appendGeometryCommand->SetParameterName("fla     58   appendGeometryCommand->SetParameterName("flag",false);
 61   appendGeometryCommand->SetDefaultValue(true)     59   appendGeometryCommand->SetDefaultValue(true);
 62   appendGeometryCommand->AvailableForStates(G4     60   appendGeometryCommand->AvailableForStates(G4State_Idle);
 63                                                    61 
 64   addPointAttributesCommand = new G4UIcmdWithA     62   addPointAttributesCommand = new G4UIcmdWithABool("/vis/gMocren/addPointAttributes", this);
 65   addPointAttributesCommand->SetGuidance("Adds     63   addPointAttributesCommand->SetGuidance("Adds point attributes to the points of trajectories.");
 66   addPointAttributesCommand->SetParameterName(     64   addPointAttributesCommand->SetParameterName("flag",false);
 67   addPointAttributesCommand->SetDefaultValue(f     65   addPointAttributesCommand->SetDefaultValue(false);
 68   addPointAttributesCommand->AvailableForState     66   addPointAttributesCommand->AvailableForStates(G4State_Idle);
 69                                                    67 
 70   useSolidsCommand = new G4UIcmdWithABool("/vi     68   useSolidsCommand = new G4UIcmdWithABool("/vis/gMocren/useSolids", this);
 71   useSolidsCommand->SetGuidance("Use GMocren S     69   useSolidsCommand->SetGuidance("Use GMocren Solids, rather than Geant4 Primitives.");
 72   useSolidsCommand->SetParameterName("flag",fa     70   useSolidsCommand->SetParameterName("flag",false);
 73   useSolidsCommand->SetDefaultValue(true);         71   useSolidsCommand->SetDefaultValue(true);
 74   useSolidsCommand->AvailableForStates(G4State     72   useSolidsCommand->AvailableForStates(G4State_Idle);
 75                                                    73 
 76   /* Not Enabled Yet                               74   /* Not Enabled Yet
 77      writeInvisiblesCommand = new G4UIcmdWithA     75      writeInvisiblesCommand = new G4UIcmdWithABool("/vis/gMocren/writeInvisibles", this);
 78      writeInvisiblesCommand->SetGuidance("Writ     76      writeInvisiblesCommand->SetGuidance("Write invisible objects.");
 79      writeInvisiblesCommand->SetParameterName(     77      writeInvisiblesCommand->SetParameterName("flag",false);
 80      writeInvisiblesCommand->SetDefaultValue(t     78      writeInvisiblesCommand->SetDefaultValue(true);
 81      writeInvisiblesCommand->AvailableForState     79      writeInvisiblesCommand->AvailableForStates(G4State_Idle);
 82   */                                               80   */
 83                                                    81 
 84   kSetgMocrenVolumeNameCommand = new G4UIcmdWi     82   kSetgMocrenVolumeNameCommand = new G4UIcmdWithAString("/vis/gMocren/setVolumeName", this);
 85   kSetgMocrenVolumeNameCommand->SetGuidance("d     83   kSetgMocrenVolumeNameCommand->SetGuidance("detector name for a volume data in gMocren data.");
 86   kSetgMocrenVolumeNameCommand->SetParameterNa     84   kSetgMocrenVolumeNameCommand->SetParameterName("kgMocrenVolumeName",false);
 87   kSetgMocrenVolumeNameCommand->SetDefaultValu     85   kSetgMocrenVolumeNameCommand->SetDefaultValue("gMocrenVolume");
 88   kSetgMocrenVolumeNameCommand->AvailableForSt     86   kSetgMocrenVolumeNameCommand->AvailableForStates(G4State_Idle);
 89                                                    87 
 90   kAddgMocrenHitNameCommand = new G4UIcmdWithA     88   kAddgMocrenHitNameCommand = new G4UIcmdWithAString("/vis/gMocren/addHitName", this);
 91   kAddgMocrenHitNameCommand->SetGuidance("hit      89   kAddgMocrenHitNameCommand->SetGuidance("hit name for a dose distribution in gMocren data.");
 92   kAddgMocrenHitNameCommand->SetParameterName(     90   kAddgMocrenHitNameCommand->SetParameterName("kgMocrenHitName",false);
 93   kAddgMocrenHitNameCommand->AvailableForState     91   kAddgMocrenHitNameCommand->AvailableForStates(G4State_Idle);
 94                                                    92 
 95   kResetgMocrenHitNameCommand = new G4UIcmdWit     93   kResetgMocrenHitNameCommand = new G4UIcmdWithoutParameter("/vis/gMocren/resetHitNames", this);
 96   kResetgMocrenHitNameCommand->SetGuidance("re     94   kResetgMocrenHitNameCommand->SetGuidance("reset all hit names.");
 97   kResetgMocrenHitNameCommand->AvailableForSta     95   kResetgMocrenHitNameCommand->AvailableForStates(G4State_Idle);
 98                                                    96 
 99   kSetgMocrenScoringMeshNameCommand = new G4UI     97   kSetgMocrenScoringMeshNameCommand = new G4UIcmdWithAString("/vis/gMocren/setScoringMeshName", this);
100   kSetgMocrenScoringMeshNameCommand->SetGuidan     98   kSetgMocrenScoringMeshNameCommand->SetGuidance("scoring mesh name for a dose distribution in gMocren data.");
101   kSetgMocrenScoringMeshNameCommand->SetParame     99   kSetgMocrenScoringMeshNameCommand->SetParameterName("kgMocrenScoringMeshName",false);
102   kSetgMocrenScoringMeshNameCommand->SetDefaul    100   kSetgMocrenScoringMeshNameCommand->SetDefaultValue("gMocrenScoringMesh");
103   kSetgMocrenScoringMeshNameCommand->Available    101   kSetgMocrenScoringMeshNameCommand->AvailableForStates(G4State_Idle);
104                                                   102 
105   kAddgMocrenHitScorerNameCommand = new G4UIcm    103   kAddgMocrenHitScorerNameCommand = new G4UIcmdWithAString("/vis/gMocren/addHitScorerName", this);
106   kAddgMocrenHitScorerNameCommand->SetGuidance    104   kAddgMocrenHitScorerNameCommand->SetGuidance("hit scorer name for a dose distribution in gMocren data.");
107   kAddgMocrenHitScorerNameCommand->SetParamete    105   kAddgMocrenHitScorerNameCommand->SetParameterName("kgMocrenHitScorerNames",false);
108   kAddgMocrenHitScorerNameCommand->AvailableFo    106   kAddgMocrenHitScorerNameCommand->AvailableForStates(G4State_Idle);
109                                                   107 
110   kResetgMocrenHitScorerNameCommand = new G4UI    108   kResetgMocrenHitScorerNameCommand = new G4UIcmdWithoutParameter("/vis/gMocren/resetHitScorerName", this);
111   kResetgMocrenHitScorerNameCommand->SetGuidan    109   kResetgMocrenHitScorerNameCommand->SetGuidance("reset all hit scorer names.");
112   kResetgMocrenHitScorerNameCommand->Available    110   kResetgMocrenHitScorerNameCommand->AvailableForStates(G4State_Idle);
113                                                   111 
114   kSetgMocrenNoVoxelsCommand = new G4UIcommand    112   kSetgMocrenNoVoxelsCommand = new G4UIcommand("/vis/gMocren/setNumberOfVoxels", this);
115   kSetgMocrenNoVoxelsCommand->SetGuidance("set    113   kSetgMocrenNoVoxelsCommand->SetGuidance("set number of voxels.");
116   kSetgMocrenNoVoxelsCommand->AvailableForStat    114   kSetgMocrenNoVoxelsCommand->AvailableForStates(G4State_Idle);
117   G4UIparameter * param = new G4UIparameter("n    115   G4UIparameter * param = new G4UIparameter("nX", 'i', false);
118   param->SetDefaultValue("1");                    116   param->SetDefaultValue("1");
119   param->SetParameterRange("nX>0");               117   param->SetParameterRange("nX>0");
120   kSetgMocrenNoVoxelsCommand->SetParameter(par    118   kSetgMocrenNoVoxelsCommand->SetParameter(param);
121   param = new G4UIparameter("nY", 'i', false);    119   param = new G4UIparameter("nY", 'i', false);
122   param->SetDefaultValue("1");                    120   param->SetDefaultValue("1");
123   param->SetParameterRange("nY>0");               121   param->SetParameterRange("nY>0");
124   kSetgMocrenNoVoxelsCommand->SetParameter(par    122   kSetgMocrenNoVoxelsCommand->SetParameter(param);
125   param = new G4UIparameter("nZ", 'i', false);    123   param = new G4UIparameter("nZ", 'i', false);
126   param->SetDefaultValue("1");                    124   param->SetDefaultValue("1");
127   param->SetParameterRange("nZ>0");               125   param->SetParameterRange("nZ>0");
128   kSetgMocrenNoVoxelsCommand->SetParameter(par    126   kSetgMocrenNoVoxelsCommand->SetParameter(param);
129                                                   127 
130   kListgMocrenCommand = new G4UIcmdWithoutPara    128   kListgMocrenCommand = new G4UIcmdWithoutParameter("/vis/gMocren/list", this);
131   kListgMocrenCommand->SetGuidance("list gMocr    129   kListgMocrenCommand->SetGuidance("list gMocren command parameters.");
132   kListgMocrenCommand->AvailableForStates(G4St    130   kListgMocrenCommand->AvailableForStates(G4State_Idle);
133                                                   131 
134   kDrawVolumeGridCommand = new G4UIcmdWithABoo    132   kDrawVolumeGridCommand = new G4UIcmdWithABool("/vis/gMocren/drawVolumeGrid", this);
135   kDrawVolumeGridCommand->SetGuidance("Add gri    133   kDrawVolumeGridCommand->SetGuidance("Add grid of the volume.");
136   kDrawVolumeGridCommand->SetParameterName("kD    134   kDrawVolumeGridCommand->SetParameterName("kDrawVolumeGrid",false);
137   kDrawVolumeGridCommand->SetDefaultValue(fals    135   kDrawVolumeGridCommand->SetDefaultValue(false);
138   kDrawVolumeGridCommand->AvailableForStates(G    136   kDrawVolumeGridCommand->AvailableForStates(G4State_Idle);
139                                                   137 
140 }                                                 138 }
141                                                   139 
142 G4GMocrenMessenger::~G4GMocrenMessenger() {       140 G4GMocrenMessenger::~G4GMocrenMessenger() {
143   delete setEventNumberSuffixCommand;             141   delete setEventNumberSuffixCommand;
144   delete appendGeometryCommand;                   142   delete appendGeometryCommand;
145   delete addPointAttributesCommand;               143   delete addPointAttributesCommand;
146   delete useSolidsCommand;                        144   delete useSolidsCommand;
147   //    delete writeInvisiblesCommand;            145   //    delete writeInvisiblesCommand;
148   delete kSetgMocrenVolumeNameCommand;            146   delete kSetgMocrenVolumeNameCommand;
149   delete kAddgMocrenHitNameCommand;               147   delete kAddgMocrenHitNameCommand;
150   delete kResetgMocrenHitNameCommand;             148   delete kResetgMocrenHitNameCommand;
151   //                                              149   //
152   delete kSetgMocrenScoringMeshNameCommand;       150   delete kSetgMocrenScoringMeshNameCommand;
153   delete kAddgMocrenHitScorerNameCommand;         151   delete kAddgMocrenHitScorerNameCommand;
154   delete kResetgMocrenHitScorerNameCommand;       152   delete kResetgMocrenHitScorerNameCommand;
155   //                                              153   //
156   delete kSetgMocrenNoVoxelsCommand;              154   delete kSetgMocrenNoVoxelsCommand;
157   //                                              155   //
158   delete kgMocrenDirectory;                       156   delete kgMocrenDirectory;
159   //                                              157   //
160   delete kDrawVolumeGridCommand;                  158   delete kDrawVolumeGridCommand;
161 }                                                 159 }
162                                                   160 
163 G4String G4GMocrenMessenger::GetCurrentValue(G    161 G4String G4GMocrenMessenger::GetCurrentValue(G4UIcommand * command) {
164   if (command==setEventNumberSuffixCommand) {     162   if (command==setEventNumberSuffixCommand) {
165     return suffix;                                163     return suffix;
166   } else if (command==appendGeometryCommand) {    164   } else if (command==appendGeometryCommand) {
167     return appendGeometryCommand->ConvertToStr    165     return appendGeometryCommand->ConvertToString(geometry); 
168   } else if (command==addPointAttributesComman    166   } else if (command==addPointAttributesCommand) {
169     return addPointAttributesCommand->ConvertT    167     return addPointAttributesCommand->ConvertToString(pointAttributes); 
170   } else if (command==useSolidsCommand) {         168   } else if (command==useSolidsCommand) {
171     return useSolidsCommand->ConvertToString(s    169     return useSolidsCommand->ConvertToString(solids);
172     //    } else if (command==writeInvisiblesC    170     //    } else if (command==writeInvisiblesCommand) {
173     //        return writeInvisiblesCommand->C    171     //        return writeInvisiblesCommand->ConvertToString(invisibles);
174   } else if (command == kSetgMocrenVolumeNameC    172   } else if (command == kSetgMocrenVolumeNameCommand) {
175     return kgMocrenVolumeName;                    173     return kgMocrenVolumeName;
176   } else if (command == kAddgMocrenHitNameComm    174   } else if (command == kAddgMocrenHitNameCommand) {
177     G4String strval;                              175     G4String strval;
178     std::vector<G4String>::iterator itr = kgMo    176     std::vector<G4String>::iterator itr = kgMocrenHitNames.begin();
179     for(; itr != kgMocrenHitNames.end(); itr++    177     for(; itr != kgMocrenHitNames.end(); itr++) {
180       strval += *itr;                             178       strval += *itr;
181       strval += " ";                              179       strval += " ";
182     }                                             180     }
183     return strval;                                181     return strval;
184   } else if (command == kSetgMocrenScoringMesh    182   } else if (command == kSetgMocrenScoringMeshNameCommand) {
185     return kgMocrenScoringMeshName;               183     return kgMocrenScoringMeshName;
186   } else if (command == kAddgMocrenHitScorerNa    184   } else if (command == kAddgMocrenHitScorerNameCommand) {
187     G4String strval;                              185     G4String strval;
188     std::vector<G4String>::iterator itr = kgMo    186     std::vector<G4String>::iterator itr = kgMocrenHitScorerNames.begin();
189     for(; itr != kgMocrenHitScorerNames.end();    187     for(; itr != kgMocrenHitScorerNames.end(); itr++) {
190       strval += *itr;                             188       strval += *itr;
191       strval += " ";                              189       strval += " ";
192     }                                             190     }
193     return strval;                                191     return strval;
194   } else if (command==kDrawVolumeGridCommand)     192   } else if (command==kDrawVolumeGridCommand) {
195     return kDrawVolumeGridCommand->ConvertToSt    193     return kDrawVolumeGridCommand->ConvertToString(kDrawVolumeGrid);
196   } else {                                        194   } else {
197     return "";                                    195     return "";
198   }                                               196   }
199 }                                                 197 }
200                                                   198 
201 void G4GMocrenMessenger::SetNewValue(G4UIcomma    199 void G4GMocrenMessenger::SetNewValue(G4UIcommand * command, G4String newValue) {
202   if (command==setEventNumberSuffixCommand) {     200   if (command==setEventNumberSuffixCommand) {
203     suffix = std::move(newValue);              << 201     suffix = newValue;
204   } else if (command==appendGeometryCommand) {    202   } else if (command==appendGeometryCommand) {
205     geometry = appendGeometryCommand->GetNewBo    203     geometry = appendGeometryCommand->GetNewBoolValue(newValue);
206   } else if (command==addPointAttributesComman    204   } else if (command==addPointAttributesCommand) {
207     pointAttributes = addPointAttributesComman    205     pointAttributes = addPointAttributesCommand->GetNewBoolValue(newValue);
208   } else if (command==useSolidsCommand) {         206   } else if (command==useSolidsCommand) {
209     solids = useSolidsCommand->GetNewBoolValue    207     solids = useSolidsCommand->GetNewBoolValue(newValue);
210     //    } else if (command==writeInvisiblesC    208     //    } else if (command==writeInvisiblesCommand) {
211     //        invisibles = writeInvisiblesComm    209     //        invisibles = writeInvisiblesCommand->GetNewBoolValue(newValue);
212   } else if (command == kSetgMocrenVolumeNameC    210   } else if (command == kSetgMocrenVolumeNameCommand) {
213     kgMocrenVolumeName = std::move(newValue);  << 211     kgMocrenVolumeName = newValue;
214   } else if (command == kAddgMocrenHitNameComm    212   } else if (command == kAddgMocrenHitNameCommand) {
215     kgMocrenHitNames.push_back(std::move(newVa << 213     kgMocrenHitNames.push_back(newValue);
216   } else if (command == kResetgMocrenHitNameCo    214   } else if (command == kResetgMocrenHitNameCommand) {
217     kgMocrenHitNames.clear();                     215     kgMocrenHitNames.clear();
218   } else if (command == kSetgMocrenScoringMesh    216   } else if (command == kSetgMocrenScoringMeshNameCommand) {
219     kgMocrenScoringMeshName = std::move(newVal << 217     kgMocrenScoringMeshName = newValue;
220   } else if (command == kAddgMocrenHitScorerNa    218   } else if (command == kAddgMocrenHitScorerNameCommand) {
221     kgMocrenHitScorerNames.push_back(std::move << 219     kgMocrenHitScorerNames.push_back(newValue);
222   } else if (command == kResetgMocrenHitScorer    220   } else if (command == kResetgMocrenHitScorerNameCommand) {
223     kgMocrenHitScorerNames.clear();               221     kgMocrenHitScorerNames.clear();
224   } else if (command == kListgMocrenCommand) {    222   } else if (command == kListgMocrenCommand) {
225     list();                                       223     list();
226   } else if (command == kSetgMocrenNoVoxelsCom    224   } else if (command == kSetgMocrenNoVoxelsCommand) {
227     G4Tokenizer next(newValue);                   225     G4Tokenizer next(newValue);
228     for(int i = 0; i < 3; i++) {                  226     for(int i = 0; i < 3; i++) {
229       kgMocrenNoVoxels[i] = StoI(next());         227       kgMocrenNoVoxels[i] = StoI(next());
230     }                                             228     }
231   } else if (command==kDrawVolumeGridCommand)     229   } else if (command==kDrawVolumeGridCommand) {
232     kDrawVolumeGrid = kDrawVolumeGridCommand->    230     kDrawVolumeGrid = kDrawVolumeGridCommand->GetNewBoolValue(newValue);
233   }                                               231   } 
234 }                                                 232 }
235                                                   233 
236 G4String G4GMocrenMessenger::getEventNumberSuf    234 G4String G4GMocrenMessenger::getEventNumberSuffix() {
237   return suffix;                                  235   return suffix;
238 }                                                 236 }
239                                                   237 
240 G4bool G4GMocrenMessenger::appendGeometry() {     238 G4bool G4GMocrenMessenger::appendGeometry() {
241   return geometry;                                239   return geometry;
242 }                                                 240 }
243                                                   241 
244 G4bool G4GMocrenMessenger::addPointAttributes(    242 G4bool G4GMocrenMessenger::addPointAttributes() {
245   return pointAttributes;                         243   return pointAttributes;
246 }                                                 244 }
247                                                   245 
248 G4bool G4GMocrenMessenger::useSolids() {          246 G4bool G4GMocrenMessenger::useSolids() {
249   return solids;                                  247   return solids;
250 }                                                 248 }
251                                                   249 
252 G4bool G4GMocrenMessenger::writeInvisibles() {    250 G4bool G4GMocrenMessenger::writeInvisibles() {
253   return invisibles;                              251   return invisibles;
254 }                                                 252 }
255                                                   253 
256 G4String G4GMocrenMessenger::getVolumeName() {    254 G4String G4GMocrenMessenger::getVolumeName() {
257   return kgMocrenVolumeName;                      255   return kgMocrenVolumeName;
258 }                                                 256 }
259                                                   257 
260 std::vector<G4String> G4GMocrenMessenger::getH    258 std::vector<G4String> G4GMocrenMessenger::getHitNames() {
261   return kgMocrenHitNames;                        259   return kgMocrenHitNames;
262 }                                                 260 }
263                                                   261 
264 G4String G4GMocrenMessenger::getScoringMeshNam    262 G4String G4GMocrenMessenger::getScoringMeshName() {
265   return kgMocrenScoringMeshName;                 263   return kgMocrenScoringMeshName;
266 }                                                 264 }
267                                                   265 
268 std::vector<G4String> G4GMocrenMessenger::getH    266 std::vector<G4String> G4GMocrenMessenger::getHitScorerNames() {
269   return kgMocrenHitScorerNames;                  267   return kgMocrenHitScorerNames;
270 }                                                 268 }
271                                                   269 
272 void G4GMocrenMessenger::list() {                 270 void G4GMocrenMessenger::list() {
273   G4cout << "  Current valuess of gMocren comm    271   G4cout << "  Current valuess of gMocren command parameters:" << G4endl;
274   //                                              272   //
275   G4cout << "    volume name:        " << kgMo    273   G4cout << "    volume name:        " << kgMocrenVolumeName << G4endl;
276   //                                              274   //
277   G4cout << "    hit names:          ";           275   G4cout << "    hit names:          ";
278   if(kgMocrenHitNames.size() > 0) {               276   if(kgMocrenHitNames.size() > 0) {
279     std::vector<G4String>::iterator itr = kgMo    277     std::vector<G4String>::iterator itr = kgMocrenHitNames.begin();
280     for(; itr != kgMocrenHitNames.end(); itr++    278     for(; itr != kgMocrenHitNames.end(); itr++)
281       G4cout << *itr << "  " << G4endl;           279       G4cout << *itr << "  " << G4endl;
282   } else {                                        280   } else {
283     G4cout << G4endl;                             281     G4cout << G4endl;
284   }                                               282   }
285   //                                              283   //
286   G4cout << "    scoring mesh name:  " << kgMo    284   G4cout << "    scoring mesh name:  " << kgMocrenScoringMeshName << G4endl;
287   //                                              285   //
288   G4cout << "    scorer names:       ";           286   G4cout << "    scorer names:       ";
289   if(kgMocrenHitScorerNames.size() > 0) {         287   if(kgMocrenHitScorerNames.size() > 0) {
290     std::vector<G4String>::iterator itr = kgMo    288     std::vector<G4String>::iterator itr = kgMocrenHitScorerNames.begin();
291     for(; itr != kgMocrenHitScorerNames.end();    289     for(; itr != kgMocrenHitScorerNames.end(); itr++)
292       G4cout << *itr << "  " << G4endl;           290       G4cout << *itr << "  " << G4endl;
293   } else {                                        291   } else {
294     G4cout << G4endl;                             292     G4cout << G4endl;
295   }                                               293   }
296   G4cout << G4endl;                               294   G4cout << G4endl;
297 }                                                 295 }
298                                                   296 
299 void G4GMocrenMessenger::getNoVoxels(G4int & n    297 void G4GMocrenMessenger::getNoVoxels(G4int & nx, G4int & ny, G4int & nz) const {
300   nx = kgMocrenNoVoxels[0];                       298   nx = kgMocrenNoVoxels[0];
301   ny = kgMocrenNoVoxels[1];                       299   ny = kgMocrenNoVoxels[1];
302   nz = kgMocrenNoVoxels[2];                       300   nz = kgMocrenNoVoxels[2];
303 }                                                 301 }
304                                                   302