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

#include <G4AdjointSimMessenger.hh>

+ Inheritance diagram for G4AdjointSimMessenger:

Public Member Functions

 G4AdjointSimMessenger (G4AdjointSimManager *)
 
 ~G4AdjointSimMessenger () override
 
void SetNewValue (G4UIcommand *, G4String) override
 
- Public Member Functions inherited from G4UImessenger
 G4UImessenger ()=default
 
 G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
virtual ~G4UImessenger ()
 
virtual G4String GetCurrentValue (G4UIcommand *command)
 
G4bool CommandsShouldBeInMaster () const
 

Additional Inherited Members

- Protected Member Functions inherited from G4UImessenger
G4String ItoS (G4int i)
 
G4String LtoS (G4long l)
 
G4String DtoS (G4double a)
 
G4String BtoS (G4bool b)
 
G4int StoI (const G4String &s)
 
G4long StoL (const G4String &s)
 
G4double StoD (const G4String &s)
 
G4bool StoB (const 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)
 
- Protected Attributes inherited from G4UImessenger
G4UIdirectory * baseDir = nullptr
 
G4String baseDirName = ""
 
G4bool commandsShouldBeInMaster = false
 

Detailed Description

Definition at line 123 of file G4AdjointSimMessenger.hh.

Constructor & Destructor Documentation

◆ G4AdjointSimMessenger()

G4AdjointSimMessenger::G4AdjointSimMessenger ( G4AdjointSimManager * pAdjointRunManager)

Definition at line 54 of file G4AdjointSimMessenger.cc.

