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

Last change on this file since 286 was 286, checked in by campagne, 17 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.