| 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 // ------------------------------------------- 27 // -------------------------------------------------------------------
28 // 28 //
29 // GEANT4 Class file 29 // GEANT4 Class file
30 // 30 //
31 // 31 //
32 // File name: G4CrossSectionDataStore 32 // File name: G4CrossSectionDataStore
33 // 33 //
34 // Modifications: 34 // Modifications:
35 // 23.01.2009 V.Ivanchenko add destruction of 35 // 23.01.2009 V.Ivanchenko add destruction of data sets
36 // 29.04.2010 G.Folger modifictaions for i 36 // 29.04.2010 G.Folger modifictaions for integer A & Z
37 // 14.03.2011 V.Ivanchenko fixed DumpPhysicsTa 37 // 14.03.2011 V.Ivanchenko fixed DumpPhysicsTable
38 // 15.08.2011 G.Folger, V.Ivanchenko, T.Koi, D 38 // 15.08.2011 G.Folger, V.Ivanchenko, T.Koi, D.Wright redesign the class
39 // 07.03.2013 M.Maire cosmetic in DumpPhysicsT 39 // 07.03.2013 M.Maire cosmetic in DumpPhysicsTable
40 // 40 //
41 //....oooOO0OOooo........oooOO0OOooo........oo 41 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
42 //....oooOO0OOooo........oooOO0OOooo........oo 42 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
43 43
44 #include "G4CrossSectionDataStore.hh" 44 #include "G4CrossSectionDataStore.hh"
45 #include "G4SystemOfUnits.hh" 45 #include "G4SystemOfUnits.hh"
46 #include "G4UnitsTable.hh" 46 #include "G4UnitsTable.hh"
47 #include "Randomize.hh" 47 #include "Randomize.hh"
48 #include "G4Nucleus.hh" 48 #include "G4Nucleus.hh"
49 49
50 #include "G4DynamicParticle.hh" 50 #include "G4DynamicParticle.hh"
51 #include "G4Isotope.hh" 51 #include "G4Isotope.hh"
52 #include "G4Element.hh" 52 #include "G4Element.hh"
53 #include "G4Material.hh" 53 #include "G4Material.hh"
54 #include "G4MaterialTable.hh" 54 #include "G4MaterialTable.hh"
55 #include "G4NistManager.hh" 55 #include "G4NistManager.hh"
56 #include "G4HadronicParameters.hh" 56 #include "G4HadronicParameters.hh"
57 #include <algorithm> 57 #include <algorithm>
58 #include <typeinfo> 58 #include <typeinfo>
59 59
60 //....oooOO0OOooo........oooOO0OOooo........oo 60 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
61 61
62 G4CrossSectionDataStore::G4CrossSectionDataSto 62 G4CrossSectionDataStore::G4CrossSectionDataStore()
63 : nist(G4NistManager::Instance()) 63 : nist(G4NistManager::Instance())
64 {} 64 {}
65 65
66 //....oooOO0OOooo........oooOO0OOooo........oo 66 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
67 67
68 G4double 68 G4double
69 G4CrossSectionDataStore::ComputeCrossSection(c 69 G4CrossSectionDataStore::ComputeCrossSection(const G4DynamicParticle* dp,
70 const G4Material* mat) 70 const G4Material* mat)
71 { 71 {
72 currentMaterial = mat; 72 currentMaterial = mat;
73 matParticle = dp->GetDefinition(); 73 matParticle = dp->GetDefinition();
74 matKinEnergy = dp->GetKineticEnergy(); 74 matKinEnergy = dp->GetKineticEnergy();
75 matCrossSection = 0.0; 75 matCrossSection = 0.0;
76 76
77 std::size_t nElements = mat->GetNumberOfElem 77 std::size_t nElements = mat->GetNumberOfElements();
78 const G4double* nAtomsPerVolume = mat->GetVe 78 const G4double* nAtomsPerVolume = mat->GetVecNbOfAtomsPerVolume();
79 79
80 if(xsecelm.size() < nElements) { xsecelm.res 80 if(xsecelm.size() < nElements) { xsecelm.resize(nElements); }
81 81
82 for(G4int i=0; i<(G4int)nElements; ++i) { 82 for(G4int i=0; i<(G4int)nElements; ++i) {
83 G4double xs = 83 G4double xs =
84 nAtomsPerVolume[i]*GetCrossSection(dp, m 84 nAtomsPerVolume[i]*GetCrossSection(dp, mat->GetElement(i), mat);
85 matCrossSection += std::max(xs, 0.0); 85 matCrossSection += std::max(xs, 0.0);
86 xsecelm[i] = matCrossSection; 86 xsecelm[i] = matCrossSection;
87 } 87 }
88 return matCrossSection; 88 return matCrossSection;
89 } 89 }
90 90
91 //....oooOO0OOooo........oooOO0OOooo........oo 91 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
92 92
93 G4double G4CrossSectionDataStore::GetCrossSect 93 G4double G4CrossSectionDataStore::GetCrossSection(const G4DynamicParticle* dp,
94 94 const G4Element* elm,
95 95 const G4Material* mat)
96 { 96 {
97 // first check the most last cross section 97 // first check the most last cross section
98 G4int i = nDataSetList-1; 98 G4int i = nDataSetList-1;
99 G4int Z = elm->GetZasInt(); 99 G4int Z = elm->GetZasInt();
100 100
101 if(elm->GetNaturalAbundanceFlag() && 101 if(elm->GetNaturalAbundanceFlag() &&
102 dataSetList[i]->IsElementApplicable(dp, Z 102 dataSetList[i]->IsElementApplicable(dp, Z, mat))
103 { 103 {
104 // element wise cross section 104 // element wise cross section
105 return dataSetList[i]->GetElementCrossSect 105 return dataSetList[i]->GetElementCrossSection(dp, Z, mat);
106 } 106 }
107 107
108 // isotope wise cross section 108 // isotope wise cross section
109 G4int nIso = (G4int)elm->GetNumberOfIsotopes 109 G4int nIso = (G4int)elm->GetNumberOfIsotopes();
110 110
111 // user-defined isotope abundances 111 // user-defined isotope abundances
112 const G4double* abundVector = elm->GetRelati 112 const G4double* abundVector = elm->GetRelativeAbundanceVector();
113 113
114 G4double sigma = 0.0; 114 G4double sigma = 0.0;
115 115
116 // isotope and element wise cross sections 116 // isotope and element wise cross sections
117 for(G4int j = 0; j < nIso; ++j) 117 for(G4int j = 0; j < nIso; ++j)
118 { 118 {
119 const G4Isotope* iso = elm->GetIsotope(j); 119 const G4Isotope* iso = elm->GetIsotope(j);
120 sigma += abundVector[j] * 120 sigma += abundVector[j] *
121 GetIsoCrossSection(dp, Z, iso->GetN(), i 121 GetIsoCrossSection(dp, Z, iso->GetN(), iso, elm, mat, i);
122 } 122 }
123 return sigma; 123 return sigma;
124 } 124 }
125 125
126 //....oooOO0OOooo........oooOO0OOooo........oo 126 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
127 127
128 G4double 128 G4double
129 G4CrossSectionDataStore::GetIsoCrossSection(co 129 G4CrossSectionDataStore::GetIsoCrossSection(const G4DynamicParticle* dp,
130 G4int Z, G4int A, 130 G4int Z, G4int A,
131 const G4Isotope* iso, 131 const G4Isotope* iso,
132 const G4Element* elm, 132 const G4Element* elm,
133 const G4Material* mat, 133 const G4Material* mat,
134 G4int idx) 134 G4int idx)
135 { 135 {
136 // this methods is called after the check th 136 // this methods is called after the check that dataSetList[idx]
137 // depend on isotopes, so first isotopes are 137 // depend on isotopes, so first isotopes are checked
138 if(dataSetList[idx]->IsIsoApplicable(dp, Z, 138 if(dataSetList[idx]->IsIsoApplicable(dp, Z, A, elm, mat) ) {
139 return dataSetList[idx]->GetIsoCrossSectio 139 return dataSetList[idx]->GetIsoCrossSection(dp, Z, A, iso, elm, mat);
140 } 140 }
141 141
142 // no isotope wise cross section - check oth 142 // no isotope wise cross section - check other datasets
143 for (G4int j = nDataSetList-1; j >= 0; --j) 143 for (G4int j = nDataSetList-1; j >= 0; --j) {
144 if(dataSetList[j]->IsElementApplicable(dp, 144 if(dataSetList[j]->IsElementApplicable(dp, Z, mat)) {
145 return dataSetList[j]->GetElementCrossSe 145 return dataSetList[j]->GetElementCrossSection(dp, Z, mat);
146 } else if (dataSetList[j]->IsIsoApplicable 146 } else if (dataSetList[j]->IsIsoApplicable(dp, Z, A, elm, mat)) {
147 return dataSetList[j]->GetIsoCrossSectio 147 return dataSetList[j]->GetIsoCrossSection(dp, Z, A, iso, elm, mat);
148 } 148 }
149 } 149 }
150 G4ExceptionDescription ed; 150 G4ExceptionDescription ed;
151 ed << "No isotope cross section found for " 151 ed << "No isotope cross section found for "
152 << dp->GetDefinition()->GetParticleName() 152 << dp->GetDefinition()->GetParticleName()
153 << " off target Element " << elm->GetName 153 << " off target Element " << elm->GetName()
154 << " Z= " << Z << " A= " << A; 154 << " Z= " << Z << " A= " << A;
155 if(nullptr != mat) ed << " from " << mat->Ge 155 if(nullptr != mat) ed << " from " << mat->GetName();
156 ed << " E(MeV)=" << dp->GetKineticEnergy()/M 156 ed << " E(MeV)=" << dp->GetKineticEnergy()/MeV << G4endl;
157 G4Exception("G4CrossSectionDataStore::GetIso 157 G4Exception("G4CrossSectionDataStore::GetIsoCrossSection", "had001",
158 FatalException, ed); 158 FatalException, ed);
159 return 0.0; 159 return 0.0;
160 } 160 }
161 161
162 //....oooOO0OOooo........oooOO0OOooo........oo 162 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
163 163
164 G4double 164 G4double
165 G4CrossSectionDataStore::GetCrossSection(const 165 G4CrossSectionDataStore::GetCrossSection(const G4DynamicParticle* dp,
166 G4int 166 G4int Z, G4int A,
167 const G4Isotope* iso, 167 const G4Isotope* iso,
168 const 168 const G4Element* elm,
169 const G4Material* mat) 169 const G4Material* mat)
170 { 170 {
171 for (G4int i = nDataSetList-1; i >= 0; --i) 171 for (G4int i = nDataSetList-1; i >= 0; --i) {
172 if (dataSetList[i]->IsIsoApplicable(dp, Z, 172 if (dataSetList[i]->IsIsoApplicable(dp, Z, A, elm, mat) ) {
173 return dataSetList[i]->GetIsoCrossSectio 173 return dataSetList[i]->GetIsoCrossSection(dp, Z, A, iso, elm, mat);
174 } else if(dataSetList[i]->IsElementApplica 174 } else if(dataSetList[i]->IsElementApplicable(dp, Z, mat)) {
175 return dataSetList[i]->GetElementCrossSe 175 return dataSetList[i]->GetElementCrossSection(dp, Z, mat);
176 } 176 }
177 } 177 }
178 G4ExceptionDescription ed; 178 G4ExceptionDescription ed;
179 ed << "No isotope cross section found for " 179 ed << "No isotope cross section found for "
180 << dp->GetDefinition()->GetParticleName() 180 << dp->GetDefinition()->GetParticleName()
181 << " off target Element " << elm->GetName 181 << " off target Element " << elm->GetName()
182 << " Z= " << Z << " A= " << A; 182 << " Z= " << Z << " A= " << A;
183 if(nullptr != mat) ed << " from " << mat->Ge 183 if(nullptr != mat) ed << " from " << mat->GetName();
184 ed << " E(MeV)=" << dp->GetKineticEnergy()/M 184 ed << " E(MeV)=" << dp->GetKineticEnergy()/MeV << G4endl;
185 G4Exception("G4CrossSectionDataStore::GetCro 185 G4Exception("G4CrossSectionDataStore::GetCrossSection", "had001",
186 FatalException, ed); 186 FatalException, ed);
187 return 0.0; 187 return 0.0;
188 } 188 }
189 189
190 //....oooOO0OOooo........oooOO0OOooo........oo 190 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
191 191
192 const G4Element* 192 const G4Element*
193 G4CrossSectionDataStore::SampleZandA(const G4D 193 G4CrossSectionDataStore::SampleZandA(const G4DynamicParticle* dp,
194 const G4M 194 const G4Material* mat,
195 G4Nucleus& target) 195 G4Nucleus& target)
196 { 196 {
197 if(nullptr != forcedElement) { return forced 197 if(nullptr != forcedElement) { return forcedElement; }
198 std::size_t nElements = mat->GetNumberOfElem 198 std::size_t nElements = mat->GetNumberOfElements();
199 const G4Element* anElement = mat->GetElement 199 const G4Element* anElement = mat->GetElement(0);
200 200
201 // select element from a compound 201 // select element from a compound
202 if(1 < nElements) { 202 if(1 < nElements) {
203 G4double cross = matCrossSection*G4Uniform 203 G4double cross = matCrossSection*G4UniformRand();
204 for(G4int i=0; i<(G4int)nElements; ++i) { 204 for(G4int i=0; i<(G4int)nElements; ++i) {
205 if(cross <= xsecelm[i]) { 205 if(cross <= xsecelm[i]) {
206 anElement = mat->GetElement(i); 206 anElement = mat->GetElement(i);
207 break; 207 break;
208 } 208 }
209 } 209 }
210 } 210 }
211 211
212 G4int Z = anElement->GetZasInt(); 212 G4int Z = anElement->GetZasInt();
213 const G4Isotope* iso = nullptr; 213 const G4Isotope* iso = nullptr;
214 214
215 G4int i = nDataSetList-1; 215 G4int i = nDataSetList-1;
216 if (dataSetList[i]->IsElementApplicable(dp, 216 if (dataSetList[i]->IsElementApplicable(dp, Z, mat)) {
217 217
218 //---------------------------------------- 218 //----------------------------------------------------------------
219 // element-wise cross section 219 // element-wise cross section
220 // isotope cross section is not computed 220 // isotope cross section is not computed
221 //---------------------------------------- 221 //----------------------------------------------------------------
222 std::size_t nIso = anElement->GetNumberOfI 222 std::size_t nIso = anElement->GetNumberOfIsotopes();
223 iso = anElement->GetIsotope(0); 223 iso = anElement->GetIsotope(0);
224 224
225 // more than 1 isotope 225 // more than 1 isotope
226 if(1 < nIso) { 226 if(1 < nIso) {
227 iso = dataSetList[i]->SelectIsotope(anEl 227 iso = dataSetList[i]->SelectIsotope(anElement,
228 dp-> 228 dp->GetKineticEnergy(),
229 dp->GetLogKineticEnergy()); 229 dp->GetLogKineticEnergy());
230 } 230 }
231 } else { 231 } else {
232 232
233 //---------------------------------------- 233 //----------------------------------------------------------------
234 // isotope-wise cross section 234 // isotope-wise cross section
235 // isotope cross section is computed 235 // isotope cross section is computed
236 //---------------------------------------- 236 //----------------------------------------------------------------
237 std::size_t nIso = anElement->GetNumberOfI 237 std::size_t nIso = anElement->GetNumberOfIsotopes();
238 iso = anElement->GetIsotope(0); 238 iso = anElement->GetIsotope(0);
239 239
240 // more than 1 isotope 240 // more than 1 isotope
241 if(1 < nIso) { 241 if(1 < nIso) {
242 const G4double* abundVector = anElement- 242 const G4double* abundVector = anElement->GetRelativeAbundanceVector();
243 if(xseciso.size() < nIso) { xseciso.resi 243 if(xseciso.size() < nIso) { xseciso.resize(nIso); }
244 244
245 G4double cross = 0.0; 245 G4double cross = 0.0;
246 G4int j; 246 G4int j;
247 for (j = 0; j<(G4int)nIso; ++j) { 247 for (j = 0; j<(G4int)nIso; ++j) {
248 G4double xsec = 0.0; 248 G4double xsec = 0.0;
249 if(abundVector[j] > 0.0) { 249 if(abundVector[j] > 0.0) {
250 iso = anElement->GetIsotope(j); 250 iso = anElement->GetIsotope(j);
251 xsec = abundVector[j]* 251 xsec = abundVector[j]*
252 GetIsoCrossSection(dp, Z, iso->GetN(), i 252 GetIsoCrossSection(dp, Z, iso->GetN(), iso, anElement, mat, i);
253 } 253 }
254 cross += xsec; 254 cross += xsec;
255 xseciso[j] = cross; 255 xseciso[j] = cross;
256 } 256 }
257 cross *= G4UniformRand(); 257 cross *= G4UniformRand();
258 for (j = 0; j<(G4int)nIso; ++j) { 258 for (j = 0; j<(G4int)nIso; ++j) {
259 if(cross <= xseciso[j]) { 259 if(cross <= xseciso[j]) {
260 iso = anElement->GetIsotope(j); 260 iso = anElement->GetIsotope(j);
261 break; 261 break;
262 } 262 }
263 } 263 }
264 } 264 }
265 } 265 }
266 target.SetIsotope(iso); 266 target.SetIsotope(iso);
267 return anElement; 267 return anElement;
268 } 268 }
269 269
270 //....oooOO0OOooo........oooOO0OOooo........oo 270 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
271 271
272 void 272 void
273 G4CrossSectionDataStore::BuildPhysicsTable(con 273 G4CrossSectionDataStore::BuildPhysicsTable(const G4ParticleDefinition& part)
274 { 274 {
275 if (nDataSetList == 0) { 275 if (nDataSetList == 0) {
276 G4ExceptionDescription ed; 276 G4ExceptionDescription ed;
277 ed << "No cross section is registered for 277 ed << "No cross section is registered for "
278 << part.GetParticleName() << G4endl; 278 << part.GetParticleName() << G4endl;
279 G4Exception("G4CrossSectionDataStore::Buil 279 G4Exception("G4CrossSectionDataStore::BuildPhysicsTable", "had001",
280 FatalException, ed); 280 FatalException, ed);
281 return; 281 return;
282 } 282 }
283 matParticle = ∂ 283 matParticle = ∂
284 for (G4int i=0; i<nDataSetList; ++i) { 284 for (G4int i=0; i<nDataSetList; ++i) {
285 dataSetList[i]->BuildPhysicsTable(part); 285 dataSetList[i]->BuildPhysicsTable(part);
286 } 286 }
287 const G4MaterialTable* theMatTable = G4Mater 287 const G4MaterialTable* theMatTable = G4Material::GetMaterialTable();
288 std::size_t nelm = 0; 288 std::size_t nelm = 0;
289 std::size_t niso = 0; 289 std::size_t niso = 0;
290 for(auto mat : *theMatTable) { 290 for(auto mat : *theMatTable) {
291 std::size_t nElements = mat->GetNumberOfEl 291 std::size_t nElements = mat->GetNumberOfElements();
292 nelm = std::max(nelm, nElements); 292 nelm = std::max(nelm, nElements);
293 for(G4int j=0; j<(G4int)nElements; ++j) { 293 for(G4int j=0; j<(G4int)nElements; ++j) {
294 niso = std::max(niso, mat->GetElement(j) 294 niso = std::max(niso, mat->GetElement(j)->GetNumberOfIsotopes());
295 } 295 }
296 } 296 }
297 // define vectors for a run 297 // define vectors for a run
298 xsecelm.resize(nelm, 0.0); 298 xsecelm.resize(nelm, 0.0);
299 xseciso.resize(niso, 0.0); 299 xseciso.resize(niso, 0.0);
300 } 300 }
301 301
302 //....oooOO0OOooo........oooOO0OOooo........oo 302 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
303 303
304 void 304 void
305 G4CrossSectionDataStore::DumpPhysicsTable(cons 305 G4CrossSectionDataStore::DumpPhysicsTable(const G4ParticleDefinition& part)
306 { 306 {
307 // Print out all cross section data sets use 307 // Print out all cross section data sets used and the energies at
308 // which they apply 308 // which they apply
309 309
310 if (nDataSetList == 0) { 310 if (nDataSetList == 0) {
311 G4cout << "WARNING - G4CrossSectionDataSto 311 G4cout << "WARNING - G4CrossSectionDataStore::DumpPhysicsTable: "
312 << " no data sets registered" << G4endl; 312 << " no data sets registered" << G4endl;
313 return; 313 return;
314 } 314 }
315 315
316 for (G4int i = nDataSetList-1; i >= 0; --i) 316 for (G4int i = nDataSetList-1; i >= 0; --i) {
317 G4double e1 = dataSetList[i]->GetMinKinEne 317 G4double e1 = dataSetList[i]->GetMinKinEnergy();
318 G4double e2 = dataSetList[i]->GetMaxKinEne 318 G4double e2 = dataSetList[i]->GetMaxKinEnergy();
319 G4cout 319 G4cout
320 << " Cr_sctns: " << std::setw(25) << 320 << " Cr_sctns: " << std::setw(25) << dataSetList[i]->GetName() << ": "
321 << G4BestUnit(e1, "Energy") << " ---> " 321 << G4BestUnit(e1, "Energy") << " ---> "
322 << G4BestUnit(e2, "Energy") << "\n"; 322 << G4BestUnit(e2, "Energy") << "\n";
323 if (dataSetList[i]->GetName() == "G4CrossS 323 if (dataSetList[i]->GetName() == "G4CrossSectionPairGG") {
324 dataSetList[i]->DumpPhysicsTable(part); 324 dataSetList[i]->DumpPhysicsTable(part);
325 G4cout << G4endl; 325 G4cout << G4endl;
326 } 326 }
327 } 327 }
328 } 328 }
329 329
330 //....oooOO0OOooo........oooOO0OOooo........oo 330 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
331 331
332 void G4CrossSectionDataStore::DumpHtml(const G 332 void G4CrossSectionDataStore::DumpHtml(const G4ParticleDefinition& /* pD */,
333 std::of 333 std::ofstream& outFile) const
334 { 334 {
335 // Write cross section data set info to html 335 // Write cross section data set info to html physics list
336 // documentation page 336 // documentation page
337 337
338 G4double ehi = 0; 338 G4double ehi = 0;
339 G4double elo = 0; 339 G4double elo = 0;
340 auto param = G4HadronicParameters::Instance( 340 auto param = G4HadronicParameters::Instance();
341 G4String physListName = param->GetPhysListNa 341 G4String physListName = param->GetPhysListName();
342 G4String dirName = param->GetPhysListDocDir( 342 G4String dirName = param->GetPhysListDocDir();
343 343
344 for (G4int i = nDataSetList-1; i > 0; i--) { 344 for (G4int i = nDataSetList-1; i > 0; i--) {
345 elo = dataSetList[i]->GetMinKinEnergy()/Ge 345 elo = dataSetList[i]->GetMinKinEnergy()/GeV;
346 ehi = dataSetList[i]->GetMaxKinEnergy()/Ge 346 ehi = dataSetList[i]->GetMaxKinEnergy()/GeV;
347 outFile << " <li><b><a href=\"" << ph 347 outFile << " <li><b><a href=\"" << physListName << "_"
348 << dataSetList[i]->GetName() << ".html\" 348 << dataSetList[i]->GetName() << ".html\"> "
349 << dataSetList[i]->GetName() << "< 349 << dataSetList[i]->GetName() << "</a> from "
350 << elo << " GeV to " << ehi << " G 350 << elo << " GeV to " << ehi << " GeV </b></li>\n";
351 PrintCrossSectionHtml(dataSetList[i], phys 351 PrintCrossSectionHtml(dataSetList[i], physListName, dirName);
352 } 352 }
353 353
354 G4double defaultHi = dataSetList[0]->GetMaxK 354 G4double defaultHi = dataSetList[0]->GetMaxKinEnergy()/GeV;
355 if (ehi < defaultHi) { 355 if (ehi < defaultHi) {
356 outFile << " <li><b><a href=\"" << da 356 outFile << " <li><b><a href=\"" << dataSetList[0]->GetName()
357 << ".html\"> " 357 << ".html\"> "
358 << dataSetList[0]->GetName() << "< 358 << dataSetList[0]->GetName() << "</a> from "
359 << ehi << " GeV to " << defaultHi 359 << ehi << " GeV to " << defaultHi << " GeV </b></li>\n";
360 PrintCrossSectionHtml(dataSetList[0], phys 360 PrintCrossSectionHtml(dataSetList[0], physListName, dirName);
361 } 361 }
362 } 362 }
363 363
364 //....oooOO0OOooo........oooOO0OOooo........oo 364 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
365 365
366 void G4CrossSectionDataStore::PrintCrossSectio 366 void G4CrossSectionDataStore::PrintCrossSectionHtml(const G4VCrossSectionDataSet *cs,
367 367 const G4String& physListName,
368 368 const G4String& dirName) const
369 { 369 {
370 370
371 G4String pathName = dirName + "/" + physList 371 G4String pathName = dirName + "/" + physListName + "_" + HtmlFileName(cs->GetName());
372 std::ofstream outCS; 372 std::ofstream outCS;
373 outCS.open(pathName); 373 outCS.open(pathName);
374 outCS << "<html>\n"; 374 outCS << "<html>\n";
375 outCS << "<head>\n"; 375 outCS << "<head>\n";
376 outCS << "<title>Description of " << cs->Get 376 outCS << "<title>Description of " << cs->GetName()
377 << "</title>\n"; 377 << "</title>\n";
378 outCS << "</head>\n"; 378 outCS << "</head>\n";
379 outCS << "<body>\n"; 379 outCS << "<body>\n";
380 380
381 cs->CrossSectionDescription(outCS); 381 cs->CrossSectionDescription(outCS);
382 382
383 outCS << "</body>\n"; 383 outCS << "</body>\n";
384 outCS << "</html>\n"; 384 outCS << "</html>\n";
385 } 385 }
386 386
387 //....oooOO0OOooo........oooOO0OOooo........oo 387 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
388 388
389 G4String G4CrossSectionDataStore::HtmlFileName 389 G4String G4CrossSectionDataStore::HtmlFileName(const G4String & in) const
390 { 390 {
391 G4String str(in); 391 G4String str(in);
392 // replace blanks by _ C++11 version: 392 // replace blanks by _ C++11 version:
393 std::transform(str.begin(), str.end(), str. 393 std::transform(str.begin(), str.end(), str.begin(), [](char ch) {
394 return ch == ' ' ? '_' : ch; 394 return ch == ' ' ? '_' : ch;
395 }); 395 });
396 str=str + ".html"; 396 str=str + ".html";
397 return str; 397 return str;
398 } 398 }
399 399
400 //....oooOO0OOooo........oooOO0OOooo........oo 400 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
401 401
402 void G4CrossSectionDataStore::AddDataSet(G4VCr 402 void G4CrossSectionDataStore::AddDataSet(G4VCrossSectionDataSet* p)
403 { 403 {
404 if(p->ForAllAtomsAndEnergies()) { 404 if(p->ForAllAtomsAndEnergies()) {
405 dataSetList.clear(); 405 dataSetList.clear();
406 nDataSetList = 0; 406 nDataSetList = 0;
407 } 407 }
408 dataSetList.push_back(p); 408 dataSetList.push_back(p);
409 ++nDataSetList; 409 ++nDataSetList;
410 } 410 }
411 411
412 //....oooOO0OOooo........oooOO0OOooo........oo 412 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
413 413
414 void G4CrossSectionDataStore::AddDataSet(G4VCr 414 void G4CrossSectionDataStore::AddDataSet(G4VCrossSectionDataSet* p, std::size_t i)
415 { 415 {
416 if(p->ForAllAtomsAndEnergies()) { 416 if(p->ForAllAtomsAndEnergies()) {
417 dataSetList.clear(); 417 dataSetList.clear();
418 dataSetList.push_back(p); 418 dataSetList.push_back(p);
419 nDataSetList = 1; 419 nDataSetList = 1;
420 } else if ( i >= dataSetList.size() ) { 420 } else if ( i >= dataSetList.size() ) {
421 dataSetList.push_back(p); 421 dataSetList.push_back(p);
422 ++nDataSetList; 422 ++nDataSetList;
423 } else { 423 } else {
424 std::vector< G4VCrossSectionDataSet* >::it 424 std::vector< G4VCrossSectionDataSet* >::iterator it = dataSetList.end() - i;
425 dataSetList.insert(it , p); 425 dataSetList.insert(it , p);
426 ++nDataSetList; 426 ++nDataSetList;
427 } 427 }
428 } 428 }
429 429
430 //....oooOO0OOooo........oooOO0OOooo........oo 430 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
431 431