| 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 // neutron_hp -- source file 26 // neutron_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 bug fix for G4FPE_DEBUG on by A. How 30 // 070523 bug fix for G4FPE_DEBUG on by A. Howard ( and T. Koi)
31 // 080319 Compilation warnings - gcc-4.3.0 fix 31 // 080319 Compilation warnings - gcc-4.3.0 fix by T. Koi
32 // 32 //
33 // P. Arce, June-2014 Conversion neutron_hp to 33 // P. Arce, June-2014 Conversion neutron_hp to particle_hp
34 // 34 //
35 #include "G4ParticleHPElastic.hh" 35 #include "G4ParticleHPElastic.hh"
36 << 36 #include "G4SystemOfUnits.hh"
37 #include "G4ParticleHPElasticFS.hh" 37 #include "G4ParticleHPElasticFS.hh"
38 #include "G4ParticleHPManager.hh" 38 #include "G4ParticleHPManager.hh"
39 #include "G4ParticleHPThermalBoost.hh" <<
40 #include "G4SystemOfUnits.hh" <<
41 #include "G4Threading.hh" 39 #include "G4Threading.hh"
42 40
43 G4ParticleHPElastic::G4ParticleHPElastic() : G << 41 G4ParticleHPElastic::G4ParticleHPElastic()
44 { << 42 :G4HadronicInteraction("NeutronHPElastic")
45 overrideSuspension = false; << 43 ,theElastic(NULL)
46 SetMinEnergy(0. * eV); << 44 ,numEle(0)
47 SetMaxEnergy(20. * MeV); << 45 {
48 } << 46 overrideSuspension = false;
49 << 47 /*
50 G4ParticleHPElastic::~G4ParticleHPElastic() << 48 G4ParticleHPElasticFS * theFS = new G4ParticleHPElasticFS;
51 { << 49 if(!std::getenv("G4NEUTRONHPDATA"))
52 // the vectror is shared among threads, only << 50 throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");
53 if (!G4Threading::IsWorkerThread()) { << 51 dirName = std::getenv("G4NEUTRONHPDATA");
54 if (theElastic != nullptr) { << 52 G4String tString = "/Elastic";
55 for (auto it = theElastic->cbegin(); it << 53 dirName = dirName + tString;
56 delete *it; << 54 // G4cout <<"G4ParticleHPElastic::G4ParticleHPElastic testit "<<dirName<<G4endl;
57 } << 55 numEle = G4Element::GetNumberOfElements();
58 theElastic->clear(); << 56 //theElastic = new G4ParticleHPChannel[numEle];
>> 57 //for (G4int i=0; i<numEle; i++)
>> 58 //{
>> 59 // theElastic[i].Init((*(G4Element::GetElementTable()))[i], dirName);
>> 60 // while(!theElastic[i].Register(theFS)) ;
>> 61 //}
>> 62 for ( G4int i = 0 ; i < numEle ; i++ )
>> 63 {
>> 64 theElastic.push_back( new G4ParticleHPChannel );
>> 65 (*theElastic[i]).Init((*(G4Element::GetElementTable()))[i], dirName);
>> 66 while(!(*theElastic[i]).Register(theFS)) ;
59 } 67 }
>> 68 delete theFS;
>> 69 */
>> 70 SetMinEnergy(0.*eV);
>> 71 SetMaxEnergy(20.*MeV);
60 } 72 }
61 } << 73
62 << 74 G4ParticleHPElastic::~G4ParticleHPElastic()
63 G4HadFinalState* G4ParticleHPElastic::ApplyYou << 75 {
64 << 76 //the vectror is shared among threads, only master deletes
65 { << 77 if ( ! G4Threading::IsWorkerThread() ) {
66 return this->ApplyYourself(aTrack, aNucleus, << 78 //delete [] theElastic;
67 } << 79 if ( theElastic != NULL ) {
68 << 80 for ( std::vector<G4ParticleHPChannel*>::iterator
69 //-------------------------------------------- << 81 it = theElastic->begin() ; it != theElastic->end() ; it++ ) {
70 // New method added by L. Thulliez (CEA-Saclay << 82 delete *it;
71 //-------------------------------------------- << 83 }
72 G4HadFinalState* G4ParticleHPElastic::ApplyYou << 84 theElastic->clear();
73 << 85 }
74 { << 86 }
75 G4ParticleHPManager::GetInstance()->OpenReac << 87 }
76 const G4Material* theMaterial = aTrack.GetMa << 88
77 auto n = (G4int)theMaterial->GetNumberOfElem << 89 #include "G4ParticleHPThermalBoost.hh"
78 std::size_t index = theMaterial->GetElement( << 90
79 << 91 G4HadFinalState * G4ParticleHPElastic::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& aNucleus )
80 if (!isFromTSL) { << 92 {
81 if (n != 1) { << 93
>> 94 //if ( numEle < (G4int)G4Element::GetNumberOfElements() ) addChannelForNewElement();
>> 95
>> 96 G4ParticleHPManager::GetInstance()->OpenReactionWhiteBoard();
>> 97 const G4Material * theMaterial = aTrack.GetMaterial();
>> 98 G4int n = theMaterial->GetNumberOfElements();
>> 99 G4int index = theMaterial->GetElement(0)->GetIndex();
>> 100 if(n!=1)
>> 101 {
82 G4int i; 102 G4int i;
83 auto xSec = new G4double[n]; << 103 G4double* xSec = new G4double[n];
84 G4double sum = 0; << 104 G4double sum=0;
85 const G4double* NumAtomsPerVolume = theM << 105 const G4double * NumAtomsPerVolume = theMaterial->GetVecNbOfAtomsPerVolume();
86 G4double rWeight; << 106 G4double rWeight;
87 G4ParticleHPThermalBoost aThermalE; 107 G4ParticleHPThermalBoost aThermalE;
88 for (i = 0; i < n; ++i) { << 108 for (i=0; i<n; i++)
>> 109 {
89 index = theMaterial->GetElement(i)->Ge 110 index = theMaterial->GetElement(i)->GetIndex();
90 rWeight = NumAtomsPerVolume[i]; 111 rWeight = NumAtomsPerVolume[i];
91 xSec[i] = ((*theElastic)[index]) << 112 //xSec[i] = theElastic[index].GetXsec(aThermalE.GetThermalEnergy(aTrack,
92 ->GetXsec(aThermalE.GetThe << 113 xSec[i] = ((*theElastic)[index])->GetXsec(aThermalE.GetThermalEnergy(aTrack,
93 << 114 theMaterial->GetElement(i),
>> 115 theMaterial->GetTemperature()));
94 xSec[i] *= rWeight; 116 xSec[i] *= rWeight;
95 sum += xSec[i]; << 117 sum+=xSec[i];
96 } 118 }
97 G4double random = G4UniformRand(); 119 G4double random = G4UniformRand();
98 G4double running = 0; 120 G4double running = 0;
99 for (i = 0; i < n; ++i) { << 121 for (i=0; i<n; i++)
>> 122 {
100 running += xSec[i]; 123 running += xSec[i];
101 index = theMaterial->GetElement(i)->Ge 124 index = theMaterial->GetElement(i)->GetIndex();
102 if (sum == 0 || random <= running / su << 125 //if(random<=running/sum) break;
>> 126 if( sum == 0 || random <= running/sum ) break;
103 } 127 }
104 delete[] xSec; << 128 delete [] xSec;
>> 129 // it is element-wise initialised.
105 } 130 }
106 } << 131 //G4HadFinalState* finalState = theElastic[index].ApplyYourself(aTrack);
107 else { << 132 G4HadFinalState* finalState = ((*theElastic)[index])->ApplyYourself(aTrack);
108 G4int i; << 133 if (overrideSuspension) finalState->SetStatusChange(isAlive);
109 if (n != 1) { << 134
110 for (i = 0; i < n; ++i) { << 135 //Overwrite target parameters
111 if (aNucleus.GetZ_asInt() == (G4int)(t << 136 aNucleus.SetParameters(G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA(),G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargZ());
112 index = theMaterial->GetElement(i)-> << 137 const G4Element* target_element = (*G4Element::GetElementTable())[index];
113 } << 138 const G4Isotope* target_isotope=NULL;
114 } << 139 G4int iele = target_element->GetNumberOfIsotopes();
>> 140 for ( G4int j = 0 ; j != iele ; j++ ) {
>> 141 target_isotope=target_element->GetIsotope( j );
>> 142 if ( target_isotope->GetN() == G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA() ) break;
115 } 143 }
>> 144 //G4cout << "Target Material of this reaction is " << theMaterial->GetName() << G4endl;
>> 145 //G4cout << "Target Element of this reaction is " << target_element->GetName() << G4endl;
>> 146 //G4cout << "Target Isotope of this reaction is " << target_isotope->GetName() << G4endl;
>> 147 aNucleus.SetIsotope( target_isotope );
>> 148
>> 149 G4ParticleHPManager::GetInstance()->CloseReactionWhiteBoard();
>> 150 return finalState;
116 } 151 }
117 152
118 // The boolean "true", as last argument, spe <<
119 // that it is an elastic channel: this is ne <<
120 G4HadFinalState* finalState = ((*theElastic) <<
121 <<
122 if (overrideSuspension) finalState->SetStatu <<
123 <<
124 // Overwrite target parameters <<
125 aNucleus.SetParameters(G4ParticleHPManager:: <<
126 G4ParticleHPManager:: <<
127 const G4Element* target_element = (*G4Elemen <<
128 const G4Isotope* target_isotope = nullptr; <<
129 auto iele = (G4int)target_element->GetNumber <<
130 for (G4int j = 0; j != iele; ++j) { <<
131 target_isotope = target_element->GetIsotop <<
132 if (target_isotope->GetN() <<
133 == G4ParticleHPManager::GetInstance()- <<
134 break; <<
135 } <<
136 aNucleus.SetIsotope(target_isotope); <<
137 <<
138 G4ParticleHPManager::GetInstance()->CloseRea <<
139 return finalState; <<
140 } <<
141 <<
142 const std::pair<G4double, G4double> G4Particle 153 const std::pair<G4double, G4double> G4ParticleHPElastic::GetFatalEnergyCheckLevels() const
143 { 154 {
144 // max energy non-conservation is mass of he << 155 //return std::pair<G4double, G4double>(10*perCent,10*GeV);
145 return std::pair<G4double, G4double>(10.0 * << 156 return std::pair<G4double, G4double>(10*perCent,DBL_MAX);
146 } 157 }
147 158
148 G4int G4ParticleHPElastic::GetVerboseLevel() c << 159 /*
>> 160 void G4ParticleHPElastic::addChannelForNewElement()
149 { 161 {
150 return G4ParticleHPManager::GetInstance()->G << 162 G4ParticleHPElasticFS* theFS = new G4ParticleHPElasticFS;
>> 163 for ( G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements() ; i++ )
>> 164 {
>> 165 G4cout << "G4ParticleHPElastic Prepairing Data for the new element of " << (*(G4Element::GetElementTable()))[i]->GetName() << G4endl;
>> 166 theElastic.push_back( new G4ParticleHPChannel );
>> 167 (*theElastic[i]).Init((*(G4Element::GetElementTable()))[i], dirName);
>> 168 while(!(*theElastic[i]).Register(theFS)) ;
>> 169 }
>> 170 delete theFS;
>> 171 numEle = (G4int)G4Element::GetNumberOfElements();
151 } 172 }
>> 173 */
152 174
153 void G4ParticleHPElastic::SetVerboseLevel(G4in << 175 G4int G4ParticleHPElastic::GetVerboseLevel() const
154 { 176 {
155 G4ParticleHPManager::GetInstance()->SetVerbo << 177 return G4ParticleHPManager::GetInstance()->GetVerboseLevel();
>> 178 }
>> 179 void G4ParticleHPElastic::SetVerboseLevel( G4int newValue )
>> 180 {
>> 181 G4ParticleHPManager::GetInstance()->SetVerboseLevel(newValue);
156 } 182 }
157 <<
158 void G4ParticleHPElastic::BuildPhysicsTable(co 183 void G4ParticleHPElastic::BuildPhysicsTable(const G4ParticleDefinition&)
159 { 184 {
160 G4ParticleHPManager* hpmanager = G4ParticleH <<
161 185
162 theElastic = hpmanager->GetElasticFinalState << 186 G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
163 187
164 if (G4Threading::IsMasterThread()) { << 188 theElastic = hpmanager->GetElasticFinalStates();
165 if (theElastic == nullptr) theElastic = ne <<
166 189
167 if (numEle == (G4int)G4Element::GetNumberO << 190 if ( G4Threading::IsMasterThread() ) {
168 191
169 if (theElastic->size() == G4Element::GetNu << 192 if ( theElastic == NULL ) theElastic = new std::vector<G4ParticleHPChannel*>;
170 numEle = (G4int)G4Element::GetNumberOfEl <<
171 return; <<
172 } <<
173 193
174 auto theFS = new G4ParticleHPElasticFS; << 194 if ( numEle == (G4int)G4Element::GetNumberOfElements() ) return;
175 if (G4FindDataDir("G4NEUTRONHPDATA") == nu <<
176 throw G4HadronicException( <<
177 __FILE__, __LINE__, <<
178 "Please setenv G4NEUTRONHPDATA to poin <<
179 dirName = G4FindDataDir("G4NEUTRONHPDATA") <<
180 G4String tString = "/Elastic"; <<
181 dirName = dirName + tString; <<
182 for (G4int i = numEle; i < (G4int)G4Elemen <<
183 theElastic->push_back(new G4ParticleHPCh <<
184 ((*theElastic)[i])->Init((*(G4Element::G <<
185 // while(!((*theElastic)[i])->Register(t <<
186 ((*theElastic)[i])->Register(theFS); <<
187 } <<
188 delete theFS; <<
189 hpmanager->RegisterElasticFinalStates(theE <<
190 } <<
191 numEle = (G4int)G4Element::GetNumberOfElemen <<
192 } <<
193 195
>> 196 if ( theElastic->size() == G4Element::GetNumberOfElements() ) {
>> 197 numEle = G4Element::GetNumberOfElements();
>> 198 return;
>> 199 }
>> 200
>> 201 G4ParticleHPElasticFS * theFS = new G4ParticleHPElasticFS;
>> 202 if(!std::getenv("G4NEUTRONHPDATA"))
>> 203 throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");
>> 204 dirName = std::getenv("G4NEUTRONHPDATA");
>> 205 G4String tString = "/Elastic";
>> 206 dirName = dirName + tString;
>> 207 for ( G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements() ; i++ ) {
>> 208 theElastic->push_back( new G4ParticleHPChannel );
>> 209 ((*theElastic)[i])->Init((*(G4Element::GetElementTable()))[i], dirName);
>> 210 //while(!((*theElastic)[i])->Register(theFS)) ;
>> 211 ((*theElastic)[i])->Register(theFS) ;
>> 212 }
>> 213 delete theFS;
>> 214 hpmanager->RegisterElasticFinalStates( theElastic );
>> 215
>> 216 }
>> 217 numEle = G4Element::GetNumberOfElements();
>> 218 }
194 void G4ParticleHPElastic::ModelDescription(std 219 void G4ParticleHPElastic::ModelDescription(std::ostream& outFile) const
195 { 220 {
196 outFile << "High Precision model based on Ev << 221 outFile << "High Precision model based on Evaluated Nuclear Data Files (ENDF) for inelastic reaction of neutrons below 20MeV\n";
197 "reaction of neutrons below 20MeV <<
198 } 222 }
199 223