| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 // Hadronic Interaction base class
28 // original by H.P. Wellisch
29 // modified by J.L. Chuma, TRIUMF, 21-Mar-1997
30 // Last modified: 04-Apr-1997
31 // reimplemented 1.11.2003 JPW.
32 // 23-Jan-2009 V.Ivanchenko move constructor a
33
34 #include <iostream>
35
36 #include "G4HadronicInteraction.hh"
37 #include "G4SystemOfUnits.hh"
38 #include "G4HadronicInteractionRegistry.hh"
39 #include "G4HadronicParameters.hh"
40
41 G4HadronicInteraction::G4HadronicInteraction(c
42 verboseLevel(0), theMinEnergy(0.0),
43 isBlocked(false), recoilEnergyThreshold(0.0)
44 epCheckLevels(DBL_MAX, DBL_MAX)
45 {
46 theMaxEnergy = G4HadronicParameters::Instanc
47 registry = G4HadronicInteractionRegistry::In
48 registry->RegisterMe(this);
49 }
50
51 G4HadronicInteraction::~G4HadronicInteraction(
52 {
53 registry->RemoveMe(this);
54 }
55
56 void G4HadronicInteraction::BuildPhysicsTable(
57 {}
58
59 void G4HadronicInteraction::InitialiseModel()
60 {}
61
62 G4HadFinalState*
63 G4HadronicInteraction::ApplyYourself(const G4H
64 {
65 return nullptr;
66 }
67
68 G4double
69 G4HadronicInteraction::SampleInvariantT(const
70 G4double, G4int, G4int)
71 {
72 return 0.0;
73 }
74
75 G4bool G4HadronicInteraction::IsApplicable(con
76 G4Nucleus&)
77 {
78 return true;
79 }
80
81 G4double G4HadronicInteraction::GetMinEnergy(
82 const G4Material *aMaterial, const G4Elemen
83 {
84 if(!IsBlocked()) { return theMinEnergy; }
85 if( IsBlocked(aMaterial) || IsBlocked(anElem
86 if(!theMinEnergyListElements.empty()) {
87 for(auto const& elmlist : theMinEnergyList
88 if( anElement == elmlist.second )
89 { return elmlist.first; }
90 }
91 }
92 if(!theMinEnergyList.empty()) {
93 for(auto const & matlist : theMinEnergyLis
94 if( aMaterial == matlist.second )
95 { return matlist.first; }
96 }
97 }
98 return theMinEnergy;
99 }
100
101 void G4HadronicInteraction::SetMinEnergy(G4dou
102 const G4Element *anElement )
103 {
104 Block();
105 if(!theMinEnergyListElements.empty()) {
106 for(auto & elmlist : theMinEnergyListEleme
107 if( anElement == elmlist.second ) {
108 elmlist.first = anEnergy;
109 return;
110 }
111 }
112 }
113 theMinEnergyListElements.push_back(std::pair
114 }
115
116 void G4HadronicInteraction::SetMinEnergy(G4dou
117 const G4Material *aMaterial )
118 {
119 Block();
120 if(!theMinEnergyList.empty()) {
121 for(auto & matlist : theMinEnergyList) {
122 if( aMaterial == matlist.second ) {
123 matlist.first = anEnergy;
124 return;
125 }
126 }
127 }
128 theMinEnergyList.push_back(std::pair<G4doubl
129 }
130
131 G4double G4HadronicInteraction::GetMaxEnergy(c
132 const G4Element *anElement ) co
133 {
134 if(!IsBlocked()) { return theMaxEnergy; }
135 if( IsBlocked(aMaterial) || IsBlocked(anElem
136 if(!theMaxEnergyListElements.empty()) {
137 for(auto const& elmlist : theMaxEnergyList
138 if( anElement == elmlist.second )
139 { return elmlist.first; }
140 }
141 }
142 if(!theMaxEnergyList.empty()) {
143 for(auto const& matlist : theMaxEnergyList
144 if( aMaterial == matlist.second )
145 { return matlist.first; }
146 }
147 }
148 return theMaxEnergy;
149 }
150
151 void G4HadronicInteraction::SetMaxEnergy(G4dou
152 const G4Element *anElement )
153 {
154 Block();
155 if(!theMaxEnergyListElements.empty()) {
156 for(auto & elmlist : theMaxEnergyListEleme
157 if( anElement == elmlist.second ) {
158 elmlist.first = anEnergy;
159 return;
160 }
161 }
162 }
163 theMaxEnergyListElements.push_back(std::pair
164 }
165
166 void G4HadronicInteraction::SetMaxEnergy(G4dou
167 {
168 Block();
169 if(!theMaxEnergyList.empty()) {
170 for(auto & matlist: theMaxEnergyList) {
171 if( aMaterial == matlist.second ) {
172 matlist.first = anEnergy;
173 return;
174 }
175 }
176 }
177 theMaxEnergyList.push_back(std::pair<G4doubl
178 }
179
180 void G4HadronicInteraction::DeActivateFor( con
181 {
182 Block();
183 theBlockedList.push_back(aMaterial);
184 }
185
186 void G4HadronicInteraction::DeActivateFor( con
187 {
188 Block();
189 theBlockedListElements.push_back(anElement);
190 }
191
192
193 G4bool G4HadronicInteraction::IsBlocked(const
194 {
195 for (auto const& mat : theBlockedList) {
196 if (aMaterial == mat) return true;
197 }
198 return false;
199 }
200
201
202 G4bool G4HadronicInteraction::IsBlocked(const
203 {
204 for (auto const& elm : theBlockedListElement
205 if (anElement == elm) return true;
206 }
207 return false;
208 }
209
210 const std::pair<G4double, G4double> G4Hadronic
211 {
212 // default level of Check
213 return std::pair<G4double, G4double>(2.*perC
214 }
215
216 std::pair<G4double, G4double>
217 G4HadronicInteraction::GetEnergyMomentumCheckL
218 {
219 return epCheckLevels;
220 }
221
222 void G4HadronicInteraction::ModelDescription(s
223 {
224 outFile << "The description for this model h
225 }
226
227