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