| 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(!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 = 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 //delete [] theElastic;
65 { << 77 if ( theElastic != NULL ) {
66 return this->ApplyYourself(aTrack, aNucleus, << 78 for ( std::vector<G4ParticleHPChannel*>::iterator
67 } << 79 it = theElastic->begin() ; it != theElastic->end() ; it++ ) {
68 << 80 delete *it;
69 //-------------------------------------------- << 81 }
70 // New method added by L. Thulliez (CEA-Saclay << 82 theElastic->clear();
71 //-------------------------------------------- << 83 }
72 G4HadFinalState* G4ParticleHPElastic::ApplyYou << 84 }
73 << 85
74 { << 86 #include "G4ParticleHPThermalBoost.hh"
75 G4ParticleHPManager::GetInstance()->OpenReac << 87
76 const G4Material* theMaterial = aTrack.GetMa << 88 G4HadFinalState * G4ParticleHPElastic::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& aNucleus )
77 auto n = (G4int)theMaterial->GetNumberOfElem << 89 {
78 std::size_t index = theMaterial->GetElement( << 90
79 << 91 //if ( numEle < (G4int)G4Element::GetNumberOfElements() ) addChannelForNewElement();
80 if (!isFromTSL) { << 92
81 if (n != 1) { << 93 G4ParticleHPManager::GetInstance()->OpenReactionWhiteBoard();
>> 94 const G4Material * theMaterial = aTrack.GetMaterial();
>> 95 G4int n = theMaterial->GetNumberOfElements();
>> 96 G4int index = theMaterial->GetElement(0)->GetIndex();
>> 97 if(n!=1)
>> 98 {
82 G4int i; 99 G4int i;
83 auto xSec = new G4double[n]; << 100 G4double* xSec = new G4double[n];
84 G4double sum = 0; << 101 G4double sum=0;
85 const G4double* NumAtomsPerVolume = theM << 102 const G4double * NumAtomsPerVolume = theMaterial->GetVecNbOfAtomsPerVolume();
86 G4double rWeight; << 103 G4double rWeight;
87 G4ParticleHPThermalBoost aThermalE; 104 G4ParticleHPThermalBoost aThermalE;
88 for (i = 0; i < n; ++i) { << 105 for (i=0; i<n; i++)
>> 106 {
89 index = theMaterial->GetElement(i)->Ge 107 index = theMaterial->GetElement(i)->GetIndex();
90 rWeight = NumAtomsPerVolume[i]; 108 rWeight = NumAtomsPerVolume[i];
91 xSec[i] = ((*theElastic)[index]) << 109 //xSec[i] = theElastic[index].GetXsec(aThermalE.GetThermalEnergy(aTrack,
92 ->GetXsec(aThermalE.GetThe << 110 xSec[i] = ((*theElastic)[index])->GetXsec(aThermalE.GetThermalEnergy(aTrack,
93 << 111 theMaterial->GetElement(i),
>> 112 theMaterial->GetTemperature()));
94 xSec[i] *= rWeight; 113 xSec[i] *= rWeight;
95 sum += xSec[i]; << 114 sum+=xSec[i];
96 } 115 }
97 G4double random = G4UniformRand(); 116 G4double random = G4UniformRand();
98 G4double running = 0; 117 G4double running = 0;
99 for (i = 0; i < n; ++i) { << 118 for (i=0; i<n; i++)
>> 119 {
100 running += xSec[i]; 120 running += xSec[i];
101 index = theMaterial->GetElement(i)->Ge 121 index = theMaterial->GetElement(i)->GetIndex();
102 if (sum == 0 || random <= running / su << 122 //if(random<=running/sum) break;
>> 123 if( sum == 0 || random <= running/sum ) break;
103 } 124 }
104 delete[] xSec; << 125 delete [] xSec;
>> 126 // it is element-wise initialised.
105 } 127 }
106 } << 128 //G4HadFinalState* finalState = theElastic[index].ApplyYourself(aTrack);
107 else { << 129 G4HadFinalState* finalState = ((*theElastic)[index])->ApplyYourself(aTrack);
108 G4int i; << 130 if (overrideSuspension) finalState->SetStatusChange(isAlive);
109 if (n != 1) { << 131
110 for (i = 0; i < n; ++i) { << 132 //Overwrite target parameters
111 if (aNucleus.GetZ_asInt() == (G4int)(t << 133 aNucleus.SetParameters(G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA(),G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargZ());
112 index = theMaterial->GetElement(i)-> << 134 const G4Element* target_element = (*G4Element::GetElementTable())[index];
113 } << 135 const G4Isotope* target_isotope=NULL;
114 } << 136 G4int iele = target_element->GetNumberOfIsotopes();
>> 137 for ( G4int j = 0 ; j != iele ; j++ ) {
>> 138 target_isotope=target_element->GetIsotope( j );
>> 139 if ( target_isotope->GetN() == G4ParticleHPManager::GetInstance()->GetReactionWhiteBoard()->GetTargA() ) break;
115 } 140 }
>> 141 //G4cout << "Target Material of this reaction is " << theMaterial->GetName() << G4endl;
>> 142 //G4cout << "Target Element of this reaction is " << target_element->GetName() << G4endl;
>> 143 //G4cout << "Target Isotope of this reaction is " << target_isotope->GetName() << G4endl;
>> 144 aNucleus.SetIsotope( target_isotope );
>> 145
>> 146 G4ParticleHPManager::GetInstance()->CloseReactionWhiteBoard();
>> 147 return finalState;
116 } 148 }
117 149
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 150 const std::pair<G4double, G4double> G4ParticleHPElastic::GetFatalEnergyCheckLevels() const
143 { 151 {
144 // max energy non-conservation is mass of he << 152 //return std::pair<G4double, G4double>(10*perCent,10*GeV);
145 return std::pair<G4double, G4double>(10.0 * << 153 return std::pair<G4double, G4double>(10*perCent,DBL_MAX);
146 } 154 }
147 155
148 G4int G4ParticleHPElastic::GetVerboseLevel() c << 156 /*
>> 157 void G4ParticleHPElastic::addChannelForNewElement()
149 { 158 {
150 return G4ParticleHPManager::GetInstance()->G << 159 G4ParticleHPElasticFS* theFS = new G4ParticleHPElasticFS;
>> 160 for ( G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements() ; i++ )
>> 161 {
>> 162 G4cout << "G4ParticleHPElastic Prepairing Data for the new element of " << (*(G4Element::GetElementTable()))[i]->GetName() << G4endl;
>> 163 theElastic.push_back( new G4ParticleHPChannel );
>> 164 (*theElastic[i]).Init((*(G4Element::GetElementTable()))[i], dirName);
>> 165 while(!(*theElastic[i]).Register(theFS)) ;
>> 166 }
>> 167 delete theFS;
>> 168 numEle = (G4int)G4Element::GetNumberOfElements();
151 } 169 }
>> 170 */
152 171
153 void G4ParticleHPElastic::SetVerboseLevel(G4in << 172 G4int G4ParticleHPElastic::GetVerboseLevel() const
154 { 173 {
155 G4ParticleHPManager::GetInstance()->SetVerbo << 174 return G4ParticleHPManager::GetInstance()->GetVerboseLevel();
>> 175 }
>> 176 void G4ParticleHPElastic::SetVerboseLevel( G4int newValue )
>> 177 {
>> 178 G4ParticleHPManager::GetInstance()->SetVerboseLevel(newValue);
156 } 179 }
157 <<
158 void G4ParticleHPElastic::BuildPhysicsTable(co 180 void G4ParticleHPElastic::BuildPhysicsTable(const G4ParticleDefinition&)
159 { 181 {
160 G4ParticleHPManager* hpmanager = G4ParticleH <<
161 182
162 theElastic = hpmanager->GetElasticFinalState << 183 G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
163 184
164 if (G4Threading::IsMasterThread()) { << 185 theElastic = hpmanager->GetElasticFinalStates();
165 if (theElastic == nullptr) theElastic = ne <<
166 186
167 if (numEle == (G4int)G4Element::GetNumberO << 187 if ( G4Threading::IsMasterThread() ) {
168 188
169 if (theElastic->size() == G4Element::GetNu << 189 if ( theElastic == NULL ) theElastic = new std::vector<G4ParticleHPChannel*>;
170 numEle = (G4int)G4Element::GetNumberOfEl <<
171 return; <<
172 } <<
173 190
174 auto theFS = new G4ParticleHPElasticFS; << 191 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 192
>> 193 if ( theElastic->size() == G4Element::GetNumberOfElements() ) {
>> 194 numEle = G4Element::GetNumberOfElements();
>> 195 return;
>> 196 }
>> 197
>> 198 G4ParticleHPElasticFS * theFS = new G4ParticleHPElasticFS;
>> 199 if(!getenv("G4NEUTRONHPDATA"))
>> 200 throw G4HadronicException(__FILE__, __LINE__, "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");
>> 201 dirName = getenv("G4NEUTRONHPDATA");
>> 202 G4String tString = "/Elastic";
>> 203 dirName = dirName + tString;
>> 204 for ( G4int i = numEle ; i < (G4int)G4Element::GetNumberOfElements() ; i++ ) {
>> 205 theElastic->push_back( new G4ParticleHPChannel );
>> 206 ((*theElastic)[i])->Init((*(G4Element::GetElementTable()))[i], dirName);
>> 207 //while(!((*theElastic)[i])->Register(theFS)) ;
>> 208 ((*theElastic)[i])->Register(theFS) ;
>> 209 }
>> 210 delete theFS;
>> 211 hpmanager->RegisterElasticFinalStates( theElastic );
>> 212
>> 213 }
>> 214 numEle = G4Element::GetNumberOfElements();
>> 215 }
194 void G4ParticleHPElastic::ModelDescription(std 216 void G4ParticleHPElastic::ModelDescription(std::ostream& outFile) const
195 { 217 {
196 outFile << "High Precision model based on Ev << 218 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 } 219 }
199 220