55 : theAdjointRunManager(pAdjointRunManager)
56{
57 AdjointSimDir = new G4UIdirectory("/adjoint/");
58 AdjointSimDir->SetGuidance("Control of the adjoint or reverse monte carlo simulation");
59
60 // Start and adjoint Run
61 //---------------------
62
63
64 beamOnCmd = new G4UIcommand("/adjoint/start_run", this);
65 beamOnCmd->SetGuidance("Start an adjoint Run.");
66 beamOnCmd->SetGuidance("Default number of events to be processed is 1.");
67 beamOnCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
68 auto p1 = new G4UIparameter("numberOfEvent", 'i', true);
69 p1->SetDefaultValue(1);
70 p1->SetParameterRange("numberOfEvent >= 0");
71 beamOnCmd->SetParameter(p1);
72
73 // Commands to define parameters relative to the external source
74 //------------------------------------------------------------
75
76 auto pos_x_par = new G4UIparameter("X", 'd', true);
77
78 auto pos_y_par = new G4UIparameter("Y", 'd', true);
79
80 auto pos_z_par = new G4UIparameter("Z", 'd', true);
81
82 auto radius_par = new G4UIparameter("R", 'd', true);
83
84 radius_par->SetParameterRange("R >= 0");
85
86 auto unit_par = new G4UIparameter("unit", 's', true);
87
88 DefineSpherExtSourceCmd = new G4UIcommand("/adjoint/DefineSphericalExtSource", this);
89 DefineSpherExtSourceCmd->SetGuidance("Define a spherical external source.");
90 DefineSpherExtSourceCmd->SetParameter(pos_x_par);
91 DefineSpherExtSourceCmd->SetParameter(pos_y_par);
92 DefineSpherExtSourceCmd->SetParameter(pos_z_par);
93 DefineSpherExtSourceCmd->SetParameter(radius_par);
94 DefineSpherExtSourceCmd->SetParameter(unit_par);
95
96 auto phys_vol_name_par = new G4UIparameter("phys_vol_name", 's', true);
97
98 DefineSpherExtSourceCenteredOnAVolumeCmd =
99 new G4UIcommand("/adjoint/DefineSphericalExtSourceCenteredOnAVolume", this);
100 DefineSpherExtSourceCenteredOnAVolumeCmd->SetGuidance(
101 "Define a spherical external source with the center located at the center "
102 "of a "
103 "physical volume");
104 DefineSpherExtSourceCenteredOnAVolumeCmd->SetParameter(phys_vol_name_par);
105 DefineSpherExtSourceCenteredOnAVolumeCmd->SetParameter(radius_par);
106 DefineSpherExtSourceCenteredOnAVolumeCmd->SetParameter(unit_par);
107
108 DefineExtSourceOnAVolumeExtSurfaceCmd =
109 new G4UIcmdWithAString("/adjoint/DefineExtSourceOnExtSurfaceOfAVolume", this);
110 DefineExtSourceOnAVolumeExtSurfaceCmd->SetGuidance(
111 "Set the external source on the external surface of a physical volume");
112 DefineExtSourceOnAVolumeExtSurfaceCmd->SetParameterName("phys_vol_name", false);
113
114 setExtSourceEMaxCmd = new G4UIcmdWithADoubleAndUnit("/adjoint/SetExtSourceEmax", this);
115 setExtSourceEMaxCmd->SetGuidance("Set the maximum energy of the external source");
116 setExtSourceEMaxCmd->SetParameterName("Emax", false);
117 setExtSourceEMaxCmd->SetUnitCategory("Energy");
118 setExtSourceEMaxCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
119
120 // Commands to define the adjoint source
121 //------------------------------------------------------------
122
123 DefineSpherAdjSourceCmd = new G4UIcommand("/adjoint/DefineSphericalAdjSource", this);
124 DefineSpherAdjSourceCmd->SetGuidance("Define a spherical adjoint source.");
125 DefineSpherAdjSourceCmd->SetParameter(pos_x_par);
126 DefineSpherAdjSourceCmd->SetParameter(pos_y_par);
127 DefineSpherAdjSourceCmd->SetParameter(pos_z_par);
128 DefineSpherAdjSourceCmd->SetParameter(radius_par);
129 DefineSpherAdjSourceCmd->SetParameter(unit_par);
130
131 DefineSpherAdjSourceCenteredOnAVolumeCmd =
132 new G4UIcommand("/adjoint/DefineSphericalAdjSourceCenteredOnAVolume", this);
133 DefineSpherAdjSourceCenteredOnAVolumeCmd->SetGuidance(
134 "Define a spherical adjoint source with the center located at the center "
135 "of a "
136 "physical volume");
137 DefineSpherAdjSourceCenteredOnAVolumeCmd->SetParameter(phys_vol_name_par);
138 DefineSpherAdjSourceCenteredOnAVolumeCmd->SetParameter(radius_par);
139 DefineSpherAdjSourceCenteredOnAVolumeCmd->SetParameter(unit_par);
140
141 DefineAdjSourceOnAVolumeExtSurfaceCmd =
142 new G4UIcmdWithAString("/adjoint/DefineAdjSourceOnExtSurfaceOfAVolume", this);
143 DefineAdjSourceOnAVolumeExtSurfaceCmd->SetGuidance(
144 "Set the adjoint source on the external surface of physical volume");
145 DefineAdjSourceOnAVolumeExtSurfaceCmd->SetParameterName("phys_vol_name", false);
146
147 setAdjSourceEminCmd = new G4UIcmdWithADoubleAndUnit("/adjoint/SetAdjSourceEmin", this);
148 setAdjSourceEminCmd->SetGuidance("Set the minimum energy of the adjoint source");
149 setAdjSourceEminCmd->SetParameterName("Emin", false);
150 setAdjSourceEminCmd->SetUnitCategory("Energy");
151 setAdjSourceEminCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
152
153 setAdjSourceEmaxCmd = new G4UIcmdWithADoubleAndUnit("/adjoint/SetAdjSourceEmax", this);
154 setAdjSourceEmaxCmd->SetGuidance("Set the maximum energy of the adjoint source");
155 setAdjSourceEmaxCmd->SetParameterName("Emax", false);
156 setAdjSourceEmaxCmd->SetUnitCategory("Energy");
157 setAdjSourceEmaxCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
158
159 ConsiderParticleAsPrimaryCmd = new G4UIcmdWithAString("/adjoint/ConsiderAsPrimary", this);
160 ConsiderParticleAsPrimaryCmd->SetGuidance("Set the selected particle as primary");
161 ConsiderParticleAsPrimaryCmd->SetParameterName("particle", false);
162 ConsiderParticleAsPrimaryCmd->SetCandidates("e- gamma proton ion");
163
164 NeglectParticleAsPrimaryCmd = new G4UIcmdWithAString("/adjoint/NeglectAsPrimary", this);
165 NeglectParticleAsPrimaryCmd->SetGuidance(
166 "Remove the selected particle from the list of primaries");
167 NeglectParticleAsPrimaryCmd->SetParameterName("particle", false);
168 NeglectParticleAsPrimaryCmd->SetCandidates("e- gamma proton ion");
169
170 setNbOfPrimaryFwdGammasPerEventCmd =
171 new G4UIcmdWithAnInteger("/adjoint/SetNbOfPrimaryFwdGammasPerEvent", this);
172 setNbOfPrimaryFwdGammasPerEventCmd->SetGuidance(
173 "Set the nb of primary fwd gamm generated on the adjoint source");
174 setNbOfPrimaryFwdGammasPerEventCmd->SetParameterName("Nb_gammas", false);
175 setNbOfPrimaryFwdGammasPerEventCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
176
177 setNbOfPrimaryAdjGammasPerEventCmd =
178 new G4UIcmdWithAnInteger("/adjoint/SetNbOfPrimaryAdjGammasPerEvent", this);
179 setNbOfPrimaryAdjGammasPerEventCmd->SetGuidance(
180 "Set the nb of primary fwd gamm generated on the adjoint source");
181 setNbOfPrimaryAdjGammasPerEventCmd->SetParameterName("Nb_gammas", false);
182 setNbOfPrimaryAdjGammasPerEventCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
183
184 setNbOfPrimaryAdjElectronsPerEventCmd =
185 new G4UIcmdWithAnInteger("/adjoint/SetNbOfPrimaryAdjElectronsPerEvent", this);
186 setNbOfPrimaryAdjElectronsPerEventCmd->SetGuidance(
187 "Set the nb of primary fwd gamm generated on the adjoint source");
188 setNbOfPrimaryAdjElectronsPerEventCmd->SetParameterName("Nb_gammas", false);
189 setNbOfPrimaryAdjElectronsPerEventCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
190}
G4State_Idle
@ G4State_Idle
Definition G4ApplicationState.hh:86
G4State_PreInit
@ G4State_PreInit
Definition G4ApplicationState.hh:84

◆ ~G4AdjointSimMessenger()

G4AdjointSimMessenger::~G4AdjointSimMessenger ( )
override

Definition at line 194 of file G4AdjointSimMessenger.cc.

195{
196 delete setNbOfPrimaryAdjElectronsPerEventCmd;
197 delete setNbOfPrimaryAdjGammasPerEventCmd;
198 delete setNbOfPrimaryFwdGammasPerEventCmd;
199 delete NeglectParticleAsPrimaryCmd;
200 delete ConsiderParticleAsPrimaryCmd;
201 delete setAdjSourceEmaxCmd;
202 delete setAdjSourceEminCmd;
203 delete DefineAdjSourceOnAVolumeExtSurfaceCmd;
204 delete DefineSpherAdjSourceCenteredOnAVolumeCmd;
205 delete DefineSpherAdjSourceCmd;
206 delete setExtSourceEMaxCmd;
207 delete DefineExtSourceOnAVolumeExtSurfaceCmd;
208 delete DefineSpherExtSourceCenteredOnAVolumeCmd;
209 delete DefineSpherExtSourceCmd;
210 delete beamOnCmd;
211 delete AdjointSimDir;
212}

Member Function Documentation

◆ SetNewValue()

void G4AdjointSimMessenger::SetNewValue ( G4UIcommand * command,
G4String newValue )
overridevirtual

Reimplemented from G4UImessenger.

Definition at line 216 of file G4AdjointSimMessenger.cc.

217{
218 if (command == nullptr) return;
219 if (command == beamOnCmd) {
220 G4int nev;
221 const auto nv = (const char*)newValue;
222 std::istringstream is(nv);
223 is >> nev;
224 theAdjointRunManager->RunAdjointSimulation(nev);
225 }
226 else if (command == ConsiderParticleAsPrimaryCmd) {
227 theAdjointRunManager->ConsiderParticleAsPrimary(newValue);
228 }
229 else if (command == NeglectParticleAsPrimaryCmd) {
230 theAdjointRunManager->NeglectParticleAsPrimary(newValue);
231 }
232 if (command == DefineSpherExtSourceCmd) {
233 G4double x, y, z, r;
234 G4String unit;
235 const auto nv = (const char*)newValue;
236 std::istringstream is(nv);
237 is >> x >> y >> z >> r >> unit;
238
239 x *= G4UnitDefinition::GetValueOf(unit);
240 y *= G4UnitDefinition::GetValueOf(unit);
241 z *= G4UnitDefinition::GetValueOf(unit);
242 r *= G4UnitDefinition::GetValueOf(unit);
243 theAdjointRunManager->DefineSphericalExtSource(r, G4ThreeVector(x, y, z));
244 }
245 else if (command == DefineSpherExtSourceCenteredOnAVolumeCmd) {
246 G4double r;
247 G4String vol_name, unit;
248 const auto nv = (const char*)newValue;
249 std::istringstream is(nv);
250 is >> vol_name >> r >> unit;
251 r *= G4UnitDefinition::GetValueOf(unit);
252 theAdjointRunManager->DefineSphericalExtSourceWithCentreAtTheCentreOfAVolume(r, vol_name);
253 }
254 else if (command == DefineExtSourceOnAVolumeExtSurfaceCmd) {
255 theAdjointRunManager->DefineExtSourceOnTheExtSurfaceOfAVolume(newValue);
256 }
257 else if (command == setExtSourceEMaxCmd) {
258 theAdjointRunManager->SetExtSourceEmax(setExtSourceEMaxCmd->GetNewDoubleValue(newValue));
259 }
260 else if (command == DefineSpherAdjSourceCmd) {
261 G4double x, y, z, r;
262 G4String unit;
263 const auto nv = (const char*)newValue;
264 std::istringstream is(nv);
265 is >> x >> y >> z >> r >> unit;
266
267 x *= G4UnitDefinition::GetValueOf(unit);
268 y *= G4UnitDefinition::GetValueOf(unit);
269 z *= G4UnitDefinition::GetValueOf(unit);
270 r *= G4UnitDefinition::GetValueOf(unit);
271 theAdjointRunManager->DefineSphericalAdjointSource(r, G4ThreeVector(x, y, z));
272 }
273 else if (command == DefineSpherAdjSourceCenteredOnAVolumeCmd) {
274 G4double r;
275 G4String vol_name, unit;
276 const auto nv = (const char*)newValue;
277 std::istringstream is(nv);
278 is >> vol_name >> r >> unit;
279 r *= G4UnitDefinition::GetValueOf(unit);
280 theAdjointRunManager->DefineSphericalAdjointSourceWithCentreAtTheCentreOfAVolume(r, vol_name);
281 }
282 else if (command == DefineAdjSourceOnAVolumeExtSurfaceCmd) {
283 theAdjointRunManager->DefineAdjointSourceOnTheExtSurfaceOfAVolume(newValue);
284 }
285 else if (command == setAdjSourceEminCmd) {
286 theAdjointRunManager->SetAdjointSourceEmin(setAdjSourceEminCmd->GetNewDoubleValue(newValue));
287 }
288 else if (command == setAdjSourceEmaxCmd) {
289 theAdjointRunManager->SetAdjointSourceEmax(setAdjSourceEmaxCmd->GetNewDoubleValue(newValue));
290 }
291 else if (command == setNbOfPrimaryFwdGammasPerEventCmd) {
292 theAdjointRunManager->SetNbOfPrimaryFwdGammasPerEvent(
293 setNbOfPrimaryFwdGammasPerEventCmd->GetNewIntValue(newValue));
294 }
295 else if (command == setNbOfPrimaryAdjGammasPerEventCmd) {
296 theAdjointRunManager->SetNbAdjointPrimaryGammasPerEvent(
297 setNbOfPrimaryAdjGammasPerEventCmd->GetNewIntValue(newValue));
298 }
299 else if (command == setNbOfPrimaryAdjElectronsPerEventCmd) {
300 theAdjointRunManager->SetNbAdjointPrimaryElectronsPerEvent(
301 setNbOfPrimaryAdjElectronsPerEventCmd->GetNewIntValue(newValue));
302 }
303}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4double
double G4double
Definition G4Types.hh:83
G4int
int G4int
Definition G4Types.hh:85
G4UnitDefinition::GetValueOf
static G4double GetValueOf(const G4String &)
Definition G4UnitsTable.cc:185
The documentation for this class was generated from the following files: