| 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 // $Id: G4RDeIonisationParameters.cc,v 1.23 2006/06/29 19:42:02 gunter Exp $
>> 28 // GEANT4 tag $Name: geant4-09-01-ref-00 $
27 // 29 //
28 // Author: Maria Grazia Pia (Maria.Grazia.Pia@ 30 // Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
29 // 31 //
30 // History: 32 // History:
31 // ----------- 33 // -----------
32 // 31 Jul 2001 MGP Created, with dumm 34 // 31 Jul 2001 MGP Created, with dummy implementation
33 // 12.09.01 V.Ivanchenko Add param and inte 35 // 12.09.01 V.Ivanchenko Add param and interpolation of parameters
34 // 04.10.01 V.Ivanchenko Add BindingEnergy 36 // 04.10.01 V.Ivanchenko Add BindingEnergy method
35 // 25.10.01 MGP Many bug fixes, mo 37 // 25.10.01 MGP Many bug fixes, mostly related to the
36 // management of poin 38 // management of pointers
37 // 29.11.01 V.Ivanchenko New parametrisatio 39 // 29.11.01 V.Ivanchenko New parametrisation + Excitation
38 // 30.05.02 V.Ivanchenko Format and names o 40 // 30.05.02 V.Ivanchenko Format and names of the data files were
39 // chenged to "ion-.. 41 // chenged to "ion-..."
40 // 17.02.04 V.Ivanchenko Increase buffer si 42 // 17.02.04 V.Ivanchenko Increase buffer size
41 // 43 //
42 // ------------------------------------------- 44 // -------------------------------------------------------------------
43 45
44 #include <fstream> <<
45 #include <sstream> <<
46 <<
47 #include "G4RDeIonisationParameters.hh" 46 #include "G4RDeIonisationParameters.hh"
48 #include "G4RDVEMDataSet.hh" 47 #include "G4RDVEMDataSet.hh"
49 #include "G4RDShellEMDataSet.hh" 48 #include "G4RDShellEMDataSet.hh"
50 #include "G4RDEMDataSet.hh" 49 #include "G4RDEMDataSet.hh"
51 #include "G4RDCompositeEMDataSet.hh" 50 #include "G4RDCompositeEMDataSet.hh"
52 #include "G4RDLinInterpolation.hh" 51 #include "G4RDLinInterpolation.hh"
53 #include "G4RDLogLogInterpolation.hh" 52 #include "G4RDLogLogInterpolation.hh"
54 #include "G4RDLinLogLogInterpolation.hh" 53 #include "G4RDLinLogLogInterpolation.hh"
55 #include "G4RDSemiLogInterpolation.hh" 54 #include "G4RDSemiLogInterpolation.hh"
56 #include "G4SystemOfUnits.hh" <<
57 #include "G4Material.hh" 55 #include "G4Material.hh"
58 #include "G4DataVector.hh" 56 #include "G4DataVector.hh"
>> 57 #include <fstream>
>> 58 #include <sstream>
>> 59
59 60
60 G4RDeIonisationParameters:: G4RDeIonisationPar 61 G4RDeIonisationParameters:: G4RDeIonisationParameters(G4int minZ, G4int maxZ)
61 : zMin(minZ), zMax(maxZ), 62 : zMin(minZ), zMax(maxZ),
62 length(24) 63 length(24)
63 { 64 {
64 LoadData(); 65 LoadData();
65 } 66 }
66 67
67 68
68 G4RDeIonisationParameters::~G4RDeIonisationPar 69 G4RDeIonisationParameters::~G4RDeIonisationParameters()
69 { 70 {
70 // Reset the map of data sets: remove the da 71 // Reset the map of data sets: remove the data sets from the map
71 std::map<G4int,G4RDVEMDataSet*,std::less<G4i 72 std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::iterator pos;
72 73
73 for (pos = param.begin(); pos != param.end() 74 for (pos = param.begin(); pos != param.end(); ++pos)
74 { 75 {
75 G4RDVEMDataSet* dataSet = (*pos).second; 76 G4RDVEMDataSet* dataSet = (*pos).second;
76 delete dataSet; 77 delete dataSet;
77 } 78 }
78 79
79 for (pos = excit.begin(); pos != excit.end() 80 for (pos = excit.begin(); pos != excit.end(); ++pos)
80 { 81 {
81 G4RDVEMDataSet* dataSet = (*pos).second; 82 G4RDVEMDataSet* dataSet = (*pos).second;
82 delete dataSet; 83 delete dataSet;
83 } 84 }
84 85
85 activeZ.clear(); 86 activeZ.clear();
86 } 87 }
87 88
88 89
89 G4double G4RDeIonisationParameters::Parameter( 90 G4double G4RDeIonisationParameters::Parameter(G4int Z, G4int shellIndex,
90 91 G4int parameterIndex,
91 92 G4double e) const
92 { 93 {
93 G4double value = 0.; 94 G4double value = 0.;
94 G4int id = Z*100 + parameterIndex; 95 G4int id = Z*100 + parameterIndex;
95 std::map<G4int,G4RDVEMDataSet*,std::less<G4i 96 std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::const_iterator pos;
96 97
97 pos = param.find(id); 98 pos = param.find(id);
98 if (pos!= param.end()) { 99 if (pos!= param.end()) {
99 G4RDVEMDataSet* dataSet = (*pos).second; 100 G4RDVEMDataSet* dataSet = (*pos).second;
100 G4int nShells = dataSet->NumberOfComponent 101 G4int nShells = dataSet->NumberOfComponents();
101 102
102 if(shellIndex < nShells) { 103 if(shellIndex < nShells) {
103 const G4RDVEMDataSet* component = dataSe 104 const G4RDVEMDataSet* component = dataSet->GetComponent(shellIndex);
104 const G4DataVector ener = component->Get 105 const G4DataVector ener = component->GetEnergies(0);
105 G4double ee = std::max(ener.front(),std: 106 G4double ee = std::max(ener.front(),std::min(ener.back(),e));
106 value = component->FindValue(ee); 107 value = component->FindValue(ee);
107 } else { 108 } else {
108 G4cout << "WARNING: G4IonisationParamete 109 G4cout << "WARNING: G4IonisationParameters::FindParameter "
109 << "has no parameters for shell= 110 << "has no parameters for shell= " << shellIndex
110 << "; Z= " << Z 111 << "; Z= " << Z
111 << G4endl; 112 << G4endl;
112 } 113 }
113 } else { 114 } else {
114 G4cout << "WARNING: G4IonisationParameters 115 G4cout << "WARNING: G4IonisationParameters::Parameter "
115 << "did not find ID = " 116 << "did not find ID = "
116 << shellIndex << G4endl; 117 << shellIndex << G4endl;
117 } 118 }
118 119
119 return value; 120 return value;
120 } 121 }
121 122
122 G4double G4RDeIonisationParameters::Excitation 123 G4double G4RDeIonisationParameters::Excitation(G4int Z, G4double e) const
123 { 124 {
124 G4double value = 0.; 125 G4double value = 0.;
125 std::map<G4int,G4RDVEMDataSet*,std::less<G4i 126 std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::const_iterator pos;
126 127
127 pos = excit.find(Z); 128 pos = excit.find(Z);
128 if (pos!= excit.end()) { 129 if (pos!= excit.end()) {
129 G4RDVEMDataSet* dataSet = (*pos).second; 130 G4RDVEMDataSet* dataSet = (*pos).second;
130 131
131 const G4DataVector ener = dataSet->GetEner 132 const G4DataVector ener = dataSet->GetEnergies(0);
132 G4double ee = std::max(ener.front(),std::m 133 G4double ee = std::max(ener.front(),std::min(ener.back(),e));
133 value = dataSet->FindValue(ee); 134 value = dataSet->FindValue(ee);
134 } else { 135 } else {
135 G4cout << "WARNING: G4IonisationParameters 136 G4cout << "WARNING: G4IonisationParameters::Excitation "
136 << "did not find ID = " 137 << "did not find ID = "
137 << Z << G4endl; 138 << Z << G4endl;
138 } 139 }
139 140
140 return value; 141 return value;
141 } 142 }
142 143
143 144
144 void G4RDeIonisationParameters::LoadData() 145 void G4RDeIonisationParameters::LoadData()
145 { 146 {
146 // --------------------------------------- 147 // ---------------------------------------
147 // Please document what are the parameters 148 // Please document what are the parameters
148 // --------------------------------------- 149 // ---------------------------------------
149 150
150 // define active elements 151 // define active elements
151 152
152 const G4MaterialTable* materialTable = G4Mat 153 const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
153 if (materialTable == 0) 154 if (materialTable == 0)
154 G4Exception("G4RDeIonisationParameters::L 155 G4Exception("G4RDeIonisationParameters::LoadData()", "InvalidSetup",
155 FatalException, "No MaterialT 156 FatalException, "No MaterialTable found!");
156 157
157 G4int nMaterials = G4Material::GetNumberOfMa 158 G4int nMaterials = G4Material::GetNumberOfMaterials();
158 159
159 for (G4int m=0; m<nMaterials; m++) { 160 for (G4int m=0; m<nMaterials; m++) {
160 161
161 const G4Material* material= (*materialTabl 162 const G4Material* material= (*materialTable)[m];
162 const G4ElementVector* elementVector = mat 163 const G4ElementVector* elementVector = material->GetElementVector();
163 const size_t nElements = material->GetNumb 164 const size_t nElements = material->GetNumberOfElements();
164 165
165 for (size_t iEl=0; iEl<nElements; iEl++) { 166 for (size_t iEl=0; iEl<nElements; iEl++) {
166 G4Element* element = (*elementVector)[iE 167 G4Element* element = (*elementVector)[iEl];
167 G4double Z = element->GetZ(); 168 G4double Z = element->GetZ();
168 if (!(activeZ.contains(Z))) { 169 if (!(activeZ.contains(Z))) {
169 activeZ.push_back(Z); 170 activeZ.push_back(Z);
170 } 171 }
171 } 172 }
172 } 173 }
173 174
174 const char* path = G4FindDataDir("G4LEDATA") << 175 char* path = getenv("G4LEDATA");
175 if (!path) 176 if (!path)
176 { 177 {
177 G4String excep("G4LEDATA environment var 178 G4String excep("G4LEDATA environment variable not set!");
178 G4Exception("G4RDeIonisationParameters:: 179 G4Exception("G4RDeIonisationParameters::LoadData()", "InvalidSetup",
179 FatalException, excep); 180 FatalException, excep);
180 } 181 }
181 182
182 G4String pathString(path); 183 G4String pathString(path);
183 G4String path2("/ioni/ion-sp-"); 184 G4String path2("/ioni/ion-sp-");
184 pathString += path2; 185 pathString += path2;
185 186
186 G4double energy, sum; 187 G4double energy, sum;
187 188
188 size_t nZ = activeZ.size(); 189 size_t nZ = activeZ.size();
189 190
190 for (size_t i=0; i<nZ; i++) { 191 for (size_t i=0; i<nZ; i++) {
191 192
192 G4int Z = (G4int)activeZ[i]; 193 G4int Z = (G4int)activeZ[i];
193 std::ostringstream ost; 194 std::ostringstream ost;
194 ost << pathString << Z << ".dat"; 195 ost << pathString << Z << ".dat";
195 G4String name(ost.str()); 196 G4String name(ost.str());
196 197
197 std::ifstream file(name); 198 std::ifstream file(name);
198 std::filebuf* lsdp = file.rdbuf(); 199 std::filebuf* lsdp = file.rdbuf();
199 200
200 if (! (lsdp->is_open()) ) { 201 if (! (lsdp->is_open()) ) {
201 G4String excep = G4String("Data file: ") 202 G4String excep = G4String("Data file: ")
202 + name + G4String(" not found. The versi 203 + name + G4String(" not found. The version 1.# of G4LEDATA should be used");
203 G4Exception("G4RDeIonisationParameters:: 204 G4Exception("G4RDeIonisationParameters::LoadData()", "DataNotFound",
204 FatalException, excep); 205 FatalException, excep);
205 } 206 }
206 207
207 // The file is organized into: 208 // The file is organized into:
208 // For each shell there are two lines: 209 // For each shell there are two lines:
209 // 1st line: 210 // 1st line:
210 // 1st column is the energy of incident e- 211 // 1st column is the energy of incident e-,
211 // 2d column is the parameter of screan t 212 // 2d column is the parameter of screan term;
212 // 2d line: 213 // 2d line:
213 // 3 energy (MeV) subdividing different ap 214 // 3 energy (MeV) subdividing different approximation area of the spectrum
214 // 20 point on the spectrum 215 // 20 point on the spectrum
215 // The shell terminates with the pattern: 216 // The shell terminates with the pattern: -1 -1
216 // The file terminates with the pattern: - 217 // The file terminates with the pattern: -2 -2
217 218
218 std::vector<G4RDVEMDataSet*> p; 219 std::vector<G4RDVEMDataSet*> p;
219 for (size_t k=0; k<length; k++) 220 for (size_t k=0; k<length; k++)
220 { 221 {
221 G4RDVDataSetAlgorithm* inter = new G4RDLinLo 222 G4RDVDataSetAlgorithm* inter = new G4RDLinLogLogInterpolation();
222 G4RDVEMDataSet* composite = new G4RDComposit 223 G4RDVEMDataSet* composite = new G4RDCompositeEMDataSet(inter,1.,1.);
223 p.push_back(composite); 224 p.push_back(composite);
224 } 225 }
225 226
226 G4int shell = 0; 227 G4int shell = 0;
227 std::vector<G4DataVector*> a; 228 std::vector<G4DataVector*> a;
228 for (size_t j=0; j<length; j++) 229 for (size_t j=0; j<length; j++)
229 { 230 {
230 G4DataVector* aa = new G4DataVector(); 231 G4DataVector* aa = new G4DataVector();
231 a.push_back(aa); 232 a.push_back(aa);
232 } 233 }
233 G4DataVector e; 234 G4DataVector e;
234 e.clear(); 235 e.clear();
235 do { 236 do {
236 file >> energy >> sum; 237 file >> energy >> sum;
237 if (energy == -2) break; 238 if (energy == -2) break;
238 239
239 if (energy > -1) { 240 if (energy > -1) {
240 e.push_back(energy); 241 e.push_back(energy);
241 a[0]->push_back(sum); 242 a[0]->push_back(sum);
242 for (size_t j=0; j<length-1; j++) { 243 for (size_t j=0; j<length-1; j++) {
243 G4double qRead; 244 G4double qRead;
244 file >> qRead; 245 file >> qRead;
245 a[j + 1]->push_back(qRead); 246 a[j + 1]->push_back(qRead);
246 } 247 }
247 248
248 } else { 249 } else {
249 250
250 // End of set for a shell, fill the ma 251 // End of set for a shell, fill the map
251 for (size_t k=0; k<length; k++) { 252 for (size_t k=0; k<length; k++) {
252 253
253 G4RDVDataSetAlgorithm* interp; 254 G4RDVDataSetAlgorithm* interp;
254 if(0 == k) interp = new G4RDLinLogL 255 if(0 == k) interp = new G4RDLinLogLogInterpolation();
255 else interp = new G4RDLogLogI 256 else interp = new G4RDLogLogInterpolation();
256 257
257 G4DataVector* eVector = new G4DataVector; 258 G4DataVector* eVector = new G4DataVector;
258 size_t eSize = e.size(); 259 size_t eSize = e.size();
259 for (size_t s=0; s<eSize; s++) { 260 for (size_t s=0; s<eSize; s++) {
260 eVector->push_back(e[s]); 261 eVector->push_back(e[s]);
261 } 262 }
262 G4RDVEMDataSet* set = new G4RDEMDataSet(sh 263 G4RDVEMDataSet* set = new G4RDEMDataSet(shell,eVector,a[k],interp,1.,1.);
263 264
264 p[k]->AddComponent(set); 265 p[k]->AddComponent(set);
265 } 266 }
266 267
267 // clear vectors 268 // clear vectors
268 for (size_t j2=0; j2<length; j2++) { 269 for (size_t j2=0; j2<length; j2++) {
269 a[j2] = new G4DataVector(); 270 a[j2] = new G4DataVector();
270 } 271 }
271 shell++; 272 shell++;
272 e.clear(); 273 e.clear();
273 } 274 }
274 } while (energy > -2); 275 } while (energy > -2);
275 276
276 file.close(); 277 file.close();
277 278
278 for (size_t kk=0; kk<length; kk++) 279 for (size_t kk=0; kk<length; kk++)
279 { 280 {
280 G4int id = Z*100 + kk; 281 G4int id = Z*100 + kk;
281 param[id] = p[kk]; 282 param[id] = p[kk];
282 } 283 }
283 } 284 }
284 285
285 G4String pathString_a(path); 286 G4String pathString_a(path);
286 G4String name_a = pathString_a + G4String("/ 287 G4String name_a = pathString_a + G4String("/ioni/ion-ex-av.dat");
287 std::ifstream file_a(name_a); 288 std::ifstream file_a(name_a);
288 std::filebuf* lsdp_a = file_a.rdbuf(); 289 std::filebuf* lsdp_a = file_a.rdbuf();
289 G4String pathString_b(path); 290 G4String pathString_b(path);
290 G4String name_b = pathString_b + G4String("/ 291 G4String name_b = pathString_b + G4String("/ioni/ion-ex-sig.dat");
291 std::ifstream file_b(name_b); 292 std::ifstream file_b(name_b);
292 std::filebuf* lsdp_b = file_b.rdbuf(); 293 std::filebuf* lsdp_b = file_b.rdbuf();
293 294
294 if (! (lsdp_a->is_open()) ) { 295 if (! (lsdp_a->is_open()) ) {
295 G4String excep = G4String("Cannot open fi 296 G4String excep = G4String("Cannot open file ")
296 + name_a; 297 + name_a;
297 G4Exception("G4RDeIonisationParameters::L 298 G4Exception("G4RDeIonisationParameters::LoadData()", "CannotOpenFile",
298 FatalException, excep); 299 FatalException, excep);
299 } 300 }
300 if (! (lsdp_b->is_open()) ) { 301 if (! (lsdp_b->is_open()) ) {
301 G4String excep = G4String("Cannot open fi 302 G4String excep = G4String("Cannot open file ")
302 + name_b; 303 + name_b;
303 G4Exception("G4RDeIonisationParameters::L 304 G4Exception("G4RDeIonisationParameters::LoadData()", "CannotOpenFile",
304 FatalException, excep); 305 FatalException, excep);
305 } 306 }
306 307
307 // The file is organized into two columns: 308 // The file is organized into two columns:
308 // 1st column is the energy 309 // 1st column is the energy
309 // 2nd column is the corresponding value 310 // 2nd column is the corresponding value
310 // The file terminates with the pattern: -1 311 // The file terminates with the pattern: -1 -1
311 // -2 312 // -2 -2
312 313
313 G4double ener, ener1, sig, sig1; 314 G4double ener, ener1, sig, sig1;
314 G4int z = 0; 315 G4int z = 0;
315 316
316 G4DataVector e; 317 G4DataVector e;
317 e.clear(); 318 e.clear();
318 G4DataVector d; 319 G4DataVector d;
319 d.clear(); 320 d.clear();
320 321
321 do { 322 do {
322 file_a >> ener >> sig; 323 file_a >> ener >> sig;
323 file_b >> ener1 >> sig1; 324 file_b >> ener1 >> sig1;
324 325
325 if(ener != ener1) { 326 if(ener != ener1) {
326 G4cout << "G4RDeIonisationParameters: pr 327 G4cout << "G4RDeIonisationParameters: problem in excitation data "
327 << "ener= " << ener 328 << "ener= " << ener
328 << " ener1= " << ener1 329 << " ener1= " << ener1
329 << G4endl; 330 << G4endl;
330 } 331 }
331 332
332 // End of file 333 // End of file
333 if (ener == -2) { 334 if (ener == -2) {
334 break; 335 break;
335 336
336 // End of next element 337 // End of next element
337 } else if (ener == -1) { 338 } else if (ener == -1) {
338 339
339 z++; 340 z++;
340 G4double Z = (G4double)z; 341 G4double Z = (G4double)z;
341 342
342 // fill map if Z is used 343 // fill map if Z is used
343 if (activeZ.contains(Z)) { 344 if (activeZ.contains(Z)) {
344 345
345 G4RDVDataSetAlgorithm* inter = new G4RDLinI 346 G4RDVDataSetAlgorithm* inter = new G4RDLinInterpolation();
346 G4DataVector* eVector = new G4DataVector; 347 G4DataVector* eVector = new G4DataVector;
347 G4DataVector* dVector = new G4DataVector; 348 G4DataVector* dVector = new G4DataVector;
348 size_t eSize = e.size(); 349 size_t eSize = e.size();
349 for (size_t s=0; s<eSize; s++) { 350 for (size_t s=0; s<eSize; s++) {
350 eVector->push_back(e[s]); 351 eVector->push_back(e[s]);
351 dVector->push_back(d[s]); 352 dVector->push_back(d[s]);
352 } 353 }
353 G4RDVEMDataSet* set = new G4RDEMDataSet(z,eV 354 G4RDVEMDataSet* set = new G4RDEMDataSet(z,eVector,dVector,inter,1.,1.);
354 excit[z] = set; 355 excit[z] = set;
355 } 356 }
356 e.clear(); 357 e.clear();
357 d.clear(); 358 d.clear();
358 359
359 } else { 360 } else {
360 361
361 e.push_back(ener*MeV); 362 e.push_back(ener*MeV);
362 d.push_back(sig1*sig*barn*MeV); 363 d.push_back(sig1*sig*barn*MeV);
363 } 364 }
364 } while (ener != -2); 365 } while (ener != -2);
365 366
366 file_a.close(); 367 file_a.close();
367 368
368 } 369 }
369 370
370 371
371 void G4RDeIonisationParameters::PrintData() co 372 void G4RDeIonisationParameters::PrintData() const
372 { 373 {
373 G4cout << G4endl; 374 G4cout << G4endl;
374 G4cout << "===== G4RDeIonisationParameters = 375 G4cout << "===== G4RDeIonisationParameters =====" << G4endl;
375 G4cout << G4endl; 376 G4cout << G4endl;
376 377
377 size_t nZ = activeZ.size(); 378 size_t nZ = activeZ.size();
378 std::map<G4int,G4RDVEMDataSet*,std::less<G4i 379 std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::const_iterator pos;
379 380
380 for (size_t i=0; i<nZ; i++) { 381 for (size_t i=0; i<nZ; i++) {
381 G4int Z = (G4int)activeZ[i]; 382 G4int Z = (G4int)activeZ[i];
382 383
383 for (size_t j=0; j<length; j++) { 384 for (size_t j=0; j<length; j++) {
384 385
385 G4int index = Z*100 + j; 386 G4int index = Z*100 + j;
386 387
387 pos = param.find(index); 388 pos = param.find(index);
388 if (pos!= param.end()) { 389 if (pos!= param.end()) {
389 G4RDVEMDataSet* dataSet = (*pos).secon 390 G4RDVEMDataSet* dataSet = (*pos).second;
390 size_t nShells = dataSet->NumberOfComp 391 size_t nShells = dataSet->NumberOfComponents();
391 392
392 for (size_t k=0; k<nShells; k++) { 393 for (size_t k=0; k<nShells; k++) {
393 394
394 G4cout << "===== Z= " << Z << " shel 395 G4cout << "===== Z= " << Z << " shell= " << k
395 << " parameter[" << j << "] 396 << " parameter[" << j << "] ====="
396 << G4endl; 397 << G4endl;
397 const G4RDVEMDataSet* comp = dataSet 398 const G4RDVEMDataSet* comp = dataSet->GetComponent(k);
398 comp->PrintData(); 399 comp->PrintData();
399 } 400 }
400 } 401 }
401 } 402 }
402 } 403 }
403 G4cout << "================================= 404 G4cout << "====================================" << G4endl;
404 } 405 }
405 406
406 407
407 408