source: trunk/examples/extended/radioactivedecay/exrdm/src/exrdmPhysListHadron.cc@ 1036

Last change on this file since 1036 was 807, checked in by garnier, 17 years ago

update
File size: 11.1 KB
Line 
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//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
27
28#include "exrdmPhysListHadron.hh"
29
30#include "G4ParticleDefinition.hh"
31#include "G4ProcessManager.hh"
32
33#include "G4TheoFSGenerator.hh"
34#include "G4ExcitationHandler.hh"
35#include "G4Evaporation.hh"
36#include "G4FermiBreakUp.hh"
37#include "G4GeneratorPrecompoundInterface.hh"
38#include "G4PreCompoundModel.hh"
39#include "G4QGSModel.hh"
40#include "G4QGSParticipants.hh"
41#include "G4QGSMFragmentation.hh"
42#include "G4ExcitedStringDecay.hh"
43
44#include "G4LElastic.hh"
45#include "G4LFission.hh"
46#include "G4LCapture.hh"
47
48#include "G4CascadeInterface.hh"
49
50#include "G4BinaryCascade.hh"
51#include "G4BinaryLightIonReaction.hh"
52
53//HPNeutron
54
55#include "G4NeutronHPElastic.hh"
56#include "G4NeutronHPElasticData.hh"
57#include "G4NeutronHPCapture.hh"
58#include "G4NeutronHPCaptureData.hh"
59#include "G4NeutronHPInelastic.hh"
60#include "G4NeutronHPInelasticData.hh"
61//c-s
62#include "G4TripathiCrossSection.hh"
63#include "G4IonsShenCrossSection.hh"
64#include "G4ProtonInelasticCrossSection.hh"
65#include "G4NeutronInelasticCrossSection.hh"
66
67// RadioactiveDecay
68#include "G4RadioactiveDecay.hh"
69#include "G4GenericIon.hh"
70
71exrdmPhysListHadron::exrdmPhysListHadron(const G4String& name)
72 : G4VPhysicsConstructor(name)
73{}
74
75exrdmPhysListHadron::~exrdmPhysListHadron()
76{}
77
78//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
79void exrdmPhysListHadron::ConstructProcess()
80{
81
82 G4ProcessManager * pManager = 0;
83
84 // this will be the model class for high energies
85 G4TheoFSGenerator * theTheoModel = new G4TheoFSGenerator;
86 // all models for treatment of thermal nucleus
87 G4Evaporation * theEvaporation = new G4Evaporation;
88 G4FermiBreakUp * theFermiBreakUp = new G4FermiBreakUp;
89 G4StatMF * theMF = new G4StatMF;
90 // Evaporation logic
91 G4ExcitationHandler * theHandler = new G4ExcitationHandler;
92 theHandler->SetEvaporation(theEvaporation);
93 theHandler->SetFermiModel(theFermiBreakUp);
94 theHandler->SetMultiFragmentation(theMF);
95 theHandler->SetMaxAandZForFermiBreakUp(12, 6);
96 theHandler->SetMinEForMultiFrag(5*MeV);
97 // Pre equilibrium stage
98 G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel(theHandler);
99
100 // a no-cascade generator-precompound interaface
101 G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface;
102 theCascade->SetDeExcitation(thePreEquilib);
103
104 // here come the high energy parts
105 // the string model; still not quite according to design - Explicite use of the forseen interfaces
106 G4VPartonStringModel * theStringModel;
107 theStringModel = new G4QGSModel<G4QGSParticipants>;
108 theTheoModel->SetTransport(theCascade);
109 theTheoModel->SetHighEnergyGenerator(theStringModel);
110 theTheoModel->SetMinEnergy(10*GeV); // 15 GeV may be the right limit
111 theTheoModel->SetMaxEnergy(100*TeV);
112
113 G4VLongitudinalStringDecay * theFragmentation = new G4QGSMFragmentation;
114 G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay(theFragmentation);
115 theStringModel->SetFragmentationModel(theStringDecay);
116
117 // Elastic Process
118
119 theElasticProcess.RegisterMe(new G4LElastic());
120
121 // ---------------------------------------------------------------------------
122 // Hadron elastic process
123 // for all particles except neutrons
124
125 theParticleIterator->reset();
126 while( (*theParticleIterator)() ) {
127 G4ParticleDefinition* particle = theParticleIterator->value();
128 G4String particleName = particle->GetParticleName();
129 if (particleName != "neutron") {
130 G4ProcessManager* pManager = particle->GetProcessManager();
131 if (particle->GetPDGMass() > 110.*MeV && theElasticProcess.IsApplicable(*particle)
132 && !particle->IsShortLived()) {
133 pManager->AddDiscreteProcess(&theElasticProcess);
134 //
135 // G4cout << "### Elastic model are registered for "
136 // << particle->GetParticleName()
137 // << G4endl;
138 }
139 }
140 }
141 // Proton
142 pManager = G4Proton::Proton()->GetProcessManager();
143 // add inelastic process
144 // Binary Cascade
145 G4BinaryCascade * theBC = new G4BinaryCascade;
146 theBC->SetMaxEnergy(10.5*GeV);
147 theProtonInelastic.RegisterMe(theBC);
148 // Higher energy
149 theProtonInelastic.RegisterMe(theTheoModel);
150 // now the cross-sections.
151 G4ProtonInelasticCrossSection * theProtonData = new G4ProtonInelasticCrossSection;
152 theProtonInelastic.AddDataSet(theProtonData);
153 pManager->AddDiscreteProcess(&theProtonInelastic);
154 //
155 //
156 // Neutron
157 pManager = G4Neutron::Neutron()->GetProcessManager();
158 // add process
159 // elastic scattering
160 theNeutronElasticProcess =
161 new G4HadronElasticProcess();
162 G4LElastic* theElasticModel1 = new G4LElastic;
163 G4NeutronHPElastic * theElasticNeutron = new G4NeutronHPElastic;
164 theNeutronElasticProcess->RegisterMe(theElasticModel1);
165 theElasticModel1->SetMinEnergy(19.*MeV);
166 theNeutronElasticProcess->RegisterMe(theElasticNeutron);
167 theElasticNeutron->SetMaxEnergy(20.*MeV);
168
169 G4NeutronHPElasticData * theNeutronData = new G4NeutronHPElasticData;
170 theNeutronElasticProcess->AddDataSet(theNeutronData);
171 pManager->AddDiscreteProcess(theNeutronElasticProcess);
172 // inelastic
173 G4NeutronHPInelastic * theHPNeutronInelasticModel =
174 new G4NeutronHPInelastic;
175 theHPNeutronInelasticModel->SetMaxEnergy(20.*MeV);
176 theNeutronInelastic.RegisterMe(theHPNeutronInelasticModel);
177 G4NeutronHPInelasticData * theNeutronData1 = new G4NeutronHPInelasticData;
178 theNeutronInelastic.AddDataSet(theNeutronData1);
179 // binary
180 G4BinaryCascade * neutronBC = new G4BinaryCascade;
181 neutronBC->SetMinEnergy(19.*MeV);
182 neutronBC->SetMaxEnergy(10.5*GeV);
183 theNeutronInelastic.RegisterMe(neutronBC);
184 // higher energy
185 theNeutronInelastic.RegisterMe(theTheoModel);
186 // now the cross-sections.
187 G4NeutronInelasticCrossSection * theNeutronData2 = new G4NeutronInelasticCrossSection;
188 theNeutronInelastic.AddDataSet(theNeutronData2);
189 pManager->AddDiscreteProcess(&theNeutronInelastic);
190 // fission
191 theFissionProcess =
192 new G4HadronFissionProcess;
193 G4LFission* theFissionModel = new G4LFission;
194 theFissionProcess->RegisterMe(theFissionModel);
195 pManager->AddDiscreteProcess(theFissionProcess);
196 //capture
197 theCaptureProcess =
198 new G4HadronCaptureProcess;
199 G4LCapture* theCaptureModel = new G4LCapture;
200 theCaptureProcess->RegisterMe(theCaptureModel);
201 theCaptureModel->SetMinEnergy(19.*MeV);
202 G4NeutronHPCapture * theHPNeutronCaptureModel = new G4NeutronHPCapture;
203 theCaptureProcess->RegisterMe(theHPNeutronCaptureModel);
204 G4NeutronHPCaptureData * theNeutronData3 = new G4NeutronHPCaptureData;
205 theCaptureProcess->AddDataSet(theNeutronData3);
206 pManager->AddDiscreteProcess(theCaptureProcess);
207
208 // now light ions
209 // light Ion BC
210 G4BinaryLightIonReaction * theIonBC= new G4BinaryLightIonReaction;
211 theIonBC->SetMinEnergy(1*MeV);
212 theIonBC->SetMaxEnergy(20*GeV);
213 G4TripathiCrossSection * TripathiCrossSection= new G4TripathiCrossSection;
214 G4IonsShenCrossSection * aShen = new G4IonsShenCrossSection;
215
216 // deuteron
217 pManager = G4Deuteron::Deuteron()->GetProcessManager();
218 theDeuteronInelasticProcess =
219 new G4DeuteronInelasticProcess("inelastic");
220 // G4LEDeuteronInelastic* theDeuteronInelasticModel =
221 // new G4LEDeuteronInelastic;
222 // theDeuteronInelasticModel->SetMaxEnergy(100*MeV);
223 theDeuteronInelasticProcess->AddDataSet(TripathiCrossSection);
224 theDeuteronInelasticProcess->AddDataSet(aShen);
225 // theDeuteronInelasticProcess->RegisterMe(theDeuteronInelasticModel);
226 theDeuteronInelasticProcess->RegisterMe(theIonBC);
227 theDeuteronInelasticProcess->RegisterMe(theTheoModel);
228 pManager->AddDiscreteProcess(theDeuteronInelasticProcess);
229 // triton
230 pManager = G4Triton::Triton()->GetProcessManager();
231 theTritonInelasticProcess =
232 new G4TritonInelasticProcess("inelastic");
233 // G4LETritonInelastic* theTritonInelasticModel =
234 // new G4LETritonInelastic;
235 //theTritonInelasticModel->SetMaxEnergy(100*MeV);
236 theTritonInelasticProcess->AddDataSet(TripathiCrossSection);
237 theTritonInelasticProcess->AddDataSet(aShen);
238 // theTritonInelasticProcess->RegisterMe(theTritonInelasticModel);
239 theTritonInelasticProcess->RegisterMe(theIonBC);
240 theTritonInelasticProcess->RegisterMe(theTheoModel);
241 pManager->AddDiscreteProcess(theTritonInelasticProcess);
242 // alpha
243 pManager = G4Alpha::Alpha()->GetProcessManager();
244 theAlphaInelasticProcess =
245 new G4AlphaInelasticProcess("inelastic");
246 // G4LEAlphaInelastic* theAlphaInelasticModel =
247 // new G4LEAlphaInelastic;
248 //theAlphaInelasticModel->SetMaxEnergy(100*MeV);
249 theAlphaInelasticProcess->AddDataSet(TripathiCrossSection);
250 theAlphaInelasticProcess->AddDataSet(aShen);
251 // theAlphaInelasticProcess->RegisterMe(theAlphaInelasticModel);
252 theAlphaInelasticProcess->RegisterMe(theIonBC);
253 theAlphaInelasticProcess->RegisterMe(theTheoModel);
254 pManager->AddDiscreteProcess(theAlphaInelasticProcess);
255 // GenericIon
256 pManager = G4GenericIon::GenericIon()->GetProcessManager();
257 // need to add the elastic explicitly
258 pManager->AddDiscreteProcess(&theElasticProcess);
259 theIonInelasticProcess =
260 new G4IonInelasticProcess();
261 theIonInelasticProcess->AddDataSet(TripathiCrossSection);
262 theIonInelasticProcess->AddDataSet(aShen);
263 // G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
264 // theGenIonBC->SetMinEnergy(0*MeV);
265 //theGenIonBC->SetMaxEnergy(20*GeV);
266 theIonInelasticProcess->RegisterMe(theIonBC);
267 theIonInelasticProcess->RegisterMe(theTheoModel);
268 pManager->AddDiscreteProcess(theIonInelasticProcess);
269
270 // Add RadioactiveDecay Process
271
272 G4RadioactiveDecay* theRadioactiveDecay = new G4RadioactiveDecay();
273 G4GenericIon* ion = G4GenericIon::GenericIon();
274 pManager->AddProcess(theRadioactiveDecay, 0, -1, 3);
275
276}
Note: See TracBrowser for help on using the repository browser.