LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
Public Member Functions | Private Attributes | List of all members
G4EmStandardPhysics_pseudoLaser Class Reference

#include "G4EmStandardPhysics_pseudoLaser.hh"

Inheritance diagram for G4EmStandardPhysics_pseudoLaser:

Public Member Functions

 G4EmStandardPhysics_pseudoLaser (G4int ver=1, const G4String &name="")
 
virtual ~G4EmStandardPhysics_pseudoLaser ()
 
virtual void ConstructParticle ()
 
virtual void ConstructProcess ()
 

Private Attributes

G4int verbose
 
G4EmParticleList partList
 

Detailed Description

Definition at line 10 of file G4EmStandardPhysics_pseudoLaser.hh.

Constructor & Destructor Documentation

G4EmStandardPhysics_pseudoLaser::G4EmStandardPhysics_pseudoLaser ( G4int  ver = 1,
const G4String &  name = "" 
)
explicit

Definition at line 74 of file G4EmStandardPhysics_pseudoLaser.cc.

References verbose.

75  : G4VPhysicsConstructor("G4EmStandard_pseudoLaser"), verbose(ver)
76 {
77  G4EmParameters* param = G4EmParameters::Instance();
78  param->SetDefaults();
79  param->SetVerbose(verbose);
80  SetPhysicsType(bElectromagnetic);
81  G4cout << "############# mu+ will be used to simulate the ionization laser!!!!! ##############\n";
82 }
G4EmStandardPhysics_pseudoLaser::verbose
G4int verbose
Definition: G4EmStandardPhysics_pseudoLaser.hh:22
G4EmStandardPhysics_pseudoLaser::~G4EmStandardPhysics_pseudoLaser ( )
virtual

Definition at line 86 of file G4EmStandardPhysics_pseudoLaser.cc.

87 {}

Member Function Documentation

void G4EmStandardPhysics_pseudoLaser::ConstructParticle ( )
virtual

Definition at line 91 of file G4EmStandardPhysics_pseudoLaser.cc.

References G4PseudoLaser::PseudoLaser().

92 {
93  // gamma
94  G4Gamma::Gamma();
95 
96  // leptons
97  G4Electron::Electron();
98  G4Positron::Positron();
99  G4MuonPlus::MuonPlus();
100  G4MuonMinus::MuonMinus();
101  G4PseudoLaser::PseudoLaser();
102 
103  // mesons
104  G4PionPlus::PionPlusDefinition();
105  G4PionMinus::PionMinusDefinition();
106  G4KaonPlus::KaonPlusDefinition();
107  G4KaonMinus::KaonMinusDefinition();
108 
109  // barions
110  G4Proton::Proton();
111  G4AntiProton::AntiProton();
112 
113  // ions
114  G4Deuteron::Deuteron();
115  G4Triton::Triton();
116  G4He3::He3();
117  G4Alpha::Alpha();
118  G4GenericIon::GenericIonDefinition();
119 }
G4PseudoLaser::PseudoLaser
static G4PseudoLaser * PseudoLaser()
Definition: G4PseudoLaser.cc:66
void G4EmStandardPhysics_pseudoLaser::ConstructProcess ( )
virtual

Definition at line 123 of file G4EmStandardPhysics_pseudoLaser.cc.

References partList, and verbose.

