Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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: