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