| 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 // $Id: G4CrossSectionDataSet.cc 104080 2017-05-10 14:52:27Z gcosmo $
28 // 29 //
29 // Author: Riccardo Capra <capra@ge.infn.it> 30 // Author: Riccardo Capra <capra@ge.infn.it>
30 // Code review by MGP October 2007: removed in 31 // Code review by MGP October 2007: removed inheritance from concrete class
31 // more impro 32 // more improvements needed
32 // 33 //
33 // History: 34 // History:
34 // ----------- 35 // -----------
35 // 30 Jun 2005 RC Created 36 // 30 Jun 2005 RC Created
36 // 14 Oct 2007 MGP Removed inheritan 37 // 14 Oct 2007 MGP Removed inheritance from concrete class G4ShellEMDataSet
37 // 38 //
38 // 15 Jul 2009 N.A.Karakatsanis 39 // 15 Jul 2009 N.A.Karakatsanis
39 // 40 //
40 // - LoadNonLogData 41 // - LoadNonLogData method was created to load only the non-logarithmic data from G4EMLOW
41 // dataset. It is 42 // dataset. It is essentially performing the data loading operations as in the past.
42 // 43 //
43 // - LoadData method 44 // - LoadData method was revised in order to calculate the logarithmic values of the data
44 // It retrieves th 45 // It retrieves the data values from the G4EMLOW data files but, then, calculates the
45 // respective log 46 // respective log values and loads them to seperate data structures.
46 // 47 //
47 // - SetLogEnergiesD 48 // - SetLogEnergiesData method was cretaed to set logarithmic values to G4 data vectors.
48 // The EM data set 49 // The EM data sets, initialized this way, contain both non-log and log values.
49 // These initializ 50 // These initialized data sets can enhance the computing performance of data interpolation
50 // operations 51 // operations
51 // 52 //
52 // 53 //
53 // ------------------------------------------- 54 // -------------------------------------------------------------------
54 55
55 56
56 #include "G4CrossSectionDataSet.hh" 57 #include "G4CrossSectionDataSet.hh"
57 #include "G4VDataSetAlgorithm.hh" 58 #include "G4VDataSetAlgorithm.hh"
58 #include "G4EMDataSet.hh" 59 #include "G4EMDataSet.hh"
59 #include <vector> 60 #include <vector>
60 #include <fstream> 61 #include <fstream>
61 #include <sstream> 62 #include <sstream>
62 63
63 //....oooOO0OOooo........oooOO0OOooo........oo <<
64 64
65 G4CrossSectionDataSet::G4CrossSectionDataSet(G 65 G4CrossSectionDataSet::G4CrossSectionDataSet(G4VDataSetAlgorithm* argAlgorithm,
66 G4double argUnitEnergies, << 66 G4double argUnitEnergies,
67 G4double argUnitData) : << 67 G4double argUnitData)
>> 68 :
68 algorithm(argAlgorithm), unitEnergies(argUn 69 algorithm(argAlgorithm), unitEnergies(argUnitEnergies), unitData(argUnitData)
69 {;} << 70 {
>> 71 z = 0;
>> 72
>> 73 }
70 74
71 //....oooOO0OOooo........oooOO0OOooo........oo <<
72 75
73 G4CrossSectionDataSet::~G4CrossSectionDataSet( 76 G4CrossSectionDataSet::~G4CrossSectionDataSet()
74 { 77 {
75 CleanUpComponents(); 78 CleanUpComponents();
76 79
77 if (algorithm) 80 if (algorithm)
78 delete algorithm; 81 delete algorithm;
79 } 82 }
80 83
81 //....oooOO0OOooo........oooOO0OOooo........oo <<
82 <<
83 G4bool G4CrossSectionDataSet::LoadData(const G 84 G4bool G4CrossSectionDataSet::LoadData(const G4String & argFileName)
84 { 85 {
85 CleanUpComponents(); 86 CleanUpComponents();
86 87
87 G4String fullFileName(FullFileName(argFileNa 88 G4String fullFileName(FullFileName(argFileName));
88 std::ifstream in(fullFileName, std::ifstream 89 std::ifstream in(fullFileName, std::ifstream::binary|std::ifstream::in);
89 90
90 if (!in.is_open()) 91 if (!in.is_open())
91 { 92 {
92 G4String message("data file \""); 93 G4String message("data file \"");
93 message+=fullFileName; 94 message+=fullFileName;
94 message+="\" not found"; 95 message+="\" not found";
95 G4Exception("G4CrossSectionDataSet::Load 96 G4Exception("G4CrossSectionDataSet::LoadData",
96 "em0003",FatalException,message); 97 "em0003",FatalException,message);
97 return false; 98 return false;
98 } 99 }
99 100
100 std::vector<G4DataVector *> columns; 101 std::vector<G4DataVector *> columns;
101 std::vector<G4DataVector *> log_columns; 102 std::vector<G4DataVector *> log_columns;
102 103
103 std::stringstream *stream(new std::stringstr 104 std::stringstream *stream(new std::stringstream);
104 char c; 105 char c;
105 G4bool comment(false); 106 G4bool comment(false);
106 G4bool space(true); 107 G4bool space(true);
107 G4bool first(true); 108 G4bool first(true);
108 109
109 try 110 try
110 { 111 {
111 while (!in.eof()) 112 while (!in.eof())
112 { 113 {
113 in.get(c); 114 in.get(c);
114 115
115 switch (c) 116 switch (c)
116 { 117 {
117 case '\r': 118 case '\r':
118 case '\n': 119 case '\n':
119 if (!first) 120 if (!first)
120 { 121 {
121 unsigned long i(0); 122 unsigned long i(0);
122 G4double value; 123 G4double value;
123 124
124 while (!stream->eof()) 125 while (!stream->eof())
125 { 126 {
126 (*stream) >> value; 127 (*stream) >> value;
127 128
128 while (i>=columns.size()) 129 while (i>=columns.size())
129 { 130 {
130 columns.push_back(new G4DataVector); 131 columns.push_back(new G4DataVector);
131 log_columns.push_back 132 log_columns.push_back(new G4DataVector);
132 } 133 }
133 134
134 columns[i]->push_back(value); 135 columns[i]->push_back(value);
135 136
136 // N. A. Karakatsanis 137 // N. A. Karakatsanis
137 // A condition is applied to check if negative 138 // A condition is applied to check if negative or zero values are present in the dataset.
138 // If yes, then a near-zero value is applied t 139 // If yes, then a near-zero value is applied to allow the computation of the logarithmic value
139 // If a value is zero, this simplification is 140 // If a value is zero, this simplification is acceptable
140 // If a value is negative, then it is not acce 141 // If a value is negative, then it is not acceptable and the data of the particular column of
141 // logarithmic values should not be used by in 142 // logarithmic values should not be used by interpolation methods.
142 // 143 //
143 // Therefore, G4LogLogInterpolation and G4LinL 144 // Therefore, G4LogLogInterpolation and G4LinLogLogInterpolation should not be used if negative values are present.
144 // Instead, G4LinInterpolation is safe in ever 145 // Instead, G4LinInterpolation is safe in every case
145 // SemiLogInterpolation is safe only if the en 146 // SemiLogInterpolation is safe only if the energy columns are non-negative
146 // G4LinLogInterpolation is safe only if the c 147 // G4LinLogInterpolation is safe only if the cross section data columns are non-negative
147 148
148 if (value <=0.) value = 149 if (value <=0.) value = 1e-300;
149 log_columns[i]->push_bac 150 log_columns[i]->push_back(std::log10(value));
150 151
151 i++; 152 i++;
152 } 153 }
153 154
154 delete stream; 155 delete stream;
155 stream=new std::stringstream; 156 stream=new std::stringstream;
156 } 157 }
157 158
158 first=true; 159 first=true;
159 comment=false; 160 comment=false;
160 space=true; 161 space=true;
161 break; 162 break;
162 163
163 case '#': 164 case '#':
164 comment=true; 165 comment=true;
165 break; 166 break;
166 167
167 case '\t': 168 case '\t':
168 case ' ': 169 case ' ':
169 space = true; 170 space = true;
170 break; 171 break;
171 172
172 default: 173 default:
173 if (comment) { break; } 174 if (comment) { break; }
174 if (space && (!first)) { (*stream) << 175 if (space && (!first)) { (*stream) << ' '; }
175 176
176 first=false; 177 first=false;
177 (*stream) << c; 178 (*stream) << c;
178 space=false; 179 space=false;
179 } 180 }
180 } 181 }
181 } 182 }
182 catch(const std::ios::failure &e) 183 catch(const std::ios::failure &e)
183 { 184 {
184 // some implementations of STL could thr 185 // some implementations of STL could throw a "failture" exception
185 // when read wants read characters after 186 // when read wants read characters after end of file
186 } 187 }
187 188
188 delete stream; 189 delete stream;
189 190
190 G4int maxI = (G4int)columns.size(); << 191 std::vector<G4DataVector *>::size_type maxI(columns.size());
191 192
192 if (maxI<2) 193 if (maxI<2)
193 { 194 {
194 G4String message("data file \""); 195 G4String message("data file \"");
195 message+=fullFileName; 196 message+=fullFileName;
196 message+="\" should have at least two co 197 message+="\" should have at least two columns";
197 G4Exception("G4CrossSectionDataSet::Load 198 G4Exception("G4CrossSectionDataSet::LoadData",
198 "em0005",FatalException,message); 199 "em0005",FatalException,message);
199 return false; 200 return false;
200 } 201 }
201 202
202 G4int i(1); << 203 std::vector<G4DataVector*>::size_type i(1);
203 while (i<maxI) 204 while (i<maxI)
204 { 205 {
205 std::size_t maxJ(columns[i]->size()); << 206 G4DataVector::size_type maxJ(columns[i]->size());
206 207
207 if (maxJ!=columns[0]->size()) 208 if (maxJ!=columns[0]->size())
208 { 209 {
209 G4String message("data file \""); 210 G4String message("data file \"");
210 message+=fullFileName; 211 message+=fullFileName;
211 message+="\" has lines with a different nu 212 message+="\" has lines with a different number of columns";
212 G4Exception("G4CrossSectionDataSet:: 213 G4Exception("G4CrossSectionDataSet::LoadData",
213 "em0005",FatalException,message); 214 "em0005",FatalException,message);
214 return false; 215 return false;
215 } 216 }
216 217
217 std::size_t j(0); << 218 G4DataVector::size_type j(0);
218 219
219 G4DataVector *argEnergies=new G4DataVect 220 G4DataVector *argEnergies=new G4DataVector;
220 G4DataVector *argData=new G4DataVector; 221 G4DataVector *argData=new G4DataVector;
221 G4DataVector *argLogEnergies=new G4DataV 222 G4DataVector *argLogEnergies=new G4DataVector;
222 G4DataVector *argLogData=new G4DataVecto 223 G4DataVector *argLogData=new G4DataVector;
223 224
224 while(j<maxJ) 225 while(j<maxJ)
225 { 226 {
226 argEnergies->push_back(columns[0]->operato 227 argEnergies->push_back(columns[0]->operator[] (j)*GetUnitEnergies());
227 argData->push_back(columns[i]->operator[] 228 argData->push_back(columns[i]->operator[] (j)*GetUnitData());
228 argLogEnergies->push_back(log_columns[0]-> 229 argLogEnergies->push_back(log_columns[0]->operator[] (j) + std::log10(GetUnitEnergies()));
229 argLogData->push_back(log_columns[i]->oper 230 argLogData->push_back(log_columns[i]->operator[] (j) + std::log10(GetUnitData()));
230 j++; 231 j++;
231 } 232 }
232 233
233 AddComponent(new G4EMDataSet(i-1, argEne 234 AddComponent(new G4EMDataSet(i-1, argEnergies, argData, argLogEnergies, argLogData, GetAlgorithm()->Clone(), GetUnitEnergies(), GetUnitData()));
234 235
235 i++; 236 i++;
236 } 237 }
237 238
238 i=maxI; 239 i=maxI;
239 while (i>0) 240 while (i>0)
240 { 241 {
241 i--; 242 i--;
242 delete columns[i]; 243 delete columns[i];
243 delete log_columns[i]; 244 delete log_columns[i];
244 } 245 }
245 246
246 return true; 247 return true;
247 } 248 }
248 249
249 //....oooOO0OOooo........oooOO0OOooo........oo <<
250 250
251 G4bool G4CrossSectionDataSet::LoadNonLogData(c 251 G4bool G4CrossSectionDataSet::LoadNonLogData(const G4String & argFileName)
252 { 252 {
253 CleanUpComponents(); 253 CleanUpComponents();
254 254
255 G4String fullFileName(FullFileName(argFileNa 255 G4String fullFileName(FullFileName(argFileName));
256 std::ifstream in(fullFileName, std::ifstream 256 std::ifstream in(fullFileName, std::ifstream::binary|std::ifstream::in);
257 257
258 if (!in.is_open()) 258 if (!in.is_open())
259 { 259 {
260 G4String message("data file \""); 260 G4String message("data file \"");
261 message+=fullFileName; 261 message+=fullFileName;
262 message+="\" not found"; 262 message+="\" not found";
263 G4Exception("G4CrossSectionDataSet::Load 263 G4Exception("G4CrossSectionDataSet::LoadNonLogData",
264 "em0003",FatalException,message); 264 "em0003",FatalException,message);
265 return false; 265 return false;
266 } 266 }
267 267
268 std::vector<G4DataVector *> columns; 268 std::vector<G4DataVector *> columns;
269 269
270 std::stringstream *stream(new std::stringstr 270 std::stringstream *stream(new std::stringstream);
271 char c; 271 char c;
272 G4bool comment(false); 272 G4bool comment(false);
273 G4bool space(true); 273 G4bool space(true);
274 G4bool first(true); 274 G4bool first(true);
275 275
276 try 276 try
277 { 277 {
278 while (!in.eof()) 278 while (!in.eof())
279 { 279 {
280 in.get(c); 280 in.get(c);
281 281
282 switch (c) 282 switch (c)
283 { 283 {
284 case '\r': 284 case '\r':
285 case '\n': 285 case '\n':
286 if (!first) 286 if (!first)
287 { 287 {
288 unsigned long i(0); 288 unsigned long i(0);
289 G4double value; 289 G4double value;
290 290
291 while (!stream->eof()) 291 while (!stream->eof())
292 { 292 {
293 (*stream) >> value; 293 (*stream) >> value;
294 294
295 while (i>=columns.size()) 295 while (i>=columns.size())
296 { 296 {
297 columns.push_back(new G4DataVector); 297 columns.push_back(new G4DataVector);
298 } 298 }
299 299
300 columns[i]->push_back(value); 300 columns[i]->push_back(value);
301 301
302 i++; 302 i++;
303 } 303 }
304 304
305 delete stream; 305 delete stream;
306 stream=new std::stringstream; 306 stream=new std::stringstream;
307 } 307 }
308 308
309 first=true; 309 first=true;
310 comment=false; 310 comment=false;
311 space=true; 311 space=true;
312 break; 312 break;
313 313
314 case '#': 314 case '#':
315 comment=true; 315 comment=true;
316 break; 316 break;
317 317
318 case '\t': 318 case '\t':
319 case ' ': 319 case ' ':
320 space = true; 320 space = true;
321 break; 321 break;
322 322
323 default: 323 default:
324 if (comment) { break; } 324 if (comment) { break; }
325 if (space && (!first)) { (*stream) << 325 if (space && (!first)) { (*stream) << ' '; }
326 326
327 first=false; 327 first=false;
328 (*stream) << c; 328 (*stream) << c;
329 space=false; 329 space=false;
330 } 330 }
331 } 331 }
332 } 332 }
333 catch(const std::ios::failure &e) 333 catch(const std::ios::failure &e)
334 { 334 {
335 // some implementations of STL could thr 335 // some implementations of STL could throw a "failture" exception
336 // when read wants read characters after 336 // when read wants read characters after end of file
337 } 337 }
338 338
339 delete stream; 339 delete stream;
340 340
341 G4int maxI = (G4int)columns.size(); << 341 std::vector<G4DataVector *>::size_type maxI(columns.size());
342 342
343 if (maxI<2) 343 if (maxI<2)
344 { 344 {
345 G4String message("data file \""); 345 G4String message("data file \"");
346 message+=fullFileName; 346 message+=fullFileName;
347 message+="\" should have at least two co 347 message+="\" should have at least two columns";
348 G4Exception("G4CrossSectionDataSet::Load 348 G4Exception("G4CrossSectionDataSet::LoadNonLogData",
349 "em0005",FatalException,message); 349 "em0005",FatalException,message);
350 return false; 350 return false;
351 } 351 }
352 352
353 G4int i(1); << 353 std::vector<G4DataVector*>::size_type i(1);
354 while (i<maxI) 354 while (i<maxI)
355 { 355 {
356 std::size_t maxJ(columns[i]->size()); << 356 G4DataVector::size_type maxJ(columns[i]->size());
357 357
358 if (maxJ!=columns[0]->size()) 358 if (maxJ!=columns[0]->size())
359 { 359 {
360 G4String message("data file \""); 360 G4String message("data file \"");
361 message+=fullFileName; 361 message+=fullFileName;
362 message+="\" has lines with a different nu 362 message+="\" has lines with a different number of columns";
363 G4Exception("G4CrossSectionDataSet:: 363 G4Exception("G4CrossSectionDataSet::LoadNonLogData",
364 "em0005",FatalException,message); 364 "em0005",FatalException,message);
365 return false; 365 return false;
366 } 366 }
367 367
368 std::size_t j(0); << 368 G4DataVector::size_type j(0);
369 369
370 G4DataVector *argEnergies=new G4DataVect 370 G4DataVector *argEnergies=new G4DataVector;
371 G4DataVector *argData=new G4DataVector; 371 G4DataVector *argData=new G4DataVector;
372 372
373 while(j<maxJ) 373 while(j<maxJ)
374 { 374 {
375 argEnergies->push_back(columns[0]->operato 375 argEnergies->push_back(columns[0]->operator[] (j)*GetUnitEnergies());
376 argData->push_back(columns[i]->operator[] 376 argData->push_back(columns[i]->operator[] (j)*GetUnitData());
377 j++; 377 j++;
378 } 378 }
379 379
380 AddComponent(new G4EMDataSet(i-1, argEne 380 AddComponent(new G4EMDataSet(i-1, argEnergies, argData, GetAlgorithm()->Clone(), GetUnitEnergies(), GetUnitData()));
381 381
382 i++; 382 i++;
383 } 383 }
384 384
385 i=maxI; 385 i=maxI;
386 while (i>0) 386 while (i>0)
387 { 387 {
388 i--; 388 i--;
389 delete columns[i]; 389 delete columns[i];
390 } 390 }
391 391
392 return true; 392 return true;
393 } 393 }
394 394
395 //....oooOO0OOooo........oooOO0OOooo........oo <<
396 395
397 G4bool G4CrossSectionDataSet::SaveData(const G 396 G4bool G4CrossSectionDataSet::SaveData(const G4String & argFileName) const
398 { 397 {
399 const G4int n = (G4int)NumberOfComponents(); << 398 const size_t n(NumberOfComponents());
400 399
401 if (n==0) 400 if (n==0)
402 { 401 {
403 G4Exception("G4CrossSectionDataSet::Save 402 G4Exception("G4CrossSectionDataSet::SaveData",
404 "em0005",FatalException,"expected at l 403 "em0005",FatalException,"expected at least one component");
405 return false; 404 return false;
406 } 405 }
407 406
408 G4String fullFileName(FullFileName(argFileNa 407 G4String fullFileName(FullFileName(argFileName));
409 std::ofstream out(fullFileName); 408 std::ofstream out(fullFileName);
410 409
411 if (!out.is_open()) 410 if (!out.is_open())
412 { 411 {
413 G4String message("cannot open \""); 412 G4String message("cannot open \"");
414 message+=fullFileName; 413 message+=fullFileName;
415 message+="\""; 414 message+="\"";
416 G4Exception("G4CrossSectionDataSet::Save 415 G4Exception("G4CrossSectionDataSet::SaveData",
417 "em0003",FatalException,message); 416 "em0003",FatalException,message);
418 return false; 417 return false;
419 } 418 }
420 419
421 G4DataVector::const_iterator iEnergies(GetCo 420 G4DataVector::const_iterator iEnergies(GetComponent(0)->GetEnergies(0).begin());
422 G4DataVector::const_iterator iEnergiesEnd(Ge 421 G4DataVector::const_iterator iEnergiesEnd(GetComponent(0)->GetEnergies(0).end());
423 G4DataVector::const_iterator * iData(new G4D 422 G4DataVector::const_iterator * iData(new G4DataVector::const_iterator[n]);
424 423
425 G4int k(n); << 424 size_t k(n);
426 425
427 while (k>0) 426 while (k>0)
428 { 427 {
429 k--; 428 k--;
430 iData[k]=GetComponent(k)->GetData(0).cbe << 429 iData[k]=GetComponent(k)->GetData(0).begin();
431 } 430 }
432 431
433 while (iEnergies!=iEnergiesEnd) 432 while (iEnergies!=iEnergiesEnd)
434 { 433 {
435 out.precision(10); 434 out.precision(10);
436 out.width(15); 435 out.width(15);
437 out.setf(std::ofstream::left); 436 out.setf(std::ofstream::left);
438 out << ((*iEnergies)/GetUnitEnergies()); 437 out << ((*iEnergies)/GetUnitEnergies());
439 438
440 k=0; 439 k=0;
441 440
442 while (k<n) 441 while (k<n)
443 { 442 {
444 out << ' '; 443 out << ' ';
445 out.precision(10); 444 out.precision(10);
446 out.width(15); 445 out.width(15);
447 out.setf(std::ofstream::left); 446 out.setf(std::ofstream::left);
448 out << ((*(iData[k]))/GetUnitData()); 447 out << ((*(iData[k]))/GetUnitData());
449 448
450 iData[k]++; 449 iData[k]++;
451 k++; 450 k++;
452 } 451 }
453 452
454 out << std::endl; 453 out << std::endl;
455 454
456 iEnergies++; 455 iEnergies++;
457 } 456 }
458 457
459 delete[] iData; 458 delete[] iData;
460 459
461 return true; 460 return true;
462 } 461 }
463 462
464 //....oooOO0OOooo........oooOO0OOooo........oo <<
465 463
466 G4String G4CrossSectionDataSet::FullFileName(c 464 G4String G4CrossSectionDataSet::FullFileName(const G4String& argFileName) const
467 { 465 {
468 const char* path = G4FindDataDir("G4LEDATA") << 466 char* path = getenv("G4LEDATA");
469 if (!path) 467 if (!path)
470 { 468 {
471 G4Exception("G4CrossSectionDataSet::Full 469 G4Exception("G4CrossSectionDataSet::FullFileName",
472 "em0006",FatalException,"G4LEDATA envir 470 "em0006",FatalException,"G4LEDATA environment variable not set");
473 return "NULL"; 471 return "NULL";
474 } 472 }
475 473
476 std::ostringstream fullFileName; 474 std::ostringstream fullFileName;
477 475
478 fullFileName << path << "/" << argFileName < 476 fullFileName << path << "/" << argFileName << ".dat";
479 477
480 return G4String(fullFileName.str().c_str()); 478 return G4String(fullFileName.str().c_str());
481 } 479 }
482 480
483 //....oooOO0OOooo........oooOO0OOooo........oo <<
484 481
485 G4double G4CrossSectionDataSet::FindValue(G4do 482 G4double G4CrossSectionDataSet::FindValue(G4double argEnergy, G4int /* argComponentId */) const
486 { 483 {
487 // Returns the sum over the shells correspon 484 // Returns the sum over the shells corresponding to e
488 G4double value = 0.; 485 G4double value = 0.;
489 486
490 std::vector<G4VEMDataSet *>::const_iterator 487 std::vector<G4VEMDataSet *>::const_iterator i(components.begin());
491 std::vector<G4VEMDataSet *>::const_iterator 488 std::vector<G4VEMDataSet *>::const_iterator end(components.end());
492 489
493 while (i!=end) 490 while (i!=end)
494 { 491 {
495 value+=(*i)->FindValue(argEnergy); 492 value+=(*i)->FindValue(argEnergy);
496 i++; 493 i++;
497 } 494 }
498 495
499 return value; 496 return value;
500 } 497 }
501 498
502 //....oooOO0OOooo........oooOO0OOooo........oo <<
503 499
504 void G4CrossSectionDataSet::PrintData(void) co 500 void G4CrossSectionDataSet::PrintData(void) const
505 { 501 {
506 const G4int n = (G4int)NumberOfComponents(); << 502 const size_t n(NumberOfComponents());
507 503
508 G4cout << "The data set has " << n << " comp 504 G4cout << "The data set has " << n << " components" << G4endl;
509 G4cout << G4endl; 505 G4cout << G4endl;
510 506
511 G4int i(0); << 507 size_t i(0);
512 508
513 while (i<n) 509 while (i<n)
514 { 510 {
515 G4cout << "--- Component " << i << " --- 511 G4cout << "--- Component " << i << " ---" << G4endl;
516 GetComponent(i)->PrintData(); 512 GetComponent(i)->PrintData();
517 ++i; << 513 i++;
518 } 514 }
519 } 515 }
520 516
521 //....oooOO0OOooo........oooOO0OOooo........oo <<
522 517
523 void G4CrossSectionDataSet::SetEnergiesData(G4 518 void G4CrossSectionDataSet::SetEnergiesData(G4DataVector* argEnergies,
524 G4DataVector* argData, 519 G4DataVector* argData,
525 G4int argComponentId) 520 G4int argComponentId)
526 { 521 {
527 G4VEMDataSet * component(components[argCompo 522 G4VEMDataSet * component(components[argComponentId]);
528 523
529 if (component) 524 if (component)
530 { 525 {
531 component->SetEnergiesData(argEnergies, 526 component->SetEnergiesData(argEnergies, argData, 0);
532 return; 527 return;
533 } 528 }
534 529
535 std::ostringstream message; 530 std::ostringstream message;
536 message << "component " << argComponentId << 531 message << "component " << argComponentId << " not found";
537 532
538 G4Exception("G4CrossSectionDataSet::SetEnerg 533 G4Exception("G4CrossSectionDataSet::SetEnergiesData",
539 "em0005",FatalException,message.str().c 534 "em0005",FatalException,message.str().c_str());
540 } 535 }
541 536
542 //....oooOO0OOooo........oooOO0OOooo........oo <<
543 537
544 void G4CrossSectionDataSet::SetLogEnergiesData 538 void G4CrossSectionDataSet::SetLogEnergiesData(G4DataVector* argEnergies,
545 G4DataVector* argData, 539 G4DataVector* argData,
546 G4Dat 540 G4DataVector* argLogEnergies,
547 G4Dat 541 G4DataVector* argLogData,
548 G4int argComponentId) 542 G4int argComponentId)
549 { 543 {
550 G4VEMDataSet * component(components[argCompo 544 G4VEMDataSet * component(components[argComponentId]);
551 545
552 if (component) 546 if (component)
553 { 547 {
554 component->SetLogEnergiesData(argEnergie 548 component->SetLogEnergiesData(argEnergies, argData, argLogEnergies, argLogData, 0);
555 return; 549 return;
556 } 550 }
557 551
558 std::ostringstream message; 552 std::ostringstream message;
559 message << "component " << argComponentId << 553 message << "component " << argComponentId << " not found";
560 554
561 G4Exception("G4CrossSectionDataSet::SetLogEn 555 G4Exception("G4CrossSectionDataSet::SetLogEnergiesData",
562 "em0005",FatalException,message.str().c 556 "em0005",FatalException,message.str().c_str());
563 } 557 }
564 558
565 //....oooOO0OOooo........oooOO0OOooo........oo <<
566 559
567 void G4CrossSectionDataSet::CleanUpComponents( 560 void G4CrossSectionDataSet::CleanUpComponents()
568 { 561 {
569 while (!components.empty()) 562 while (!components.empty())
570 { 563 {
571 if (components.back()) delete components 564 if (components.back()) delete components.back();
572 components.pop_back(); 565 components.pop_back();
573 } 566 }
574 } 567 }
575 568
576 569
577 570