124 {
125  if(verbose > 1) {
126  G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
127  }
128  G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
129  G4LossTableManager* man = G4LossTableManager::Instance();
130 
131  // muon & hadron bremsstrahlung and pair production
132  G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
133  G4MuPairProduction* mup = new G4MuPairProduction();
134  G4hBremsstrahlung* pib = new G4hBremsstrahlung();
135  G4hPairProduction* pip = new G4hPairProduction();
136  G4hBremsstrahlung* kb = new G4hBremsstrahlung();
137  G4hPairProduction* kp = new G4hPairProduction();
138  G4hBremsstrahlung* pb = new G4hBremsstrahlung();
139  G4hPairProduction* pp = new G4hPairProduction();
140 
141  // muon & hadron multiple scattering
142  G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
143  mumsc->SetEmModel(new G4WentzelVIModel());
144  G4CoulombScattering* muss = new G4CoulombScattering();
145 
146  G4hMultipleScattering* pimsc = new G4hMultipleScattering();
147  pimsc->SetEmModel(new G4WentzelVIModel());
148  G4CoulombScattering* piss = new G4CoulombScattering();
149 
150  G4hMultipleScattering* kmsc = new G4hMultipleScattering();
151  kmsc->SetEmModel(new G4WentzelVIModel());
152  G4CoulombScattering* kss = new G4CoulombScattering();
153 
154  G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
155 
156  // high energy limit for e+- scattering models
157  G4double highEnergyLimit = G4EmParameters::Instance()->MscEnergyLimit();
158 
159  // Add standard EM Processes
160  G4ParticleTable* table = G4ParticleTable::GetParticleTable();
161  for(const auto& particleName : partList.PartNames()) {
162  G4ParticleDefinition* particle = table->FindParticle(particleName);
163  if (!particle) { continue; }
164  if (particleName == "gamma") {
165 
166  G4PhotoElectricEffect* pee = new G4PhotoElectricEffect();
167  pee->SetEmModel(new G4LivermorePhotoElectricModel());
168 
169  if(G4EmParameters::Instance()->GeneralProcessActive()) {
170  G4GammaGeneralProcess* sp = new G4GammaGeneralProcess();
171  sp->AddEmProcess(pee);
172  sp->AddEmProcess(new G4ComptonScattering());
173  sp->AddEmProcess(new G4GammaConversion());
174  sp->AddEmProcess(new G4RayleighScattering());
175  man->SetGammaGeneralProcess(sp);
176  ph->RegisterProcess(sp, particle);
177 
178  } else {
179  ph->RegisterProcess(pee, particle);
180  ph->RegisterProcess(new G4ComptonScattering(), particle);
181  ph->RegisterProcess(new G4GammaConversion(), particle);
182  ph->RegisterProcess(new G4RayleighScattering(), particle);
183  }
184 
185  } else if (particleName == "e-") {
186 
187  G4eMultipleScattering* msc = new G4eMultipleScattering;
188  G4UrbanMscModel* msc1 = new G4UrbanMscModel();
189  G4WentzelVIModel* msc2 = new G4WentzelVIModel();
190  msc1->SetHighEnergyLimit(highEnergyLimit);
191  msc2->SetLowEnergyLimit(highEnergyLimit);
192  msc->SetEmModel(msc1);
193  msc->SetEmModel(msc2);
194 
195  G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
196  G4CoulombScattering* ss = new G4CoulombScattering();
197  ss->SetEmModel(ssm);
198  ss->SetMinKinEnergy(highEnergyLimit);
199  ssm->SetLowEnergyLimit(highEnergyLimit);
200  ssm->SetActivationLowEnergyLimit(highEnergyLimit);
201 
202  ph->RegisterProcess(msc, particle);
203  ph->RegisterProcess(new G4eIonisation(), particle);
204  ph->RegisterProcess(new G4eBremsstrahlung(), particle);
205  ph->RegisterProcess(ss, particle);
206 
207  } else if (particleName == "e+") {
208 
209  G4eMultipleScattering* msc = new G4eMultipleScattering;
210  G4UrbanMscModel* msc1 = new G4UrbanMscModel();
211  G4WentzelVIModel* msc2 = new G4WentzelVIModel();
212  msc1->SetHighEnergyLimit(highEnergyLimit);
213  msc2->SetLowEnergyLimit(highEnergyLimit);
214  msc->SetEmModel(msc1);
215  msc->SetEmModel(msc2);
216 
217  G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
218  G4CoulombScattering* ss = new G4CoulombScattering();
219  ss->SetEmModel(ssm);
220  ss->SetMinKinEnergy(highEnergyLimit);
221  ssm->SetLowEnergyLimit(highEnergyLimit);
222  ssm->SetActivationLowEnergyLimit(highEnergyLimit);
223 
224  ph->RegisterProcess(msc, particle);
225  ph->RegisterProcess(new G4eIonisation(), particle);
226  ph->RegisterProcess(new G4eBremsstrahlung(), particle);
227  ph->RegisterProcess(new G4eplusAnnihilation(), particle);
228  ph->RegisterProcess(ss, particle);
229 
230  } else if (particleName == "mu-" ) {
231 
232  ph->RegisterProcess(mumsc, particle);
233  ph->RegisterProcess(new G4MuIonisation(), particle);
234  ph->RegisterProcess(mub, particle);
235  ph->RegisterProcess(mup, particle);
236  ph->RegisterProcess(muss, particle);
237 
238  // -- distinguish the muplus for substitue of a laser
239  } else if (particleName == "mu+") {
240 
241  // -- mu+ will ionize ONLY
242  G4cout << "##### Turning off Multiple scattering, Coulomb Scattering, Pair Prodution, and Bremstrahlung for mu+!!!\n";
243  ph->RegisterProcess(new G4MuIonisation(), particle); // -- ionization
244  //ph->RegisterProcess(new MyG4MuIonisationNoDelta(), particle); // -- ionization
245  // -- turn off Multiple scattering, bremstrahlung, pair production, and Coulomb scattering
246  ph->RegisterProcess(mumsc, particle); // -- multiple scattering
247  ph->RegisterProcess(mub, particle); // -- bremmstrahlung
248  ph->RegisterProcess(mup, particle); // -- pair production
249  ph->RegisterProcess(muss, particle); // -- Coulomb scattering
250 
251  } else if (particleName == "alpha" ||
252  particleName == "He3") {
253 
254  ph->RegisterProcess(new G4hMultipleScattering(), particle);
255  ph->RegisterProcess(new G4ionIonisation(), particle);
256 
257  } else if (particleName == "GenericIon") {
258 
259  ph->RegisterProcess(hmsc, particle);
260  ph->RegisterProcess(new G4ionIonisation(), particle);
261 
262  } else if (particleName == "pi+" ||
263  particleName == "pi-" ) {
264 
265  ph->RegisterProcess(pimsc, particle);
266  ph->RegisterProcess(new G4hIonisation(), particle);
267  ph->RegisterProcess(pib, particle);
268  ph->RegisterProcess(pip, particle);
269  ph->RegisterProcess(piss, particle);
270 
271  } else if (particleName == "kaon+" ||
272  particleName == "kaon-" ) {
273 
274  ph->RegisterProcess(kmsc, particle);
275  ph->RegisterProcess(new G4hIonisation(), particle);
276  ph->RegisterProcess(kb, particle);
277  ph->RegisterProcess(kp, particle);
278  ph->RegisterProcess(kss, particle);
279 
280  } else if (particleName == "proton" ||
281  particleName == "anti_proton") {
282 
283  G4hMultipleScattering* pmsc = new G4hMultipleScattering();
284  pmsc->SetEmModel(new G4WentzelVIModel());
285 
286  ph->RegisterProcess(pmsc, particle);
287  ph->RegisterProcess(new G4hIonisation(), particle);
288  ph->RegisterProcess(pb, particle);
289  ph->RegisterProcess(pp, particle);
290  ph->RegisterProcess(new G4CoulombScattering(), particle);
291 
292  } else if (particleName == "B+" ||
293  particleName == "B-" ||
294  particleName == "D+" ||
295  particleName == "D-" ||
296  particleName == "Ds+" ||
297  particleName == "Ds-" ||
298  particleName == "anti_He3" ||
299  particleName == "anti_alpha" ||
300  particleName == "anti_deuteron" ||
301  particleName == "anti_lambda_c+" ||
302  particleName == "anti_omega-" ||
303  particleName == "anti_sigma_c+" ||
304  particleName == "anti_sigma_c++" ||
305  particleName == "anti_sigma+" ||
306  particleName == "anti_sigma-" ||
307  particleName == "anti_triton" ||
308  particleName == "anti_xi_c+" ||
309  particleName == "anti_xi-" ||
310  particleName == "deuteron" ||
311  particleName == "lambda_c+" ||
312  particleName == "omega-" ||
313  particleName == "sigma_c+" ||
314  particleName == "sigma_c++" ||
315  particleName == "sigma+" ||
316  particleName == "sigma-" ||
317  particleName == "tau+" ||
318  particleName == "tau-" ||
319  particleName == "triton" ||
320  particleName == "xi_c+" ||
321  particleName == "xi-" ) {
322 
323  ph->RegisterProcess(hmsc, particle);
324  ph->RegisterProcess(new G4hIonisation(), particle);
325  }
326  }
327 
328  //Find the mulaser particle by hand
329  G4ParticleDefinition* particle = table->FindParticle("mulaser");
330  ph->RegisterProcess(new MyG4MuIonisationNoDelta(), particle); // -- ionization
331 
332  // Deexcitation
333  //
334  man->SetAtomDeexcitation(new G4UAtomicDeexcitation());
335 
336  G4EmModelActivator mact(GetPhysicsName());
337 }
G4EmStandardPhysics_pseudoLaser::partList
G4EmParticleList partList
Definition: G4EmStandardPhysics_pseudoLaser.hh:23
G4EmStandardPhysics_pseudoLaser::verbose
G4int verbose
Definition: G4EmStandardPhysics_pseudoLaser.hh:22

Member Data Documentation

G4EmParticleList G4EmStandardPhysics_pseudoLaser::partList
private

Definition at line 23 of file G4EmStandardPhysics_pseudoLaser.hh.

Referenced by ConstructProcess().

G4int G4EmStandardPhysics_pseudoLaser::verbose
private

Definition at line 22 of file G4EmStandardPhysics_pseudoLaser.hh.

Referenced by ConstructProcess(), and G4EmStandardPhysics_pseudoLaser().

The documentation for this class was generated from the following files: