| 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 // particle_hp -- source file 26 // particle_hp -- source file
27 // J.P. Wellisch, Nov-1996 27 // J.P. Wellisch, Nov-1996
28 // A prototype of the low energy neutron trans 28 // A prototype of the low energy neutron transport model.
29 // 29 //
30 // 070523 add neglecting doppler broadening on 30 // 070523 add neglecting doppler broadening on the fly. T. Koi
31 // 070613 fix memory leaking by T. Koi 31 // 070613 fix memory leaking by T. Koi
32 // 071002 enable cross section dump by T. Koi 32 // 071002 enable cross section dump by T. Koi
33 // 080428 change checking point of "neglecting 33 // 080428 change checking point of "neglecting doppler broadening" flag
34 // from GetCrossSection to BuildPhysics 34 // from GetCrossSection to BuildPhysicsTable by T. Koi
35 // 081024 G4NucleiPropertiesTable:: to G4Nucle 35 // 081024 G4NucleiPropertiesTable:: to G4NucleiProperties::
36 // 36 //
37 // P. Arce, June-2014 Conversion neutron_hp to 37 // P. Arce, June-2014 Conversion neutron_hp to particle_hp
38 // 38 //
39 #include "G4ParticleHPInelasticData.hh" 39 #include "G4ParticleHPInelasticData.hh"
40 40
41 #include "G4ElementTable.hh" 41 #include "G4ElementTable.hh"
42 #include "G4HadronicParameters.hh" 42 #include "G4HadronicParameters.hh"
43 #include "G4Neutron.hh" 43 #include "G4Neutron.hh"
44 #include "G4NucleiProperties.hh" 44 #include "G4NucleiProperties.hh"
45 #include "G4ParticleHPData.hh" 45 #include "G4ParticleHPData.hh"
46 #include "G4ParticleHPManager.hh" 46 #include "G4ParticleHPManager.hh"
47 #include "G4Pow.hh" 47 #include "G4Pow.hh"
48 48
49 G4ParticleHPInelasticData::G4ParticleHPInelast 49 G4ParticleHPInelasticData::G4ParticleHPInelasticData(G4ParticleDefinition* projectile)
50 : G4VCrossSectionDataSet("") 50 : G4VCrossSectionDataSet("")
51 { 51 {
52 const char* dataDirVariable; 52 const char* dataDirVariable;
53 G4String particleName; 53 G4String particleName;
54 if (projectile == G4Neutron::Neutron()) { 54 if (projectile == G4Neutron::Neutron()) {
55 dataDirVariable = "G4NEUTRONHPDATA"; 55 dataDirVariable = "G4NEUTRONHPDATA";
56 } 56 }
57 else if (projectile == G4Proton::Proton()) { 57 else if (projectile == G4Proton::Proton()) {
58 dataDirVariable = "G4PROTONHPDATA"; 58 dataDirVariable = "G4PROTONHPDATA";
59 particleName = "Proton"; 59 particleName = "Proton";
60 } 60 }
61 else if (projectile == G4Deuteron::Deuteron( 61 else if (projectile == G4Deuteron::Deuteron()) {
62 dataDirVariable = "G4DEUTERONHPDATA"; 62 dataDirVariable = "G4DEUTERONHPDATA";
63 particleName = "Deuteron"; 63 particleName = "Deuteron";
64 } 64 }
65 else if (projectile == G4Triton::Triton()) { 65 else if (projectile == G4Triton::Triton()) {
66 dataDirVariable = "G4TRITONHPDATA"; 66 dataDirVariable = "G4TRITONHPDATA";
67 particleName = "Triton"; 67 particleName = "Triton";
68 } 68 }
69 else if (projectile == G4He3::He3()) { 69 else if (projectile == G4He3::He3()) {
70 dataDirVariable = "G4HE3HPDATA"; 70 dataDirVariable = "G4HE3HPDATA";
71 particleName = "He3"; 71 particleName = "He3";
72 } 72 }
73 else if (projectile == G4Alpha::Alpha()) { 73 else if (projectile == G4Alpha::Alpha()) {
74 dataDirVariable = "G4ALPHAHPDATA"; 74 dataDirVariable = "G4ALPHAHPDATA";
75 particleName = "Alpha"; 75 particleName = "Alpha";
76 } 76 }
77 else { 77 else {
78 G4String message( 78 G4String message(
79 "G4ParticleHPInelasticData may only be c 79 "G4ParticleHPInelasticData may only be called for neutron, proton, deuteron, triton, He3 or "
80 "alpha, while it is called for " 80 "alpha, while it is called for "
81 + projectile->GetParticleName()); 81 + projectile->GetParticleName());
82 throw G4HadronicException(__FILE__, __LINE 82 throw G4HadronicException(__FILE__, __LINE__, message.c_str());
83 } 83 }
84 G4String dataName = projectile->GetParticleN 84 G4String dataName = projectile->GetParticleName() + "HPInelasticXS";
85 dataName.at(0) = (char)std::toupper(dataName 85 dataName.at(0) = (char)std::toupper(dataName.at(0));
86 SetName(dataName); 86 SetName(dataName);
87 87
88 if ((G4FindDataDir(dataDirVariable) == nullp 88 if ((G4FindDataDir(dataDirVariable) == nullptr) && (G4FindDataDir("G4PARTICLEHPDATA") == nullptr))
89 { 89 {
90 G4String message("Please setenv G4PARTICLE 90 G4String message("Please setenv G4PARTICLEHPDATA (recommended) or, at least setenv "
91 + G4String(dataDirVariabl 91 + G4String(dataDirVariable) + " to point to the "
92 + projectile->GetParticle 92 + projectile->GetParticleName() + " cross-section files.");
93 throw G4HadronicException(__FILE__, __LINE 93 throw G4HadronicException(__FILE__, __LINE__, message.c_str());
94 } 94 }
95 95
96 G4String dirName; 96 G4String dirName;
97 if (G4FindDataDir(dataDirVariable) != nullpt 97 if (G4FindDataDir(dataDirVariable) != nullptr) {
98 dirName = G4FindDataDir(dataDirVariable); 98 dirName = G4FindDataDir(dataDirVariable);
99 } 99 }
100 else { 100 else {
101 G4String baseName = G4FindDataDir("G4PARTI 101 G4String baseName = G4FindDataDir("G4PARTICLEHPDATA");
102 dirName = baseName + "/" + particleName; 102 dirName = baseName + "/" + particleName;
103 } 103 }
104 #ifdef G4VERBOSE 104 #ifdef G4VERBOSE
105 if (G4HadronicParameters::Instance()->GetVer 105 if (G4HadronicParameters::Instance()->GetVerboseLevel() > 0) {
106 G4cout << "@@@ G4ParticleHPInelasticData i 106 G4cout << "@@@ G4ParticleHPInelasticData instantiated for particle "
107 << projectile->GetParticleName() << 107 << projectile->GetParticleName() << " data directory variable is " << dataDirVariable
108 << " pointing to " << dirName << G4 108 << " pointing to " << dirName << G4endl;
109 } 109 }
110 #endif 110 #endif
111 111
112 SetMinKinEnergy(0 * CLHEP::MeV); 112 SetMinKinEnergy(0 * CLHEP::MeV);
113 SetMaxKinEnergy(20 * CLHEP::MeV); 113 SetMaxKinEnergy(20 * CLHEP::MeV);
114 114
115 theCrossSections = nullptr; 115 theCrossSections = nullptr;
116 theProjectile = projectile; 116 theProjectile = projectile;
117 117
118 theHPData = nullptr; 118 theHPData = nullptr;
119 instanceOfWorker = false; 119 instanceOfWorker = false;
120 if (G4Threading::IsMasterThread()) { 120 if (G4Threading::IsMasterThread()) {
121 theHPData = new G4ParticleHPData(theProjec 121 theHPData = new G4ParticleHPData(theProjectile);
122 } 122 }
123 else { 123 else {
124 instanceOfWorker = true; 124 instanceOfWorker = true;
125 } 125 }
126 element_cache = nullptr; 126 element_cache = nullptr;
127 material_cache = nullptr; 127 material_cache = nullptr;
128 ke_cache = 0.0; 128 ke_cache = 0.0;
129 xs_cache = 0.0; 129 xs_cache = 0.0;
130 } 130 }
131 131
132 G4ParticleHPInelasticData::~G4ParticleHPInelas 132 G4ParticleHPInelasticData::~G4ParticleHPInelasticData()
133 { 133 {
134 if (theCrossSections != nullptr && !instance 134 if (theCrossSections != nullptr && !instanceOfWorker) {
135 theCrossSections->clearAndDestroy(); 135 theCrossSections->clearAndDestroy();
136 delete theCrossSections; 136 delete theCrossSections;
137 theCrossSections = nullptr; 137 theCrossSections = nullptr;
138 } 138 }
139 if (theHPData != nullptr && !instanceOfWorke 139 if (theHPData != nullptr && !instanceOfWorker) {
140 delete theHPData; 140 delete theHPData;
141 theHPData = nullptr; 141 theHPData = nullptr;
142 } 142 }
143 } 143 }
144 144
145 G4bool G4ParticleHPInelasticData::IsIsoApplica 145 G4bool G4ParticleHPInelasticData::IsIsoApplicable(const G4DynamicParticle* dp, G4int /*Z*/,
146 146 G4int /*A*/, const G4Element* /*elm*/,
147 147 const G4Material* /*mat*/)
148 { 148 {
149 G4double eKin = dp->GetKineticEnergy(); 149 G4double eKin = dp->GetKineticEnergy();
150 return eKin <= GetMaxKinEnergy() && eKin >= 150 return eKin <= GetMaxKinEnergy() && eKin >= GetMinKinEnergy()
151 && dp->GetDefinition() == theProjecti 151 && dp->GetDefinition() == theProjectile;
152 } 152 }
153 153
154 G4double G4ParticleHPInelasticData::GetIsoCros 154 G4double G4ParticleHPInelasticData::GetIsoCrossSection(const G4DynamicParticle* dp, G4int /*Z*/,
155 155 G4int /*A*/, const G4Isotope* /*iso*/,
156 156 const G4Element* element,
157 157 const G4Material* material)
158 { 158 {
159 if (dp->GetKineticEnergy() == ke_cache && el 159 if (dp->GetKineticEnergy() == ke_cache && element == element_cache && material == material_cache)
160 return xs_cache; 160 return xs_cache;
161 161
162 ke_cache = dp->GetKineticEnergy(); 162 ke_cache = dp->GetKineticEnergy();
163 element_cache = element; 163 element_cache = element;
164 material_cache = material; 164 material_cache = material;
165 G4double xs = GetCrossSection(dp, element, m 165 G4double xs = GetCrossSection(dp, element, material->GetTemperature());
166 xs_cache = xs; 166 xs_cache = xs;
167 return xs; 167 return xs;
168 } 168 }
169 169
170 void G4ParticleHPInelasticData::BuildPhysicsTa 170 void G4ParticleHPInelasticData::BuildPhysicsTable(const G4ParticleDefinition& projectile)
171 { 171 {
172 if (G4Threading::IsWorkerThread()) { 172 if (G4Threading::IsWorkerThread()) {
173 theCrossSections = G4ParticleHPManager::Ge 173 theCrossSections = G4ParticleHPManager::GetInstance()->GetInelasticCrossSections(&projectile);
174 return; 174 return;
175 } 175 }
176 if (theHPData == nullptr) 176 if (theHPData == nullptr)
177 theHPData = G4ParticleHPData::Instance(con 177 theHPData = G4ParticleHPData::Instance(const_cast<G4ParticleDefinition*>(&projectile));
178 178
179 std::size_t numberOfElements = G4Element::Ge 179 std::size_t numberOfElements = G4Element::GetNumberOfElements();
180 if (theCrossSections == nullptr) 180 if (theCrossSections == nullptr)
181 theCrossSections = new G4PhysicsTable(numb 181 theCrossSections = new G4PhysicsTable(numberOfElements);
182 else 182 else
183 theCrossSections->clearAndDestroy(); 183 theCrossSections->clearAndDestroy();
184 184
185 // make a PhysicsVector for each element 185 // make a PhysicsVector for each element
186 186
187 auto theElementTable = G4Element::GetElement << 187 static G4ThreadLocal G4ElementTable* theElementTable = nullptr;
>> 188 if (theElementTable == nullptr) theElementTable = G4Element::GetElementTable();
188 for (std::size_t i = 0; i < numberOfElements 189 for (std::size_t i = 0; i < numberOfElements; ++i) {
189 G4PhysicsVector* physVec = theHPData->Make 190 G4PhysicsVector* physVec = theHPData->MakePhysicsVector((*theElementTable)[i], this);
190 theCrossSections->push_back(physVec); 191 theCrossSections->push_back(physVec);
191 } 192 }
192 G4ParticleHPManager::GetInstance()->Register 193 G4ParticleHPManager::GetInstance()->RegisterInelasticCrossSections(&projectile, theCrossSections);
193 } 194 }
194 195
195 void G4ParticleHPInelasticData::DumpPhysicsTab << 196 void G4ParticleHPInelasticData::DumpPhysicsTable(const G4ParticleDefinition& projectile)
196 { 197 {
>> 198 if (&projectile != theProjectile)
>> 199 throw G4HadronicException(__FILE__, __LINE__,
>> 200 "Attempt to use ParticleHP data for a wrong projectile!!!");
>> 201
197 #ifdef G4VERBOSE 202 #ifdef G4VERBOSE
198 if (G4HadronicParameters::Instance()->GetVer 203 if (G4HadronicParameters::Instance()->GetVerboseLevel() == 0) return;
199 204
200 // Dump element based cross section 205 // Dump element based cross section
201 // range 10e-5 eV to 20 MeV 206 // range 10e-5 eV to 20 MeV
202 // 10 point per decade 207 // 10 point per decade
203 // in barn 208 // in barn
204 209
205 G4cout << G4endl; 210 G4cout << G4endl;
206 G4cout << G4endl; 211 G4cout << G4endl;
207 G4cout << "Inelastic Cross Section of Neutro 212 G4cout << "Inelastic Cross Section of Neutron HP" << G4endl;
208 G4cout << "(Pointwise cross-section at 0 Kel 213 G4cout << "(Pointwise cross-section at 0 Kelvin.)" << G4endl;
209 G4cout << G4endl; 214 G4cout << G4endl;
210 G4cout << "Name of Element" << G4endl; 215 G4cout << "Name of Element" << G4endl;
211 G4cout << "Energy[eV] XS[barn]" << G4endl; 216 G4cout << "Energy[eV] XS[barn]" << G4endl;
212 G4cout << G4endl; 217 G4cout << G4endl;
213 218
214 std::size_t numberOfElements = G4Element::Ge 219 std::size_t numberOfElements = G4Element::GetNumberOfElements();
215 auto theElementTable = G4Element::GetElement << 220 static G4ThreadLocal G4ElementTable* theElementTable = nullptr;
>> 221 if (theElementTable == nullptr) theElementTable = G4Element::GetElementTable();
216 222
217 for (std::size_t i = 0; i < numberOfElements 223 for (std::size_t i = 0; i < numberOfElements; ++i) {
218 G4cout << (*theElementTable)[i]->GetName() 224 G4cout << (*theElementTable)[i]->GetName() << G4endl;
219 225
220 G4int ie = 0; 226 G4int ie = 0;
221 227
222 for (ie = 0; ie < 130; ie++) { 228 for (ie = 0; ie < 130; ie++) {
223 G4double eKinetic = 1.0e-5 * G4Pow::GetI 229 G4double eKinetic = 1.0e-5 * G4Pow::GetInstance()->powA(10.0, ie / 10.0) * CLHEP::eV;
224 G4bool outOfRange = false; 230 G4bool outOfRange = false;
225 231
226 if (eKinetic < 20 * CLHEP::MeV) { 232 if (eKinetic < 20 * CLHEP::MeV) {
227 G4cout << eKinetic / CLHEP::eV << " " 233 G4cout << eKinetic / CLHEP::eV << " "
228 << (*((*theCrossSections)(i))). 234 << (*((*theCrossSections)(i))).GetValue(eKinetic, outOfRange) / CLHEP::barn
229 << G4endl; 235 << G4endl;
230 } 236 }
231 } 237 }
232 G4cout << G4endl; 238 G4cout << G4endl;
233 } 239 }
234 #endif 240 #endif
235 } 241 }
236 242
237 G4double G4ParticleHPInelasticData::GetCrossSe 243 G4double G4ParticleHPInelasticData::GetCrossSection(const G4DynamicParticle* projectile,
238 244 const G4Element* anE, G4double aT)
239 { 245 {
240 G4double result = 0; 246 G4double result = 0;
241 G4bool outOfRange; 247 G4bool outOfRange;
242 std::size_t index = anE->GetIndex(); 248 std::size_t index = anE->GetIndex();
243 249
244 // prepare neutron 250 // prepare neutron
245 G4double eKinetic = projectile->GetKineticEn 251 G4double eKinetic = projectile->GetKineticEnergy();
246 252
247 if (G4ParticleHPManager::GetInstance()->GetN 253 if (G4ParticleHPManager::GetInstance()->GetNeglectDoppler()) {
248 // NEGLECT_DOPPLER 254 // NEGLECT_DOPPLER
249 G4double factor = 1.0; 255 G4double factor = 1.0;
250 if (eKinetic < aT * CLHEP::k_Boltzmann) { 256 if (eKinetic < aT * CLHEP::k_Boltzmann) {
251 // below 0.1 eV neutrons 257 // below 0.1 eV neutrons
252 // Have to do some, but now just igonre. 258 // Have to do some, but now just igonre.
253 // Will take care after performance chec 259 // Will take care after performance check.
254 // factor = factor * targetV; 260 // factor = factor * targetV;
255 } 261 }
256 return ((*((*theCrossSections)(index))).Ge 262 return ((*((*theCrossSections)(index))).GetValue(eKinetic, outOfRange)) * factor;
257 } 263 }
258 264
259 G4ReactionProduct theNeutron(projectile->Get 265 G4ReactionProduct theNeutron(projectile->GetDefinition());
260 theNeutron.SetMomentum(projectile->GetMoment 266 theNeutron.SetMomentum(projectile->GetMomentum());
261 theNeutron.SetKineticEnergy(eKinetic); 267 theNeutron.SetKineticEnergy(eKinetic);
262 268
263 // prepare thermal nucleus 269 // prepare thermal nucleus
264 G4Nucleus aNuc; 270 G4Nucleus aNuc;
265 G4double eps = 0.0001; 271 G4double eps = 0.0001;
266 G4double theA = anE->GetN(); 272 G4double theA = anE->GetN();
267 G4double theZ = anE->GetZ(); 273 G4double theZ = anE->GetZ();
268 G4double eleMass; 274 G4double eleMass;
269 eleMass = G4NucleiProperties::GetNuclearMass 275 eleMass = G4NucleiProperties::GetNuclearMass(static_cast<G4int>(theA + eps),
270 276 static_cast<G4int>(theZ + eps));
271 277
272 G4ReactionProduct boosted; 278 G4ReactionProduct boosted;
273 G4double aXsection; 279 G4double aXsection;
274 280
275 // MC integration loop 281 // MC integration loop
276 G4int counter = 0; 282 G4int counter = 0;
277 G4int failCount = 0; 283 G4int failCount = 0;
278 G4double buffer = 0; 284 G4double buffer = 0;
279 G4int size = G4int(std::max(10., aT / 60 * C 285 G4int size = G4int(std::max(10., aT / 60 * CLHEP::kelvin));
280 G4ThreeVector neutronVelocity = 1. / theProj 286 G4ThreeVector neutronVelocity = 1. / theProjectile->GetPDGMass() * theNeutron.GetMomentum();
281 G4double neutronVMag = neutronVelocity.mag() 287 G4double neutronVMag = neutronVelocity.mag();
282 288
283 #ifndef G4PHP_DOPPLER_LOOP_ONCE 289 #ifndef G4PHP_DOPPLER_LOOP_ONCE
284 while (counter == 0 290 while (counter == 0
285 || std::abs(buffer - result / std::ma 291 || std::abs(buffer - result / std::max(1, counter))
286 > 0.01 * buffer) // Loop checki 292 > 0.01 * buffer) // Loop checking, 11.05.2015, T. Koi
287 { 293 {
288 if (counter != 0) buffer = result / counte 294 if (counter != 0) buffer = result / counter;
289 while (counter < size) // Loop checking, 295 while (counter < size) // Loop checking, 11.05.2015, T. Koi
290 { 296 {
291 ++counter; 297 ++counter;
292 #endif 298 #endif
293 G4ReactionProduct aThermalNuc = 299 G4ReactionProduct aThermalNuc =
294 aNuc.GetThermalNucleus(eleMass / G4Neu 300 aNuc.GetThermalNucleus(eleMass / G4Neutron::Neutron()->GetPDGMass(), aT);
295 boosted.Lorentz(theNeutron, aThermalNuc) 301 boosted.Lorentz(theNeutron, aThermalNuc);
296 G4double theEkin = boosted.GetKineticEne 302 G4double theEkin = boosted.GetKineticEnergy();
297 aXsection = (*((*theCrossSections)(index 303 aXsection = (*((*theCrossSections)(index))).GetValue(theEkin, outOfRange);
298 if (aXsection < 0) { 304 if (aXsection < 0) {
299 if (failCount < 1000) { 305 if (failCount < 1000) {
300 ++failCount; 306 ++failCount;
301 #ifndef G4PHP_DOPPLER_LOOP_ONCE 307 #ifndef G4PHP_DOPPLER_LOOP_ONCE
302 --counter; 308 --counter;
303 continue; 309 continue;
304 #endif 310 #endif
305 } 311 }
306 else { 312 else {
307 aXsection = 0; 313 aXsection = 0;
308 } 314 }
309 } 315 }
310 // velocity correction. 316 // velocity correction.
311 G4ThreeVector targetVelocity = 1. / aThe 317 G4ThreeVector targetVelocity = 1. / aThermalNuc.GetMass() * aThermalNuc.GetMomentum();
312 aXsection *= (targetVelocity - neutronVe 318 aXsection *= (targetVelocity - neutronVelocity).mag() / neutronVMag;
313 result += aXsection; 319 result += aXsection;
314 } 320 }
315 #ifndef G4PHP_DOPPLER_LOOP_ONCE 321 #ifndef G4PHP_DOPPLER_LOOP_ONCE
316 size += size; 322 size += size;
317 } 323 }
318 result /= counter; 324 result /= counter;
319 #endif 325 #endif
320 326
321 return result; 327 return result;
322 } 328 }
323 329
324 G4int G4ParticleHPInelasticData::GetVerboseLev 330 G4int G4ParticleHPInelasticData::GetVerboseLevel() const
325 { 331 {
326 return G4ParticleHPManager::GetInstance()->G 332 return G4ParticleHPManager::GetInstance()->GetVerboseLevel();
327 } 333 }
328 334
329 void G4ParticleHPInelasticData::SetVerboseLeve 335 void G4ParticleHPInelasticData::SetVerboseLevel(G4int newValue)
330 { 336 {
331 G4ParticleHPManager::GetInstance()->SetVerbo 337 G4ParticleHPManager::GetInstance()->SetVerboseLevel(newValue);
332 } 338 }
333 339
334 void G4ParticleHPInelasticData::CrossSectionDe 340 void G4ParticleHPInelasticData::CrossSectionDescription(std::ostream& outFile) const
335 { 341 {
336 outFile << "Extension of High Precision cros 342 outFile << "Extension of High Precision cross section for inelastic reaction of proton, "
337 "deuteron, triton, He3 and alpha 343 "deuteron, triton, He3 and alpha below 20MeV\n";
338 } 344 }
339 345