source: ELYSE/HEAD/source/PhysicsList.cxx@ 626

Last change on this file since 626 was 286, checked in by campagne, 19 years ago

ELYSE sauvegarde provisoire (JEC)
File size: 22.7 KB
Line 
1//this
2#include "ELYSE/PhysicsList.hh"
3
4//Geant 4
5#include "G4EmStandardPhysics.hh"
6#include "G4EmStandardPhysics71.hh"
7#include "G4LossTableManager.hh"
8#include "G4UnitsTable.hh"
9
10#include "G4Cerenkov.hh"
11#include "G4Scintillation.hh"
12#include "G4OpAbsorption.hh"
13#include "G4OpRayleigh.hh"
14#include "G4OpBoundaryProcess.hh"
15
16
17// Bosons
18#include "G4ChargedGeantino.hh"
19#include "G4Geantino.hh"
20#include "G4Gamma.hh"
21#include "G4OpticalPhoton.hh"
22
23// leptons
24#include "G4MuonPlus.hh"
25#include "G4MuonMinus.hh"
26#include "G4NeutrinoMu.hh"
27#include "G4AntiNeutrinoMu.hh"
28
29#include "G4Electron.hh"
30#include "G4Positron.hh"
31#include "G4NeutrinoE.hh"
32#include "G4AntiNeutrinoE.hh"
33
34// Mesons
35#include "G4PionPlus.hh"
36#include "G4PionMinus.hh"
37#include "G4PionZero.hh"
38#include "G4Eta.hh"
39#include "G4EtaPrime.hh"
40
41#include "G4KaonPlus.hh"
42#include "G4KaonMinus.hh"
43#include "G4KaonZero.hh"
44#include "G4AntiKaonZero.hh"
45#include "G4KaonZeroLong.hh"
46#include "G4KaonZeroShort.hh"
47
48// Baryons
49#include "G4Proton.hh"
50#include "G4AntiProton.hh"
51#include "G4Neutron.hh"
52#include "G4AntiNeutron.hh"
53
54// Nuclei
55#include "G4Deuteron.hh"
56#include "G4Triton.hh"
57#include "G4Alpha.hh"
58#include "G4GenericIon.hh"
59
60#include "G4Gamma.hh"
61#include "G4Electron.hh"
62#include "G4Positron.hh"
63
64
65//ELYSE
66#include "ELYSE/PhysicsListMessenger.hh"
67#include "ELYSE/PhysListEmStandard.hh"
68#include "ELYSE/PhysListEmLivermore.hh"
69#include "ELYSE/PhysListEmPenelope.hh"
70
71
72//----------------------------------------------------------------------
73
74ELYSE::PhysicsList::PhysicsList() : G4VModularPhysicsList(),
75 theCerenkovProcess(0),
76 theScintillationProcess(0),
77 theAbsorptionProcess(0),
78 theRayleighScatteringProcess(0),
79 theBoundaryProcess(0)
80 {
81 G4LossTableManager::Instance();
82 currentDefaultCut = 1.0*mm;
83 cutForGamma = currentDefaultCut;
84 cutForElectron = currentDefaultCut;
85 cutForPositron = currentDefaultCut;
86
87 pMessenger = new PhysicsListMessenger(this);
88
89 SetVerboseLevel(1);
90
91 // EM physics
92 emName = G4String("standard");
93 emPhysicsList = new PhysListEmStandard(emName);
94
95}
96
97//----------------------------------------------------------------------
98
99ELYSE::PhysicsList::~PhysicsList() {
100 delete pMessenger;
101}
102
103//----------------------------------------------------------------------
104
105
106void ELYSE::PhysicsList::ConstructParticle() {
107// pseudo-particles
108 G4Geantino::GeantinoDefinition();
109 G4ChargedGeantino::ChargedGeantinoDefinition();
110
111// gamma
112 G4Gamma::GammaDefinition();
113
114// optical photon
115 G4OpticalPhoton::OpticalPhotonDefinition();
116
117// leptons
118 G4Electron::ElectronDefinition();
119 G4Positron::PositronDefinition();
120 G4MuonPlus::MuonPlusDefinition();
121 G4MuonMinus::MuonMinusDefinition();
122
123 G4NeutrinoE::NeutrinoEDefinition();
124 G4AntiNeutrinoE::AntiNeutrinoEDefinition();
125 G4NeutrinoMu::NeutrinoMuDefinition();
126 G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
127
128// mesons
129 G4PionPlus::PionPlusDefinition();
130 G4PionMinus::PionMinusDefinition();
131 G4PionZero::PionZeroDefinition();
132 G4Eta::EtaDefinition();
133 G4EtaPrime::EtaPrimeDefinition();
134 G4KaonPlus::KaonPlusDefinition();
135 G4KaonMinus::KaonMinusDefinition();
136 G4KaonZero::KaonZeroDefinition();
137 G4AntiKaonZero::AntiKaonZeroDefinition();
138 G4KaonZeroLong::KaonZeroLongDefinition();
139 G4KaonZeroShort::KaonZeroShortDefinition();
140
141// barions
142 G4Proton::ProtonDefinition();
143 G4AntiProton::AntiProtonDefinition();
144 G4Neutron::NeutronDefinition();
145 G4AntiNeutron::AntiNeutronDefinition();
146
147// ions
148 G4Deuteron::DeuteronDefinition();
149 G4Triton::TritonDefinition();
150 G4Alpha::AlphaDefinition();
151 G4GenericIon::GenericIonDefinition();
152}
153
154//----------------------------------------------------------------------
155
156#include "G4ProcessManager.hh"
157#include "G4Decay.hh"
158
159void ELYSE::PhysicsList::ConstructProcess() {
160 AddTransportation();
161
162 // electromagnetic Physics List
163 //
164 emPhysicsList->ConstructProcess();
165
166 //Decay
167 ConstructGeneral();
168
169 //Optical Photons
170 ConstructOp();
171 //JEC 20/2/07 not useful? ConstructHad();
172 SetVerbose(0);
173
174}//ConstructProcess
175
176//--------------------------------------------------------------------------------------------------
177
178void ELYSE::PhysicsList::ConstructGeneral() {
179 // Add Decay Process
180 G4Decay* theDecayProcess = new G4Decay();
181 theParticleIterator->reset();
182 while( (*theParticleIterator)() ){
183 G4ParticleDefinition* particle = theParticleIterator->value();
184 G4ProcessManager* pmanager = particle->GetProcessManager();
185 if (theDecayProcess->IsApplicable(*particle)) {
186 pmanager ->AddProcess(theDecayProcess);
187 // set ordering for PostStepDoIt and AtRestDoIt
188 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
189 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
190 }
191 }
192}//ConstructGeneral
193
194//-----------------------------------------------------------------------------------------------
195void ELYSE::PhysicsList::ConstructOp(){
196
197 theCerenkovProcess = new G4Cerenkov("Cerenkov");
198 theScintillationProcess = new G4Scintillation("Scintillation");
199 theAbsorptionProcess = new G4OpAbsorption();
200 theRayleighScatteringProcess = new G4OpRayleigh();
201 theBoundaryProcess = new G4OpBoundaryProcess();
202
203 /*
204 theCerenkovProcess->DumpPhysicsTable();
205 theScintillationProcess->DumpPhysicsTable();
206 theAbsorptionProcess->DumpPhysicsTable();
207 theRayleighScatteringProcess->DumpPhysicsTable();
208 */
209
210
211 theCerenkovProcess->SetTrackSecondariesFirst(false); //NV: if "true" generates as many trajectory objs of
212 theCerenkovProcess->SetMaxNumPhotonsPerStep(300); //op parents as the # of parents' steps.
213 //The number of photons may be tuned by the messenger
214
215 //JEC 19/2/07 theScintillationProcess->SetScintillationYieldFactor(1.);
216 theScintillationProcess->SetScintillationYieldFactor(0.);
217 theScintillationProcess->SetTrackSecondariesFirst(false);
218
219 G4OpticalSurfaceModel themodel = unified; //JEC where does it come from?
220 theBoundaryProcess->SetModel(themodel);
221
222 theParticleIterator->reset();
223 while( (*theParticleIterator)() )
224 {
225 G4ParticleDefinition* particle = theParticleIterator->value();
226 G4ProcessManager* pmanager = particle->GetProcessManager();
227 G4String particleName = particle->GetParticleName();
228
229 if (theCerenkovProcess->IsApplicable(*particle)) {
230 pmanager->AddContinuousProcess(theCerenkovProcess);
231 }
232
233 if (theScintillationProcess->IsApplicable(*particle)) {
234 pmanager->AddProcess(theScintillationProcess);
235 pmanager->SetProcessOrderingToLast(theScintillationProcess, idxAtRest);
236 pmanager->SetProcessOrderingToLast(theScintillationProcess, idxPostStep);
237 }
238
239 if (particleName == "opticalphoton") {
240 pmanager->AddDiscreteProcess(theAbsorptionProcess);
241 pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
242 pmanager->AddDiscreteProcess(theBoundaryProcess);
243 }
244 }
245}//ConstructOp
246
247//----------------------------------------------------------------------
248
249void ELYSE::PhysicsList::AddPhysicsList(const G4String& name) {
250 if (verboseLevel>1) {
251 G4cout << "ELYSE::PhysicsList::AddPhysicsList: <" << name << ">" << G4endl;
252 }
253
254 if (name == emName) return;
255
256 if (name == "standard") {
257
258 emName = name;
259 delete emPhysicsList;
260 emPhysicsList = new PhysListEmStandard(name);
261
262 } else if (name == "G4standard") {
263
264 emName = name;
265 delete emPhysicsList;
266 emPhysicsList = new G4EmStandardPhysics(name);
267
268 } else if (name == "G4standard_fast") {
269
270 emName = name;
271 delete emPhysicsList;
272 emPhysicsList = new G4EmStandardPhysics71(name);
273
274 } else if (name == "Livermore") {
275
276 emName = name;
277 delete emPhysicsList;
278 emPhysicsList = new PhysListEmLivermore(name);
279
280 } else if (name == "Penelope") {
281
282 emName = name;
283 delete emPhysicsList;
284 emPhysicsList = new PhysListEmPenelope(name);
285
286 } else {
287
288 G4cout << "ELYSE::PhysicsList::AddPhysicsList: <" << name << ">"
289 << " is not defined"
290 << G4endl;
291 }
292}
293
294//----------------------------------------------------------------------
295void ELYSE::PhysicsList::SetCuts()
296{
297
298 if (verboseLevel >0){
299 G4cout << "PhysicsList::SetCuts:";
300 G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;
301 }
302
303 // set cut values for gamma at first and for e- second and next for e+,
304 // because some processes for e+/e- need cut values for gamma
305 SetCutValue(cutForGamma, "gamma");
306 SetCutValue(cutForElectron, "e-");
307 SetCutValue(cutForPositron, "e+");
308
309 if (verboseLevel>0) DumpCutValuesTable();
310}
311
312//----------------------------------------------------------------------
313
314void ELYSE::PhysicsList::SetCutForGamma(G4double cut) {
315 cutForGamma = cut;
316 SetParticleCuts(cutForGamma, G4Gamma::Gamma());
317}
318
319//----------------------------------------------------------------------
320
321void ELYSE::PhysicsList::SetCutForElectron(G4double cut) {
322 cutForElectron = cut;
323 SetParticleCuts(cutForElectron, G4Electron::Electron());
324}
325
326//----------------------------------------------------------------------
327
328void ELYSE::PhysicsList::SetCutForPositron(G4double cut) {
329 cutForPositron = cut;
330 SetParticleCuts(cutForPositron, G4Positron::Positron());
331}
332
333//-------------------------------------------------------------------
334void ELYSE::PhysicsList::SetVerbose(G4int verbose) {
335
336 theCerenkovProcess->SetVerboseLevel(verbose);
337 theScintillationProcess->SetVerboseLevel(verbose);
338 theAbsorptionProcess->SetVerboseLevel(verbose);
339 theRayleighScatteringProcess->SetVerboseLevel(verbose);
340 theBoundaryProcess->SetVerboseLevel(verbose);
341
342}//SetVerbose
343//-------------------------------------------------------------------
344
345void ELYSE::PhysicsList::SetNbOfPhotonsCerenkov(G4int MaxNumber) {
346 theCerenkovProcess->SetMaxNumPhotonsPerStep(MaxNumber);
347}//SetNbOfPhotonsCerenkov
348
349
350//-----------------------------------------------------------------------------------------------
351
352// // Elastic processes:
353// #include "G4HadronElasticProcess.hh"
354
355// // Inelastic processes:
356// #include "G4PionPlusInelasticProcess.hh"
357// #include "G4PionMinusInelasticProcess.hh"
358// #include "G4KaonPlusInelasticProcess.hh"
359// #include "G4KaonZeroSInelasticProcess.hh"
360// #include "G4KaonZeroLInelasticProcess.hh"
361// #include "G4KaonMinusInelasticProcess.hh"
362// #include "G4ProtonInelasticProcess.hh"
363// #include "G4AntiProtonInelasticProcess.hh"
364// #include "G4NeutronInelasticProcess.hh"
365// #include "G4AntiNeutronInelasticProcess.hh"
366// #include "G4DeuteronInelasticProcess.hh"
367// #include "G4TritonInelasticProcess.hh"
368// #include "G4AlphaInelasticProcess.hh"
369
370// // Low-energy Models: < 20GeV
371// #include "G4LElastic.hh"
372// #include "G4LEPionPlusInelastic.hh"
373// #include "G4LEPionMinusInelastic.hh"
374// #include "G4LEKaonPlusInelastic.hh"
375// #include "G4LEKaonZeroSInelastic.hh"
376// #include "G4LEKaonZeroLInelastic.hh"
377// #include "G4LEKaonMinusInelastic.hh"
378// #include "G4LEProtonInelastic.hh"
379// #include "G4LEAntiProtonInelastic.hh"
380// #include "G4LENeutronInelastic.hh"
381// #include "G4LEAntiNeutronInelastic.hh"
382// #include "G4LEDeuteronInelastic.hh"
383// #include "G4LETritonInelastic.hh"
384// #include "G4LEAlphaInelastic.hh"
385
386// // High-energy Models: >20 GeV
387// #include "G4HEPionPlusInelastic.hh"
388// #include "G4HEPionMinusInelastic.hh"
389// #include "G4HEKaonPlusInelastic.hh"
390// #include "G4HEKaonZeroInelastic.hh"
391// #include "G4HEKaonZeroInelastic.hh"
392// #include "G4HEKaonMinusInelastic.hh"
393// #include "G4HEProtonInelastic.hh"
394// #include "G4HEAntiProtonInelastic.hh"
395// #include "G4HENeutronInelastic.hh"
396// #include "G4HEAntiNeutronInelastic.hh"
397
398// // Neutron high-precision models: <20 MeV
399// #include "G4NeutronHPElastic.hh"
400// #include "G4NeutronHPElasticData.hh"
401// #include "G4NeutronHPCapture.hh"
402// #include "G4NeutronHPCaptureData.hh"
403// #include "G4NeutronHPInelastic.hh"
404// #include "G4NeutronHPInelasticData.hh"
405// #include "G4LCapture.hh"
406
407// // Secondary hadronic interaction models
408// #include "G4CascadeInterface.hh"
409// #include "G4BinaryCascade.hh"
410
411// // Stopping processes
412// #include "G4PiMinusAbsorptionAtRest.hh"
413// #include "G4KaonMinusAbsorptionAtRest.hh"
414// #include "G4AntiProtonAnnihilationAtRest.hh"
415// #include "G4AntiNeutronAnnihilationAtRest.hh"
416
417// void ELYSE::PhysicsList::ConstructHad() {
418
419// // This code stolen from:
420// // examples/advanced/underground_physics/src/DMXPhysicsList.cc
421// // CWW 2/23/05
422// //
423
424// G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
425// G4LElastic* theElasticModel = new G4LElastic;
426// theElasticProcess->RegisterMe(theElasticModel);
427
428// theParticleIterator->reset();
429// while ((*theParticleIterator)())
430// {
431// G4ParticleDefinition* particle = theParticleIterator->value();
432// G4ProcessManager* pmanager = particle->GetProcessManager();
433// G4String particleName = particle->GetParticleName();
434
435// if (particleName == "pi+")
436// {
437// pmanager->AddDiscreteProcess(theElasticProcess);
438// G4PionPlusInelasticProcess* theInelasticProcess =
439// new G4PionPlusInelasticProcess();
440// G4LEPionPlusInelastic* theLEInelasticModel =
441// new G4LEPionPlusInelastic;
442// theInelasticProcess->RegisterMe(theLEInelasticModel);
443// G4HEPionPlusInelastic* theHEInelasticModel =
444// new G4HEPionPlusInelastic;
445// theInelasticProcess->RegisterMe(theHEInelasticModel);
446// pmanager->AddDiscreteProcess(theInelasticProcess);
447// }
448
449// else if (particleName == "pi-")
450// {
451// pmanager->AddDiscreteProcess(theElasticProcess);
452// G4PionMinusInelasticProcess* theInelasticProcess =
453// new G4PionMinusInelasticProcess();
454// G4LEPionMinusInelastic* theLEInelasticModel =
455// new G4LEPionMinusInelastic;
456// theInelasticProcess->RegisterMe(theLEInelasticModel);
457// G4HEPionMinusInelastic* theHEInelasticModel =
458// new G4HEPionMinusInelastic;
459// theInelasticProcess->RegisterMe(theHEInelasticModel);
460// pmanager->AddDiscreteProcess(theInelasticProcess);
461// G4String prcNam;
462// pmanager->AddRestProcess(new G4PiMinusAbsorptionAtRest, ordDefault);
463// }
464
465// else if (particleName == "kaon+")
466// {
467// pmanager->AddDiscreteProcess(theElasticProcess);
468// G4KaonPlusInelasticProcess* theInelasticProcess =
469// new G4KaonPlusInelasticProcess();
470// G4LEKaonPlusInelastic* theLEInelasticModel =
471// new G4LEKaonPlusInelastic;
472// theInelasticProcess->RegisterMe(theLEInelasticModel);
473// G4HEKaonPlusInelastic* theHEInelasticModel =
474// new G4HEKaonPlusInelastic;
475// theInelasticProcess->RegisterMe(theHEInelasticModel);
476// pmanager->AddDiscreteProcess(theInelasticProcess);
477// }
478
479// else if (particleName == "kaon0S")
480// {
481// pmanager->AddDiscreteProcess(theElasticProcess);
482// G4KaonZeroSInelasticProcess* theInelasticProcess =
483// new G4KaonZeroSInelasticProcess();
484// G4LEKaonZeroSInelastic* theLEInelasticModel =
485// new G4LEKaonZeroSInelastic;
486// theInelasticProcess->RegisterMe(theLEInelasticModel);
487// G4HEKaonZeroInelastic* theHEInelasticModel =
488// new G4HEKaonZeroInelastic;
489// theInelasticProcess->RegisterMe(theHEInelasticModel);
490// pmanager->AddDiscreteProcess(theInelasticProcess);
491// }
492
493// else if (particleName == "kaon0L")
494// {
495// pmanager->AddDiscreteProcess(theElasticProcess);
496// G4KaonZeroLInelasticProcess* theInelasticProcess =
497// new G4KaonZeroLInelasticProcess();
498// G4LEKaonZeroLInelastic* theLEInelasticModel =
499// new G4LEKaonZeroLInelastic;
500// theInelasticProcess->RegisterMe(theLEInelasticModel);
501// G4HEKaonZeroInelastic* theHEInelasticModel =
502// new G4HEKaonZeroInelastic;
503// theInelasticProcess->RegisterMe(theHEInelasticModel);
504// pmanager->AddDiscreteProcess(theInelasticProcess);
505// }
506
507// else if (particleName == "kaon-")
508// {
509// pmanager->AddDiscreteProcess(theElasticProcess);
510// G4KaonMinusInelasticProcess* theInelasticProcess =
511// new G4KaonMinusInelasticProcess();
512// G4LEKaonMinusInelastic* theLEInelasticModel =
513// new G4LEKaonMinusInelastic;
514// theInelasticProcess->RegisterMe(theLEInelasticModel);
515// G4HEKaonMinusInelastic* theHEInelasticModel =
516// new G4HEKaonMinusInelastic;
517// theInelasticProcess->RegisterMe(theHEInelasticModel);
518// pmanager->AddDiscreteProcess(theInelasticProcess);
519// pmanager->AddRestProcess(new G4KaonMinusAbsorptionAtRest, ordDefault);
520// }
521
522// else if (particleName == "proton")
523// {
524// pmanager->AddDiscreteProcess(theElasticProcess);
525// G4ProtonInelasticProcess* theInelasticProcess =
526// new G4ProtonInelasticProcess();
527
528
529// //JEC 12/2/07 USE ONE SPECIFIC hadronic model...
530// // if (gheishahad) {
531// G4LEProtonInelastic* theLEInelasticModel = new G4LEProtonInelastic;
532// theInelasticProcess->RegisterMe(theLEInelasticModel);
533// // }
534// // else if (bertinihad) {
535// // G4CascadeInterface* theBertiniModel = new G4CascadeInterface;
536// // theInelasticProcess->RegisterMe(theBertiniModel);
537// // }
538// // else if (binaryhad) {
539// // G4BinaryCascade* theBinaryModel = new G4BinaryCascade();
540// // theInelasticProcess->RegisterMe(theBinaryModel);
541// // }
542// // else {
543// // G4cout << "No secondary interaction model chosen! Using G4 BINARY." << G4endl;
544// // G4BinaryCascade* theBinaryModel = new G4BinaryCascade();
545// // theInelasticProcess->RegisterMe(theBinaryModel);
546// // }
547
548// G4HEProtonInelastic* theHEInelasticModel = new G4HEProtonInelastic;
549// theInelasticProcess->RegisterMe(theHEInelasticModel);
550// pmanager->AddDiscreteProcess(theInelasticProcess);
551// }
552
553// else if (particleName == "anti_proton")
554// {
555// pmanager->AddDiscreteProcess(theElasticProcess);
556// G4AntiProtonInelasticProcess* theInelasticProcess =
557// new G4AntiProtonInelasticProcess();
558// G4LEAntiProtonInelastic* theLEInelasticModel =
559// new G4LEAntiProtonInelastic;
560// theInelasticProcess->RegisterMe(theLEInelasticModel);
561// G4HEAntiProtonInelastic* theHEInelasticModel =
562// new G4HEAntiProtonInelastic;
563// theInelasticProcess->RegisterMe(theHEInelasticModel);
564// pmanager->AddDiscreteProcess(theInelasticProcess);
565// }
566
567// else if (particleName == "neutron")
568// {
569// // elastic scattering
570// G4HadronElasticProcess* theNeutronElasticProcess =
571// new G4HadronElasticProcess;
572// G4LElastic* theElasticModel1 = new G4LElastic;
573// G4NeutronHPElastic * theElasticNeutron = new G4NeutronHPElastic;
574// theNeutronElasticProcess->RegisterMe(theElasticModel1);
575// theElasticModel1->SetMinEnergy(19*MeV);
576// theNeutronElasticProcess->RegisterMe(theElasticNeutron);
577// G4NeutronHPElasticData * theNeutronData = new G4NeutronHPElasticData;
578// theNeutronElasticProcess->AddDataSet(theNeutronData);
579// pmanager->AddDiscreteProcess(theNeutronElasticProcess);
580
581// // inelastic scattering
582// G4NeutronInelasticProcess* theInelasticProcess =
583// new G4NeutronInelasticProcess();
584
585// //JEC 12/2/07 USE ONE SPECIFIC hadronic model...
586// // if (gheishahad) {
587// G4LENeutronInelastic* theInelasticModel = new G4LENeutronInelastic;
588// theInelasticModel->SetMinEnergy(19*MeV);
589// theInelasticProcess->RegisterMe(theInelasticModel);
590// // }
591// // else if (bertinihad) {
592// // G4CascadeInterface* theBertiniModel = new G4CascadeInterface;
593// // theBertiniModel->SetMinEnergy(19*MeV);
594// // theInelasticProcess->RegisterMe(theBertiniModel);
595// // }
596// // else if (binaryhad) {
597// // G4BinaryCascade* theBinaryModel = new G4BinaryCascade();
598// // theBinaryModel->SetMinEnergy(19*MeV);
599// // theInelasticProcess->RegisterMe(theBinaryModel);
600// // }
601// // else {
602// // G4cout << "No secondary interaction model chosen! Using G4 BINARY." << G4endl;
603// // G4BinaryCascade* theBinaryModel = new G4BinaryCascade();
604// // theBinaryModel->SetMinEnergy(19*MeV);
605// // theInelasticProcess->RegisterMe(theBinaryModel);
606// // }
607
608// G4HENeutronInelastic* theHEInelasticModel = new G4HENeutronInelastic;
609// theInelasticProcess->RegisterMe(theHEInelasticModel);
610
611// G4NeutronHPInelastic * theLENeutronInelasticModel =
612// new G4NeutronHPInelastic;
613// theInelasticProcess->RegisterMe(theLENeutronInelasticModel);
614
615// G4NeutronHPInelasticData * theNeutronData1 =
616// new G4NeutronHPInelasticData;
617// theInelasticProcess->AddDataSet(theNeutronData1);
618// pmanager->AddDiscreteProcess(theInelasticProcess);
619
620// // capture
621// G4HadronCaptureProcess* theCaptureProcess =
622// new G4HadronCaptureProcess;
623// G4LCapture* theCaptureModel = new G4LCapture;
624// theCaptureModel->SetMinEnergy(19*MeV);
625// theCaptureProcess->RegisterMe(theCaptureModel);
626// G4NeutronHPCapture * theLENeutronCaptureModel = new G4NeutronHPCapture;
627// theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
628// G4NeutronHPCaptureData * theNeutronData3 = new G4NeutronHPCaptureData;
629// theCaptureProcess->AddDataSet(theNeutronData3);
630// pmanager->AddDiscreteProcess(theCaptureProcess);
631// // G4ProcessManager* pmanager = G4Neutron::Neutron->GetProcessManager();
632// // pmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1);
633// }
634
635// else if (particleName == "anti_neutron")
636// {
637// pmanager->AddDiscreteProcess(theElasticProcess);
638// G4AntiNeutronInelasticProcess* theInelasticProcess =
639// new G4AntiNeutronInelasticProcess();
640// G4LEAntiNeutronInelastic* theLEInelasticModel =
641// new G4LEAntiNeutronInelastic;
642// theInelasticProcess->RegisterMe(theLEInelasticModel);
643// G4HEAntiNeutronInelastic* theHEInelasticModel =
644// new G4HEAntiNeutronInelastic;
645// theInelasticProcess->RegisterMe(theHEInelasticModel);
646// pmanager->AddDiscreteProcess(theInelasticProcess);
647// }
648
649// else if (particleName == "deuteron")
650// {
651// pmanager->AddDiscreteProcess(theElasticProcess);
652// G4DeuteronInelasticProcess* theInelasticProcess =
653// new G4DeuteronInelasticProcess();
654// G4LEDeuteronInelastic* theLEInelasticModel =
655// new G4LEDeuteronInelastic;
656// theInelasticProcess->RegisterMe(theLEInelasticModel);
657// pmanager->AddDiscreteProcess(theInelasticProcess);
658// }
659
660// else if (particleName == "triton")
661// {
662// pmanager->AddDiscreteProcess(theElasticProcess);
663// G4TritonInelasticProcess* theInelasticProcess =
664// new G4TritonInelasticProcess();
665// G4LETritonInelastic* theLEInelasticModel =
666// new G4LETritonInelastic;
667// theInelasticProcess->RegisterMe(theLEInelasticModel);
668// pmanager->AddDiscreteProcess(theInelasticProcess);
669// }
670
671// else if (particleName == "alpha")
672// {
673// pmanager->AddDiscreteProcess(theElasticProcess);
674// G4AlphaInelasticProcess* theInelasticProcess =
675// new G4AlphaInelasticProcess();
676// G4LEAlphaInelastic* theLEInelasticModel =
677// new G4LEAlphaInelastic;
678// theInelasticProcess->RegisterMe(theLEInelasticModel);
679// pmanager->AddDiscreteProcess(theInelasticProcess);
680// }
681
682// }
683// }//ConstructHad
Note: See TracBrowser for help on using the repository browser.