Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4RadioactiveDecaymessenger.cc
Go to the documentation of this file.
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
28#include "G4NuclearLevelData.hh"
29#include <sstream>
31
32
34(G4RadioactiveDecay* theRadioactiveDecayContainer1)
35:theRadioactiveDecayContainer(theRadioactiveDecayContainer1)
36{
37 // main directory for control of the RDM
38 old_grdmDirectory = new G4UIdirectory("/grdm/"); // To be removed in G4 11.0
39 old_grdmDirectory->SetGuidance("Controls for the Radioactive Decay Module.");
40
41 rdmDirectory = new G4UIdirectory("/process/had/rdm/");
42 rdmDirectory->SetGuidance("Controls for the Radioactive Decay Module.");
43
44 // Command to define the limits on nucleus the RDM will treat.
45 old_nucleuslimitsCmd = new G4UIcmdWithNucleusLimits("/grdm/nucleusLimits",this); // To be removed in G4 11.0
46 old_nucleuslimitsCmd->SetGuidance("Set the atomic weight and number limits for the RDM.");
47 old_nucleuslimitsCmd->SetParameterName("OldAMin","OldAMax","OldZMin","OldZMax",true);
48
49 nucleuslimitsCmd = new G4UIcmdWithNucleusLimits("/process/had/rdm/nucleusLimits",this);
50 nucleuslimitsCmd->SetGuidance("Set the atomic weight and number limits for the RDM.");
51 nucleuslimitsCmd->SetParameterName("AMin","AMax","ZMin","ZMax",true);
52
53 // The next command contols whether the decay will be treated analoguely or
54 // with variance reduction
55 old_analoguemcCmd = new G4UIcmdWithABool("/grdm/analogueMC",this); // To be removed in G4 11.0
56 old_analoguemcCmd->SetGuidance("false: variance reduction method; true: analogue method");
57 old_analoguemcCmd->SetParameterName("OldAnalogueMC",true);
58 old_analoguemcCmd->SetDefaultValue(true);
59
60 analoguemcCmd = new G4UIcmdWithABool("/process/had/rdm/analogueMC",this);
61 analoguemcCmd->SetGuidance("false: variance reduction method; true: analogue method");
62 analoguemcCmd->SetParameterName("AnalogueMC",true);
63 analoguemcCmd->SetDefaultValue(true);
64
65 // The next command contols whether beta decay will be treated faithfully or in fast mode
66 old_fbetaCmd = new G4UIcmdWithABool("/grdm/fBeta",this); // To be removed in G4 11.0
67 old_fbetaCmd->SetGuidance("false: use 3-body decay, true: use histogram method");
68 old_fbetaCmd->SetParameterName("OldFBeta",true);
69 old_fbetaCmd->SetDefaultValue(false);
70
71 fbetaCmd = new G4UIcmdWithABool("/process/had/rdm/fBeta",this);
72 fbetaCmd->SetGuidance("false: use 3-body decay, true: use histogram method");
73 fbetaCmd->SetParameterName("FBeta",true);
74 fbetaCmd->SetDefaultValue(false);
75
76 // Command to selete a logical volume for RDM.
77 old_avolumeCmd = new G4UIcmdWithAString("/grdm/selectVolume",this); // To be removed in G4 11.0
78 old_avolumeCmd->SetGuidance("Supply a logical volumes name to add it to the RDM apply list");
79 old_avolumeCmd->SetParameterName("OldAVolume",false);
80
81 avolumeCmd = new G4UIcmdWithAString("/process/had/rdm/selectVolume",this);
82 avolumeCmd->SetGuidance("Supply a logical volumes name to add it to the RDM apply list");
83 avolumeCmd->SetParameterName("AVolume",false);
84
85 // Command to de-selete a logical volume for RDM.
86 old_deavolumeCmd = new G4UIcmdWithAString("/grdm/deselectVolume",this); // To be removed in G4 11.0
87 old_deavolumeCmd->SetGuidance("Supply a logical volumes name to remove it from the RDM apply list");
88 old_deavolumeCmd->SetParameterName("OldAVolume",false);
89
90 deavolumeCmd = new G4UIcmdWithAString("/process/had/rdm/deselectVolume",this);
91 deavolumeCmd->SetGuidance("Supply a logical volumes name to remove it from the RDM apply list");
92 deavolumeCmd->SetParameterName("AVolume",false);
93
94 // Command to selete all logical volumes for RDM.
95 old_allvolumesCmd = new G4UIcmdWithoutParameter("/grdm/allVolumes",this); // To be removed in G4 11.0
96 old_allvolumesCmd->SetGuidance(" apply RDM to all logical volumes. No parameter required.");
97 // old_allvolumeCmd->SetParameterName("OldAddAVolume",true);
98
99 allvolumesCmd = new G4UIcmdWithoutParameter("/process/had/rdm/allVolumes",this);
100 allvolumesCmd->SetGuidance(" apply RDM to all logical volumes. No parameter required.");
101 // allvolumeCmd->SetParameterName("AddAVolume",true);
102
103 // Command to de-selete a logical volume for RDM.
104 old_deallvolumesCmd = new G4UIcmdWithoutParameter("/grdm/noVolumes",this); // To be removed in G4 11.0
105 old_deallvolumesCmd->SetGuidance(" RDM is not applied to any logical volumes");
106 // old_deallvolumesCmd->SetParameterName("OldRemoveAVolume",true);
107
108 deallvolumesCmd = new G4UIcmdWithoutParameter("/process/had/rdm/noVolumes",this);
109 deallvolumesCmd->SetGuidance(" RDM is not applied to any logical volumes");
110 // deallvolumesCmd->SetParameterName("RemoveAVolume",true);
111
112 // The next command contols whether the branching ratio biasing will be applied or not
113 old_brbiasCmd = new G4UIcmdWithABool("/grdm/BRbias",this); // To be removed in G4 11.0
114 old_brbiasCmd->SetGuidance("false: no biasing; true: all branches are treated as equal");
115 old_brbiasCmd->SetParameterName("OldBRBias",true);
116 old_brbiasCmd->SetDefaultValue(true);
117
118 brbiasCmd = new G4UIcmdWithABool("/process/had/rdm/BRbias",this);
119 brbiasCmd->SetGuidance("false: no biasing; true: all branches are treated as equal");
120 brbiasCmd->SetParameterName("BRBias",true);
121 brbiasCmd->SetDefaultValue(true);
122
123 // Command controls whether ICM will be applied or not
124 old_icmCmd = new G4UIcmdWithABool("/grdm/applyICM",this); // To be removed in G4 11.0
125 old_icmCmd->SetGuidance("True: ICM is applied; false: no");
126 old_icmCmd->SetParameterName("OldApplyICM",true);
127 old_icmCmd->SetDefaultValue(true);
128
129 icmCmd = new G4UIcmdWithABool("/process/had/rdm/applyICM",this);
130 icmCmd->SetGuidance("True: ICM is applied; false: no");
131 icmCmd->SetParameterName("ApplyICM",true);
132 icmCmd->SetDefaultValue(true);
133
134 // Command contols whether ARM will be applied or not
135 old_armCmd = new G4UIcmdWithABool("/grdm/applyARM",this); // To be removed in G4 11.0
136 old_armCmd->SetGuidance("True: ARM is applied; false: no");
137 old_armCmd->SetParameterName("OldApplyARM",true);
138 old_armCmd->SetDefaultValue(true);
139 // old_armCmd->AvailableForStates(G4State_PreInit);
140
141 armCmd = new G4UIcmdWithABool("/process/had/rdm/applyARM",this);
142 armCmd->SetGuidance("True: ARM is applied; false: no");
143 armCmd->SetParameterName("ApplyARM",true);
144 armCmd->SetDefaultValue(true);
145 // armCmd->AvailableForStates(G4State_PreInit);
146
147 // Command to set the h-l thresold for isomer production
148 old_hlthCmd = new G4UIcmdWithADoubleAndUnit("/grdm/hlThreshold",this); // To be removed in G4 11.0
149 old_hlthCmd->SetGuidance("Set the h-l threshold for isomer production");
150 old_hlthCmd->SetParameterName("OldHlThreshold",false);
151 // old_hlthCmd->SetRange("OldHlThreshold>0.");
152 old_hlthCmd->SetUnitCategory("Time");
153 // old_hlthCmd->AvailableForStates(G4State_PreInit);
154
155 hlthCmd = new G4UIcmdWithADoubleAndUnit("/process/had/rdm/hlThreshold",this);
156 hlthCmd->SetGuidance("Set the h-l threshold for isomer production");
157 hlthCmd->SetParameterName("HlThreshold",false);
158 // hlthCmd->SetRange("HlThreshold>0.");
159 hlthCmd->SetUnitCategory("Time");
160 // hlthCmd->AvailableForStates(G4State_PreInit);
161
162 // Command to define the incident particle source time profile.
163 old_sourcetimeprofileCmd = new G4UIcmdWithAString("/grdm/sourceTimeProfile",this); // To be removed in G4 11.0
164 old_sourcetimeprofileCmd->SetGuidance
165 ("Supply the name of the ascii file containing the source particle time profile");
166 old_sourcetimeprofileCmd->SetParameterName("OldSTimeProfile",true);
167 old_sourcetimeprofileCmd->SetDefaultValue("source.data");
168
169 sourcetimeprofileCmd = new G4UIcmdWithAString("/process/had/rdm/sourceTimeProfile",this);
170 sourcetimeprofileCmd->SetGuidance
171 ("Supply the name of the ascii file containing the source particle time profile");
172 sourcetimeprofileCmd->SetParameterName("STimeProfile",true);
173 sourcetimeprofileCmd->SetDefaultValue("source.data");
174
175 // Command to define the incident particle source time profile.
176 old_decaybiasprofileCmd = new G4UIcmdWithAString("/grdm/decayBiasProfile",this); // To be removed in G4 11.0
177 old_decaybiasprofileCmd->SetGuidance
178 ("Supply the name of the ascii file containing the decay bias time profile");
179 old_decaybiasprofileCmd->SetParameterName("OldDBiasProfile",true);
180 old_decaybiasprofileCmd->SetDefaultValue("bias.data");
181
182 decaybiasprofileCmd = new G4UIcmdWithAString("/process/had/rdm/decayBiasProfile",this);
183 decaybiasprofileCmd->SetGuidance
184 ("Supply the name of the ascii file containing the decay bias time profile");
185 decaybiasprofileCmd->SetParameterName("DBiasProfile",true);
186 decaybiasprofileCmd->SetDefaultValue("bias.data");
187
188 // Command to set the directional bias (collimation) vector
189 old_colldirCmd = new G4UIcmdWith3Vector("/grdm/decayDirection",this); // To be removed in G4 11.0
190 old_colldirCmd->SetGuidance("Supply the direction vector for decay products");
191 old_colldirCmd->SetParameterName("OldX","OldY","OldZ",false);
192
193 colldirCmd = new G4UIcmdWith3Vector("/process/had/rdm/decayDirection",this);
194 colldirCmd->SetGuidance("Supply the direction vector for decay products");
195 colldirCmd->SetParameterName("X","Y","Z",false);
196
197 // Command to set the directional bias (collimation) half angle ("cone")
198 old_collangleCmd = new G4UIcmdWithADoubleAndUnit("/grdm/decayHalfAngle",this); // To be removed in G4 11.0
199 old_collangleCmd->SetGuidance("Supply maximum angle from direction vector for decay products");
200 old_collangleCmd->SetParameterName("OldHalfAngle",false);
201 old_collangleCmd->SetUnitCategory("Angle");
202
203 collangleCmd = new G4UIcmdWithADoubleAndUnit("/process/had/rdm/decayHalfAngle",this);
204 collangleCmd->SetGuidance("Supply maximum angle from direction vector for decay products");
205 collangleCmd->SetParameterName("HalfAngle",false);
206 collangleCmd->SetUnitCategory("Angle");
207
208 // This command setup the nuclei spliting parameter
209 old_splitnucleiCmd = new G4UIcmdWithAnInteger("/grdm/splitNuclei",this); // To be removed in G4 11.0
210 old_splitnucleiCmd->SetGuidance("Set number of spliting for the isotopes.");
211 old_splitnucleiCmd->SetParameterName("OldNSplit",true);
212 old_splitnucleiCmd->SetDefaultValue(1);
213 old_splitnucleiCmd->SetRange("OldNSplit>=1");
214
215 splitnucleiCmd = new G4UIcmdWithAnInteger("/process/had/rdm/splitNuclei",this);
216 splitnucleiCmd->SetGuidance("Set number of spliting for the isotopes.");
217 splitnucleiCmd->SetParameterName("NSplit",true);
218 splitnucleiCmd->SetDefaultValue(1);
219 splitnucleiCmd->SetRange("NSplit>=1");
220
221 // This command setup the verbose level of radioactive decay
222 old_verboseCmd = new G4UIcmdWithAnInteger("/grdm/verbose",this); // To be removed in G4 11.0
223 old_verboseCmd->SetGuidance("Set verbose level: 0, 1, 2 or 3");
224 old_verboseCmd->SetParameterName("OldVerboseLevel",true);
225 old_verboseCmd->SetDefaultValue(1);
226 old_verboseCmd->SetRange("OldVerboseLevel>=0");
227
228 verboseCmd = new G4UIcmdWithAnInteger("/process/had/rdm/verbose",this);
229 verboseCmd->SetGuidance("Set verbose level: 0, 1, 2 or 3");
230 verboseCmd->SetParameterName("VerboseLevel",true);
231 verboseCmd->SetDefaultValue(1);
232 verboseCmd->SetRange("VerboseLevel>=0");
233
234 // This command allows the user to define its own decay datafile for a given isotope
235 old_userDecayDataCmd = new G4UIcommand("/grdm/setRadioactiveDecayFile",this); // To be removed in G4 11.0
236 G4UIparameter* old_Z_para= new G4UIparameter("Z_isotope",'i',true);
237 old_Z_para->SetParameterRange("Z_isotope > 0");
238 old_Z_para->SetGuidance("Z: Charge number of isotope");
239 G4UIparameter* old_A_para= new G4UIparameter("A_isotope",'i',true);
240 old_A_para->SetParameterRange("A_isotope > 1");
241 old_A_para->SetGuidance("A: mass number of isotope");
242 G4UIparameter* old_FileName_para= new G4UIparameter("file_name",'s',true);
243 old_FileName_para->SetGuidance("Name of the user data file");
244 old_userDecayDataCmd->SetParameter(old_Z_para);
245 old_userDecayDataCmd->SetParameter(old_A_para);
246 old_userDecayDataCmd->SetParameter(old_FileName_para);
247
248 userDecayDataCmd = new G4UIcommand("/process/had/rdm/setRadioactiveDecayFile",this);
249 G4UIparameter* Z_para= new G4UIparameter("Z_isotope",'i',true);
250 Z_para->SetParameterRange("Z_isotope > 0");
251 Z_para->SetGuidance("Z: Charge number of isotope");
252 G4UIparameter* A_para= new G4UIparameter("A_isotope",'i',true);
253 A_para->SetParameterRange("A_isotope > 1");
254 A_para->SetGuidance("A: mass number of isotope");
255 G4UIparameter* FileName_para= new G4UIparameter("file_name",'s',true);
256 FileName_para->SetGuidance("Name of the user data file");
257 userDecayDataCmd->SetParameter(Z_para);
258 userDecayDataCmd->SetParameter(A_para);
259 userDecayDataCmd->SetParameter(FileName_para);
260
261 // This commands allows the user to define its own evaporation data file for a given isotope
262 old_userEvaporationDataCmd = new G4UIcommand("/grdm/setPhotoEvaporationFile",this); // To be removed in G4 11.0
263 G4UIparameter* old_Z_para_ = new G4UIparameter("Z_isotope",'i',true);
264 old_Z_para_->SetParameterRange("Z_isotope > 0");
265 old_Z_para_->SetGuidance("Z: Charge number of isotope");
266 G4UIparameter* old_A_para_ = new G4UIparameter("A_isotope",'i',true);
267 old_A_para_->SetParameterRange("A_isotope > 1");
268 old_A_para_->SetGuidance("A: mass number of isotope");
269 G4UIparameter* old_FileName_para_ = new G4UIparameter("file_name",'s',true);
270 old_FileName_para_->SetGuidance("Name of the user data file");
271 old_userEvaporationDataCmd->SetParameter(old_Z_para_);
272 old_userEvaporationDataCmd->SetParameter(old_A_para_);
273 old_userEvaporationDataCmd->SetParameter(old_FileName_para_);
274
275 userEvaporationDataCmd = new G4UIcommand("/process/had/rdm/setPhotoEvaporationFile",this);
276 G4UIparameter* Z_para_ = new G4UIparameter("Z_isotope",'i',true);
277 Z_para_->SetParameterRange("Z_isotope > 0");
278 Z_para_->SetGuidance("Z: Charge number of isotope");
279 G4UIparameter* A_para_ = new G4UIparameter("A_isotope",'i',true);
280 A_para_->SetParameterRange("A_isotope > 1");
281 A_para_->SetGuidance("A: mass number of isotope");
282 G4UIparameter* FileName_para_ = new G4UIparameter("file_name",'s',true);
283 FileName_para_->SetGuidance("Name of the user data file");
284 userEvaporationDataCmd->SetParameter(Z_para_);
285 userEvaporationDataCmd->SetParameter(A_para_);
286 userEvaporationDataCmd->SetParameter(FileName_para_);
287
288}
289////////////////////////////////////////////////////////////////////////////////
290//
292{
293 delete old_grdmDirectory; // To be removed in G4 11.0
294 delete rdmDirectory;
295 delete old_nucleuslimitsCmd; // To be removed in G4 11.0
296 delete nucleuslimitsCmd;
297 delete old_sourcetimeprofileCmd; // To be removed in G4 11.0
298 delete sourcetimeprofileCmd;
299 delete old_decaybiasprofileCmd; // To be removed in G4 11.0
300 delete decaybiasprofileCmd;
301 delete old_analoguemcCmd; // To be removed in G4 11.0
302 delete analoguemcCmd;
303 delete old_fbetaCmd; // To be removed in G4 11.0
304 delete fbetaCmd;
305 delete old_brbiasCmd; // To be removed in G4 11.0
306 delete brbiasCmd;
307 delete old_splitnucleiCmd; // To be removed in G4 11.0
308 delete splitnucleiCmd;
309 delete old_verboseCmd; // To be removed in G4 11.0
310 delete verboseCmd;
311 delete old_avolumeCmd; // To be removed in G4 11.0
312 delete avolumeCmd;
313 delete old_deavolumeCmd; // To be removed in G4 11.0
314 delete deavolumeCmd;
315 delete old_allvolumesCmd; // To be removed in G4 11.0
316 delete allvolumesCmd;
317 delete old_deallvolumesCmd; // To be removed in G4 11.0
318 delete deallvolumesCmd;
319 delete old_icmCmd; // To be removed in G4 11.0
320 delete icmCmd;
321 delete old_armCmd; // To be removed in G4 11.0
322 delete armCmd;
323 delete old_hlthCmd; // To be removed in G4 11.0
324 delete hlthCmd;
325 delete old_userDecayDataCmd; // To be removed in G4 11.0
326 delete userDecayDataCmd;
327 delete old_userEvaporationDataCmd; // To be removed in G4 11.0
328 delete userEvaporationDataCmd;
329 delete old_colldirCmd; // To be removed in G4 11.0
330 delete colldirCmd;
331 delete old_collangleCmd; // To be removed in G4 11.0
332 delete collangleCmd;
333}
334////////////////////////////////////////////////////////////////////////////////
335//
337{
338 // Old commands to be removed in G4 11.0
339 if ( command == old_nucleuslimitsCmd ) {
340 theRadioactiveDecayContainer->
341 SetNucleusLimits( old_nucleuslimitsCmd->GetNewNucleusLimitsValue( newValues ) );
343 ed << "This command is valid but deprecated and will be replaced with the command:\n"
344 << "/process/had/rdm/nucleusLimits in the next major release, Geant4 version 11.0";
345 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_771", JustWarning, ed );
346 } else if ( command == old_analoguemcCmd ) {
347 theRadioactiveDecayContainer->
348 SetAnalogueMonteCarlo( old_analoguemcCmd->GetNewBoolValue( newValues ) );
350 ed << "This command is valid but deprecated and will be replaced with the command:\n"
351 << "/process/had/rdm/analogueMC in the next major release, Geant4 version 11.0";
352 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_772", JustWarning, ed );
353 } else if ( command == old_fbetaCmd ) {
354 theRadioactiveDecayContainer->SetFBeta( old_fbetaCmd->GetNewBoolValue( newValues ) );
356 ed << "This command is valid but deprecated and will be replaced with the command:\n"
357 << "/process/had/rdm/fBeta in the next major release, Geant4 version 11.0";
358 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_773", JustWarning, ed );
359 } else if ( command == old_avolumeCmd ) {
360 theRadioactiveDecayContainer->SelectAVolume( newValues );
362 ed << "This command is valid but deprecated and will be replaced with the command:\n"
363 << "/process/had/rdm/selectVolume in the next major release, Geant4 version 11.0";
364 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_774", JustWarning, ed );
365 } else if ( command == old_deavolumeCmd ) {
366 theRadioactiveDecayContainer->DeselectAVolume( newValues );
368 ed << "This command is valid but deprecated and will be replaced with the command:\n"
369 << "/process/had/rdm/deselectVolume in the next major release, Geant4 version 11.0";
370 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_775", JustWarning, ed );
371 } else if ( command == old_allvolumesCmd ) {
372 theRadioactiveDecayContainer->SelectAllVolumes();
374 ed << "This command is valid but deprecated and will be replaced with the command:\n"
375 << "/process/had/rdm/allVolumes in the next major release, Geant4 version 11.0";
376 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_776", JustWarning, ed );
377 } else if ( command == old_deallvolumesCmd ) {
378 theRadioactiveDecayContainer->DeselectAllVolumes();
380 ed << "This command is valid but deprecated and will be replaced with the command:\n"
381 << "/process/had/rdm/noVolumes in the next major release, Geant4 version 11.0";
382 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_777", JustWarning, ed );
383 } else if ( command == old_brbiasCmd ) {
384 theRadioactiveDecayContainer->SetBRBias( old_brbiasCmd->GetNewBoolValue( newValues ) );
386 ed << "This command is valid but deprecated and will be replaced with the command:\n"
387 << "/process/had/rdm/BRbias in the next major release, Geant4 version 11.0";
388 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_778", JustWarning, ed );
389 } else if ( command == old_sourcetimeprofileCmd ) {
390 theRadioactiveDecayContainer->SetSourceTimeProfile( newValues );
392 ed << "This command is valid but deprecated and will be replaced with the command:\n"
393 << "/process/had/rdm/sourceTimeProfile in the next major release, Geant4 version 11.0";
394 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_779", JustWarning, ed );
395 } else if ( command == old_decaybiasprofileCmd ) {
396 theRadioactiveDecayContainer->SetDecayBias( newValues );
398 ed << "This command is valid but deprecated and will be replaced with the command:\n"
399 << "/process/had/rdm/decayBiasProfile in the next major release, Geant4 version 11.0";
400 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_780", JustWarning, ed );
401 } else if ( command == old_splitnucleiCmd ) {
402 theRadioactiveDecayContainer->SetSplitNuclei( old_splitnucleiCmd->GetNewIntValue( newValues ) );
404 ed << "This command is valid but deprecated and will be replaced with the command:\n"
405 << "/process/had/rdm/splitNuclei in the next major release, Geant4 version 11.0";
406 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_781", JustWarning, ed );
407 } else if ( command == old_verboseCmd ) {
408 theRadioactiveDecayContainer->SetVerboseLevel( old_verboseCmd->GetNewIntValue( newValues ) );
410 ed << "This command is valid but deprecated and will be replaced with the command:\n"
411 << "/process/had/rdm/verbose in the next major release, Geant4 version 11.0";
412 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_782", JustWarning, ed );
413 } else if ( command == old_icmCmd ) {
414 theRadioactiveDecayContainer->SetICM( old_icmCmd->GetNewBoolValue( newValues ) );
416 ed << "This command is valid but deprecated and will be replaced with the command:\n"
417 << "/process/had/rdm/applyICM in the next major release, Geant4 version 11.0";
418 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_783", JustWarning, ed );
419 } else if ( command == old_armCmd ) {
420 theRadioactiveDecayContainer->SetARM( old_armCmd->GetNewBoolValue( newValues ) );
422 ed << "This command is valid but deprecated and will be replaced with the command:\n"
423 << "/process/had/rdm/applyARM in the next major release, Geant4 version 11.0";
424 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_784", JustWarning, ed );
425 } else if ( command == old_hlthCmd ) {
426 theRadioactiveDecayContainer->SetHLThreshold( old_hlthCmd->GetNewDoubleValue( newValues ) );
428 ed << "This command is valid but deprecated and will be replaced with the command:\n"
429 << "/process/had/rdm/hlThreshold in the next major release, Geant4 version 11.0";
430 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_785", JustWarning, ed );
431 } else if ( command == old_userDecayDataCmd ) {
432 G4int Z,A;
433 G4String file_name;
434 const char* nv = (const char*)newValues;
435 std::istringstream is(nv);
436 is >> Z >> A >> file_name;
437 theRadioactiveDecayContainer->AddUserDecayDataFile(Z,A,file_name);
439 ed << "This command is valid but deprecated and will be replaced with the command:\n"
440 << "/process/had/rdm/setRadioactiveDecayFile in the next major release, Geant4 version 11.0";
441 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_786", JustWarning, ed );
442 } else if ( command == old_userEvaporationDataCmd ) {
443 G4int Z,A;
444 G4String file_name;
445 const char* nv = (const char*)newValues;
446 std::istringstream is(nv);
447 is >> Z >> A >> file_name;
450 ed << "This command is valid but deprecated and will be replaced with the command:\n"
451 << "/process/had/rdm/setPhotoEvaporationFile in the next major release, Geant4 version 11.0";
452 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_787", JustWarning, ed );
453 } else if ( command == old_colldirCmd ) {
454 theRadioactiveDecayContainer->SetDecayDirection( old_colldirCmd->GetNew3VectorValue( newValues ) );
456 ed << "This command is valid but deprecated and will be replaced with the command:\n"
457 << "/process/had/rdm/decayDirection in the next major release, Geant4 version 11.0";
458 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_788", JustWarning, ed );
459 } else if ( command == old_collangleCmd ) {
460 theRadioactiveDecayContainer->SetDecayHalfAngle( old_collangleCmd->GetNewDoubleValue( newValues ) );
462 ed << "This command is valid but deprecated and will be replaced with the command:\n"
463 << "/process/had/rdm/decayHalfAngle in the next major release, Geant4 version 11.0";
464 G4Exception( "G4RadioactiveDecaymessenger", "HAD_RDM_789", JustWarning, ed );
465 }
466
467 // New commands
468 if ( command == nucleuslimitsCmd ) {
469 theRadioactiveDecayContainer->
470 SetNucleusLimits( nucleuslimitsCmd->GetNewNucleusLimitsValue( newValues ) );
471 } else if ( command == analoguemcCmd ) {
472 theRadioactiveDecayContainer->
473 SetAnalogueMonteCarlo( analoguemcCmd->GetNewBoolValue( newValues ) );
474 } else if ( command == fbetaCmd ) {
475 theRadioactiveDecayContainer->SetFBeta( fbetaCmd->GetNewBoolValue( newValues ) );
476 } else if ( command == avolumeCmd ) {
477 theRadioactiveDecayContainer->SelectAVolume( newValues );
478 } else if ( command == deavolumeCmd ) {
479 theRadioactiveDecayContainer->DeselectAVolume( newValues );
480 } else if ( command == allvolumesCmd ) {
481 theRadioactiveDecayContainer->SelectAllVolumes();
482 } else if ( command == deallvolumesCmd ) {
483 theRadioactiveDecayContainer->DeselectAllVolumes();
484 } else if ( command == brbiasCmd ) {
485 theRadioactiveDecayContainer->SetBRBias( brbiasCmd->GetNewBoolValue( newValues ) );
486 } else if ( command == sourcetimeprofileCmd ) {
487 theRadioactiveDecayContainer->SetSourceTimeProfile( newValues );
488 } else if ( command == decaybiasprofileCmd ) {
489 theRadioactiveDecayContainer->SetDecayBias( newValues );
490 } else if ( command == splitnucleiCmd ) {
491 theRadioactiveDecayContainer->SetSplitNuclei( splitnucleiCmd->GetNewIntValue( newValues ) );
492 } else if ( command == verboseCmd ) {
493 theRadioactiveDecayContainer->SetVerboseLevel( verboseCmd->GetNewIntValue( newValues ) );
494 } else if ( command == icmCmd ) {
495 theRadioactiveDecayContainer->SetICM( icmCmd->GetNewBoolValue( newValues ) );
496 } else if ( command == armCmd ) {
497 theRadioactiveDecayContainer->SetARM( armCmd->GetNewBoolValue( newValues ) );
498 } else if ( command == hlthCmd ) {
499 theRadioactiveDecayContainer->SetHLThreshold( hlthCmd->GetNewDoubleValue( newValues ) );
500 } else if ( command == userDecayDataCmd ) {
501 G4int Z,A;
502 G4String file_name;
503 const char* nv = (const char*)newValues;
504 std::istringstream is(nv);
505 is >> Z >> A >> file_name;
506 theRadioactiveDecayContainer->AddUserDecayDataFile(Z,A,file_name);
507 } else if ( command == userEvaporationDataCmd ) {
508 G4int Z,A;
509 G4String file_name;
510 const char* nv = (const char*)newValues;
511 std::istringstream is(nv);
512 is >> Z >> A >> file_name;
514 } else if ( command == colldirCmd ) {
515 theRadioactiveDecayContainer->SetDecayDirection( colldirCmd->GetNew3VectorValue( newValues ) );
516 } else if ( command == collangleCmd ) {
517 theRadioactiveDecayContainer->SetDecayHalfAngle( collangleCmd->GetNewDoubleValue( newValues ) );
518 }
519}
520
521
522
523
524
525
double A(double temperature)
@ JustWarning
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
int G4int
Definition: G4Types.hh:85
G4bool AddPrivateData(G4int Z, G4int A, const G4String &filename)
static G4NuclearLevelData * GetInstance()
void DeselectAVolume(const G4String aVolume)
void SetSplitNuclei(G4int r)
void SetVerboseLevel(G4int value)
void SetSourceTimeProfile(G4String filename)
void SetDecayBias(G4String filename)
void SetICM(G4bool icm)
void SetBRBias(G4bool r)
void SelectAVolume(const G4String aVolume)
void SetDecayHalfAngle(G4double halfAngle=0.*CLHEP::deg)
void SetDecayDirection(const G4ThreeVector &theDir)
void SetARM(G4bool arm)
void SetHLThreshold(G4double hl)
void AddUserDecayDataFile(G4int Z, G4int A, G4String filename)
G4RadioactiveDecaymessenger(G4RadioactiveDecay *theRadioactiveDecayContainer)
void SetNewValue(G4UIcommand *command, G4String newValues)
static G4ThreeVector GetNew3VectorValue(const char *paramString)
void SetParameterName(const char *theNameX, const char *theNameY, const char *theNameZ, G4bool omittable, G4bool currentAsDefault=false)
static G4bool GetNewBoolValue(const char *paramString)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
void SetDefaultValue(G4bool defVal)
void SetUnitCategory(const char *unitCategory)
static G4double GetNewDoubleValue(const char *paramString)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
void SetDefaultValue(const char *defVal)
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
static G4int GetNewIntValue(const char *paramString)
void SetDefaultValue(G4int defVal)
G4NucleusLimits GetNewNucleusLimitsValue(G4String paramString)
void SetParameterName(const char *theNameAMin, const char *theNameAMax, const char *theNameZMin, const char *theNameZMax, G4bool omittable, G4bool currentAsDefault=true)
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:146
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:156
void SetRange(const char *rs)
Definition: G4UIcommand.hh:120
void SetGuidance(const char *theGuidance)
void SetParameterRange(const char *theRange)