Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4MaterialPropertiesTable.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27//
28//
29////////////////////////////////////////////////////////////////////////
30// G4MaterialPropertiesTable Implementation
31////////////////////////////////////////////////////////////////////////
32//
33// File: G4MaterialPropertiesTable.cc
34// Version: 1.0
35// Created: 1996-02-08
36// Author: Juliet Armstrong
37// Updated: 2005-05-12 add SetGROUPVEL(), courtesy of
38// Horton-Smith (bug report #741), by P. Gumplinger
39// 2002-11-05 add named material constants by P. Gumplinger
40// 1999-11-05 Migration from G4RWTPtrHashDictionary to STL
41// by John Allison
42// 1997-03-26 by Peter Gumplinger
43// > cosmetics (only)
44//
45////////////////////////////////////////////////////////////////////////
46
47#include "globals.hh"
48#include "G4MaterialPropertiesTable.hh"
49#include "G4PhysicalConstants.hh"
50#include "G4Log.hh"
51
52#include <algorithm>
53
54/////////////////
55// Constructors
56/////////////////
57
58G4MaterialPropertiesTable::G4MaterialPropertiesTable()
59{
60 // elements of these 2 vectors must be in same order as
61 // the corresponding enums in G4MaterialPropertiesIndex.hh
62 G4MaterialPropertyName.push_back(G4String("RINDEX"));
63 G4MaterialPropertyName.push_back(G4String("REFLECTIVITY"));
64 G4MaterialPropertyName.push_back(G4String("REALRINDEX"));
65 G4MaterialPropertyName.push_back(G4String("IMAGINARYRINDEX"));
66 G4MaterialPropertyName.push_back(G4String("EFFICIENCY"));
67 G4MaterialPropertyName.push_back(G4String("TRANSMITTANCE"));
68 G4MaterialPropertyName.push_back(G4String("SPECULARLOBECONSTANT"));
69 G4MaterialPropertyName.push_back(G4String("SPECULARSPIKECONSTANT"));
70 G4MaterialPropertyName.push_back(G4String("BACKSCATTERCONSTANT"));
71 G4MaterialPropertyName.push_back(G4String("GROUPVEL"));
72 G4MaterialPropertyName.push_back(G4String("MIEHG"));
73 G4MaterialPropertyName.push_back(G4String("RAYLEIGH"));
74 G4MaterialPropertyName.push_back(G4String("WLSCOMPONENT"));
75 G4MaterialPropertyName.push_back(G4String("WLSABSLENGTH"));
76 G4MaterialPropertyName.push_back(G4String("WLSCOMPONENT2"));
77 G4MaterialPropertyName.push_back(G4String("WLSABSLENGTH2"));
78 G4MaterialPropertyName.push_back(G4String("ABSLENGTH"));
79 G4MaterialPropertyName.push_back(G4String("FASTCOMPONENT"));
80 G4MaterialPropertyName.push_back(G4String("SLOWCOMPONENT"));
81 G4MaterialPropertyName.push_back(G4String("PROTONSCINTILLATIONYIELD"));
82 G4MaterialPropertyName.push_back(G4String("DEUTERONSCINTILLATIONYIELD"));
83 G4MaterialPropertyName.push_back(G4String("TRITONSCINTILLATIONYIELD"));
84 G4MaterialPropertyName.push_back(G4String("ALPHASCINTILLATIONYIELD"));
85 G4MaterialPropertyName.push_back(G4String("IONSCINTILLATIONYIELD"));
86 G4MaterialPropertyName.push_back(G4String("ELECTRONSCINTILLATIONYIELD"));
87 G4MaterialPropertyName.push_back(G4String("SCINTILLATIONCOMPONENT1"));
88 G4MaterialPropertyName.push_back(G4String("SCINTILLATIONCOMPONENT2"));
89 G4MaterialPropertyName.push_back(G4String("SCINTILLATIONCOMPONENT3"));
90
91 G4MaterialConstPropertyName.push_back(G4String("SURFACEROUGHNESS"));
92 G4MaterialConstPropertyName.push_back(G4String("ISOTHERMAL_COMPRESSIBILITY"));
93 G4MaterialConstPropertyName.push_back(G4String("RS_SCALE_FACTOR"));
94 G4MaterialConstPropertyName.push_back(G4String("WLSMEANNUMBERPHOTONS"));
95 G4MaterialConstPropertyName.push_back(G4String("WLSTIMECONSTANT"));
96 G4MaterialConstPropertyName.push_back(G4String("WLSMEANNUMBERPHOTONS2"));
97 G4MaterialConstPropertyName.push_back(G4String("WLSTIMECONSTANT2"));
98 G4MaterialConstPropertyName.push_back(G4String("MIEHG_FORWARD"));
99 G4MaterialConstPropertyName.push_back(G4String("MIEHG_BACKWARD"));
100 G4MaterialConstPropertyName.push_back(G4String("MIEHG_FORWARD_RATIO"));
101 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONYIELD"));
102 G4MaterialConstPropertyName.push_back(G4String("RESOLUTIONSCALE"));
103 G4MaterialConstPropertyName.push_back(G4String("FASTTIMECONSTANT"));
104 G4MaterialConstPropertyName.push_back(G4String("FASTSCINTILLATIONRISETIME"));
105 G4MaterialConstPropertyName.push_back(G4String("SLOWTIMECONSTANT"));
106 G4MaterialConstPropertyName.push_back(G4String("SLOWSCINTILLATIONRISETIME"));
107 G4MaterialConstPropertyName.push_back(G4String("YIELDRATIO"));
108 G4MaterialConstPropertyName.push_back(G4String("FERMIPOT"));
109 G4MaterialConstPropertyName.push_back(G4String("DIFFUSION"));
110 G4MaterialConstPropertyName.push_back(G4String("SPINFLIP"));
111 G4MaterialConstPropertyName.push_back(G4String("LOSS"));
112 G4MaterialConstPropertyName.push_back(G4String("LOSSCS"));
113 G4MaterialConstPropertyName.push_back(G4String("ABSCS"));
114 G4MaterialConstPropertyName.push_back(G4String("SCATCS"));
115 G4MaterialConstPropertyName.push_back(G4String("MR_NBTHETA"));
116 G4MaterialConstPropertyName.push_back(G4String("MR_NBE"));
117 G4MaterialConstPropertyName.push_back(G4String("MR_RRMS"));
118 G4MaterialConstPropertyName.push_back(G4String("MR_CORRLEN"));
119 G4MaterialConstPropertyName.push_back(G4String("MR_THETAMIN"));
120 G4MaterialConstPropertyName.push_back(G4String("MR_THETAMAX"));
121 G4MaterialConstPropertyName.push_back(G4String("MR_EMIN"));
122 G4MaterialConstPropertyName.push_back(G4String("MR_EMAX"));
123 G4MaterialConstPropertyName.push_back(G4String("MR_ANGNOTHETA"));
124 G4MaterialConstPropertyName.push_back(G4String("MR_ANGNOPHI"));
125 G4MaterialConstPropertyName.push_back(G4String("MR_ANGCUT"));
126 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONTIMECONSTANT1"));
127 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONTIMECONSTANT2"));
128 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONTIMECONSTANT3"));
129 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONRISETIME1"));
130 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONRISETIME2"));
131 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONRISETIME3"));
132 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONYIELD1"));
133 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONYIELD2"));
134 G4MaterialConstPropertyName.push_back(G4String("SCINTILLATIONYIELD3"));
135 G4MaterialConstPropertyName.push_back(G4String("PROTONSCINTILLATIONYIELD1"));
136 G4MaterialConstPropertyName.push_back(G4String("PROTONSCINTILLATIONYIELD2"));
137 G4MaterialConstPropertyName.push_back(G4String("PROTONSCINTILLATIONYIELD3"));
138 G4MaterialConstPropertyName.push_back(G4String("DEUTERONSCINTILLATIONYIELD1"));
139 G4MaterialConstPropertyName.push_back(G4String("DEUTERONSCINTILLATIONYIELD2"));
140 G4MaterialConstPropertyName.push_back(G4String("DEUTERONSCINTILLATIONYIELD3"));
141 G4MaterialConstPropertyName.push_back(G4String("TRITONSCINTILLATIONYIELD1"));
142 G4MaterialConstPropertyName.push_back(G4String("TRITONSCINTILLATIONYIELD2"));
143 G4MaterialConstPropertyName.push_back(G4String("TRITONSCINTILLATIONYIELD3"));
144 G4MaterialConstPropertyName.push_back(G4String("ALPHASCINTILLATIONYIELD1"));
145 G4MaterialConstPropertyName.push_back(G4String("ALPHASCINTILLATIONYIELD2"));
146 G4MaterialConstPropertyName.push_back(G4String("ALPHASCINTILLATIONYIELD3"));
147 G4MaterialConstPropertyName.push_back(G4String("IONSCINTILLATIONYIELD1"));
148 G4MaterialConstPropertyName.push_back(G4String("IONSCINTILLATIONYIELD2"));
149 G4MaterialConstPropertyName.push_back(G4String("IONSCINTILLATIONYIELD3"));
150 G4MaterialConstPropertyName.push_back(G4String("ELECTRONSCINTILLATIONYIELD1"));
151 G4MaterialConstPropertyName.push_back(G4String("ELECTRONSCINTILLATIONYIELD2"));
152 G4MaterialConstPropertyName.push_back(G4String("ELECTRONSCINTILLATIONYIELD3"));
153}
154
155////////////////
156// Destructor
157////////////////
158
159G4MaterialPropertiesTable::~G4MaterialPropertiesTable()
160{
161 MPTiterator i;
162 for (i = MPT.begin(); i != MPT.end(); ++i)
163 {
164 delete (*i).second;
165 }
166 MPT.clear();
167 MPTC.clear();
168
169 MPiterator it;
170 for (it = MP.begin(); it != MP.end(); ++it)
171 {
172 delete (*it).second;
173 }
174 MP.clear();
175 MCP.clear();
176
177 G4MaterialPropertyName.clear();
178 G4MaterialConstPropertyName.clear();
179}
180
181////////////
182// Methods
183////////////
184
185G4int G4MaterialPropertiesTable::GetConstPropertyIndex(const G4String& key,
186 G4bool warning) const
187{
188 // Returns the constant material property index corresponding to a key
189
190 size_t index = std::distance(G4MaterialConstPropertyName.begin(),
191 std::find(G4MaterialConstPropertyName.begin(),
192 G4MaterialConstPropertyName.end(), key));
193 if(index < G4MaterialConstPropertyName.size()) return index;
194 if (warning) {
195 G4ExceptionDescription ed;
196 ed << "Constant Material Property Index for key " << key << " not found.";
197 G4Exception("G4MaterialPropertiesTable::GetConstPropertyIndex()","mat206",
198 JustWarning, ed);
199 }
200 return -1;
201}
202
203G4int G4MaterialPropertiesTable::GetPropertyIndex(const G4String& key,
204 G4bool warning) const
205{
206 // Returns the material property index corresponding to a key
207 size_t index = std::distance(G4MaterialPropertyName.begin(),
208 std::find(G4MaterialPropertyName.begin(),
209 G4MaterialPropertyName.end(), key));
210 if(index < G4MaterialPropertyName.size()) return index;
211 if (warning) {
212 G4ExceptionDescription ed;
213 ed << "Material Property Index for key " << key << " not found.";
214 G4Exception("G4MaterialPropertiesTable::GetPropertyIndex()","mat207",
215 JustWarning, ed);
216 }
217 return -1;
218}
219
220G4double G4MaterialPropertiesTable::GetConstProperty(const G4int index) const
221{
222 // Returns the constant material property corresponding to an index
223 // fatal exception if property not found
224
225 MCPiterator j;
226 j = MCP.find(index);
227 if ( j != MCP.end() ) return j->second;
228 G4ExceptionDescription ed;
229 ed << "Constant Material Property Index " << index << " not found.";
230 G4Exception("G4MaterialPropertiesTable::GetConstProperty()","mat202",
231 FatalException, ed);
232 return 0.;
233}
234
235G4double G4MaterialPropertiesTable::GetConstProperty(const G4String& key) const
236{
237 // Returns the constant material property corresponding to a key
238 // fatal exception if property not found
239
240 return GetConstProperty(GetConstPropertyIndex(key));
241}
242
243G4double G4MaterialPropertiesTable::GetConstProperty(const char *key) const
244{
245 return GetConstProperty(G4String(key));
246}
247
248G4bool G4MaterialPropertiesTable::ConstPropertyExists(const G4int index) const
249{
250 // Returns true if a const property corresponding to 'index' exists
251
252 MCPiterator j;
253 j = MCP.find(index);
254 if ( j != MCP.end() ) return true;
255 return false;
256}
257
258G4bool G4MaterialPropertiesTable::ConstPropertyExists(const G4String& key) const
259{
260 // Returns true if a const property 'key' exists
261 return ConstPropertyExists(GetConstPropertyIndex(key));
262}
263
264G4bool G4MaterialPropertiesTable::ConstPropertyExists(const char *key) const
265{
266 return ConstPropertyExists(G4String(key));
267}
268
269G4MaterialPropertyVector*
270G4MaterialPropertiesTable::GetProperty(const G4String& key, G4bool warning)
271{
272 // Returns a Material Property Vector corresponding to a key
273 const G4int index = GetPropertyIndex(key, warning);
274 return GetProperty(index);
275}
276
277G4MaterialPropertyVector*
278G4MaterialPropertiesTable::GetProperty(const char *key, G4bool warning)
279{
280 return GetProperty(G4String(key), warning);
281}
282
283G4MaterialPropertyVector*
284G4MaterialPropertiesTable::GetProperty(const G4int index, G4bool warning)
285{
286 // Returns a Material Property Vector corresponding to an index
287 MPiterator i;
288 i = MP.find(index);
289 if ( i != MP.end() ) return i->second;
290 if (warning) {
291 G4ExceptionDescription ed;
292 ed << "Material Property for index " << index << " not found.";
293 G4Exception("G4MaterialPropertiesTable::GetPropertyIndex()","mat208",
294 JustWarning, ed);
295 }
296 return nullptr;
297}
298
299G4MaterialPropertyVector* G4MaterialPropertiesTable::AddProperty(
300 const G4String& key,
301 const std::vector<G4double>& photonEnergies,
302 const std::vector<G4double>& propertyValues)
303{
304 if (photonEnergies.size() != propertyValues.size()) {
305 G4ExceptionDescription ed;
306 ed << "AddProperty error!";
307 G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat210",
308 FatalException, ed);
309 }
310
311 // if the key doesn't exist, add it
312 if (std::find(G4MaterialPropertyName.begin(),
313 G4MaterialPropertyName.end(), key) ==
314 G4MaterialPropertyName.end()) {
315 G4MaterialPropertyName.push_back(key);
316 }
317
318 G4MaterialPropertyVector *mpv = new G4MaterialPropertyVector(photonEnergies,
319 propertyValues);
320 G4int index = GetPropertyIndex(key);
321 MP[index] = mpv;
322
323 // if key is RINDEX, we calculate GROUPVEL -
324 // contribution from Tao Lin (IHEP, the JUNO experiment)
325 if (key=="RINDEX") {
326 CalculateGROUPVEL();
327 }
328
329 return mpv;
330}
331
332G4MaterialPropertyVector* G4MaterialPropertiesTable::AddProperty(
333 const char *key,
334 G4double *PhotonEnergies,
335 G4double *PropertyValues,
336 G4int NumEntries)
337{
338 // Provides a way of adding a property to the Material Properties
339 // Table given a pair of numbers and a key
340 G4String k(key);
341 std::vector<G4double> energies;
342 std::vector<G4double> values;
343 for (G4int i=0; i<NumEntries; ++i) {
344 energies.push_back(PhotonEnergies[i]);
345 values.push_back(PropertyValues[i]);
346 }
347 return AddProperty(k, energies, values);
348}
349
350void G4MaterialPropertiesTable::AddProperty(const G4String& key, G4MaterialPropertyVector* mpv)
351{
352 // Provides a way of adding a property to the Material Properties
353 // Table given an G4MaterialPropertyVector Reference and a key
354 // if the key doesn't exist, add it
355 if (std::find(G4MaterialPropertyName.begin(),
356 G4MaterialPropertyName.end(), key) ==
357 G4MaterialPropertyName.end()) {
358 G4MaterialPropertyName.push_back(key);
359 }
360 G4int index = GetPropertyIndex(key);
361 MP[ index ] = mpv;
362
363 // if key is RINDEX, we calculate GROUPVEL -
364 // contribution from Tao Lin (IHEP, the JUNO experiment)
365 if (key=="RINDEX") {
366 CalculateGROUPVEL();
367 }
368}
369
370void G4MaterialPropertiesTable::
371AddProperty(const char *key, G4MaterialPropertyVector *mpv)
372{
373 AddProperty(G4String(key), mpv);
374}
375
376void G4MaterialPropertiesTable::AddEntry(const G4String& key,
377 G4double aPhotonEnergy,
378 G4double aPropertyValue)
379{
380 // Allows to add an entry pair directly to the Material Property Vector
381 // given a key
382 if (std::find(G4MaterialPropertyName.begin(),
383 G4MaterialPropertyName.end(), key) ==
384 G4MaterialPropertyName.end()) {
385 G4MaterialPropertyName.push_back(key);
386 }
387 G4int index = GetPropertyIndex(key);
388
389 G4MaterialPropertyVector *targetVector=MP[index];
390 if (targetVector != nullptr)
391 {
392 targetVector->InsertValues(aPhotonEnergy, aPropertyValue);
393 }
394 else
395 {
396 G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat203",
397 FatalException, "Material Property Vector not found.");
398 }
399}
400
401void G4MaterialPropertiesTable::AddEntry(const char *key,
402 G4double aPhotonEnergy,
403 G4double aPropertyValue)
404{
405 AddEntry(G4String(key), aPhotonEnergy, aPropertyValue);
406}
407
408void G4MaterialPropertiesTable::DumpTable()
409{
410 // material properties
411 MPiterator i;
412 for (i = MP.begin(); i != MP.end(); ++i)
413 {
414 G4cout << (*i).first << ": "<< G4MaterialPropertyName[(*i).first] <<G4endl;
415 if ( (*i).second != 0 )
416 {
417 (*i).second->DumpValues();
418 }
419 else
420 {
421 G4Exception("G4MaterialPropertiesTable::DumpTable()", "mat204",
422 JustWarning, "NULL Material Property Vector Pointer.");
423 }
424 }
425 // material constant properties
426 MCPiterator j;
427 for (j = MCP.begin(); j != MCP.end(); ++j)
428 {
429 G4cout << j->first <<": "<< G4MaterialConstPropertyName[j->first] <<G4endl;
430 if ( j->second != 0 )
431 {
432 G4cout << j->second << G4endl;
433 }
434 else
435 {
436 G4Exception("G4MaterialPropertiesTable::DumpTable()", "mat202",
437 JustWarning, "No Material Constant Property.");
438 }
439 }
440}
441
442#ifdef G4MULTITHREADED
443#include "G4AutoLock.hh"
444namespace {
445 G4Mutex materialPropertyTableMutex = G4MUTEX_INITIALIZER;
446}
447#endif
448
449G4MaterialPropertyVector* G4MaterialPropertiesTable::CalculateGROUPVEL()
450{
451#ifdef G4MULTITHREADED
452 G4AutoLock mptm(&materialPropertyTableMutex);
453#endif
454 // reconsider (i.e, remove) above mutex as this method is likely called only
455 // when RINDEX is added during the detector construction phase (i.e., adding
456 // meterials properties into geometry) on the master thread (Oct. 2017, SYJ)
457
458 // check if "GROUPVEL" already exists
459 MPiterator itr;
460 itr = MP.find(kGROUPVEL);
461 if(itr != MP.end()) return itr->second;
462
463 // fetch RINDEX data, give up if unavailable
464 //
465 G4MaterialPropertyVector *rindex = this->GetProperty(kRINDEX);
466 if (rindex==0) { return 0; }
467
468 // RINDEX exists but has no entries, give up
469 //
470 if ( rindex->GetVectorLength() == 0 ) { return 0; }
471
472 // add GROUPVEL vector
473 //
474 G4MaterialPropertyVector* groupvel = new G4MaterialPropertyVector();
475
476 // fill GROUPVEL vector using RINDEX values
477 // rindex built-in "iterator" was advanced to first entry above
478 //
479 G4double E0 = rindex->Energy(0);
480 G4double n0 = (*rindex)[0];
481
482 if (E0 <= 0.)
483 {
484 G4Exception("G4MaterialPropertiesTable::CalculateGROUPVEL()", "mat205",
485 FatalException, "Optical Photon Energy <= 0");
486 }
487
488 if ( rindex->GetVectorLength() >= 2 )
489 {
490 // good, we have at least two entries in RINDEX
491 // get next energy/value pair
492
493 G4double E1 = rindex->Energy(1);
494 G4double n1 = (*rindex)[1];
495
496 if (E1 <= 0.)
497 {
498 G4Exception("G4MaterialPropertiesTable::CalculateGROUPVEL()", "mat205",
499 FatalException, "Optical Photon Energy <= 0");
500 }
501
502 G4double vg;
503
504 // add entry at first photon energy
505 //
506 vg = c_light/(n0+(n1-n0)/G4Log(E1/E0));
507
508 // allow only for 'normal dispersion' -> dn/d(logE) > 0
509 //
510 if((vg<0) || (vg>c_light/n0)) { vg = c_light/n0; }
511
512 groupvel->InsertValues( E0, vg );
513
514 // add entries at midpoints between remaining photon energies
515 //
516
517 for (size_t i = 2; i < rindex->GetVectorLength(); i++)
518 {
519 vg = c_light/( 0.5*(n0+n1)+(n1-n0)/G4Log(E1/E0));
520
521 // allow only for 'normal dispersion' -> dn/d(logE) > 0
522 //
523 if((vg<0) || (vg>c_light/(0.5*(n0+n1)))) { vg = c_light/(0.5*(n0+n1)); }
524 groupvel->InsertValues( 0.5*(E0+E1), vg );
525
526 // get next energy/value pair, or exit loop
527 //
528 E0 = E1;
529 n0 = n1;
530 E1 = rindex->Energy(i);
531 n1 = (*rindex)[i];
532
533 if (E1 <= 0.)
534 {
535 G4Exception("G4MaterialPropertiesTable::CalculateGROUPVEL()", "mat205",
536 FatalException, "Optical Photon Energy <= 0");
537 }
538 }
539
540 // add entry at last photon energy
541 //
542 vg = c_light/(n1+(n1-n0)/G4Log(E1/E0));
543
544 // allow only for 'normal dispersion' -> dn/d(logE) > 0
545 //
546 if((vg<0) || (vg>c_light/n1)) { vg = c_light/n1; }
547 groupvel->InsertValues( E1, vg );
548 }
549 else // only one entry in RINDEX -- weird!
550 {
551 groupvel->InsertValues( E0, c_light/n0 );
552 }
553
554 this->AddProperty( "GROUPVEL", groupvel );
555
556 return groupvel;
557}
558
559G4MaterialPropertyVector* G4MaterialPropertiesTable::SetGROUPVEL()
560{
561 G4String message("SetGROUPVEL will be obsolete from the next release ");
562 message += "Use G4MaterialPropertiesTable::CalculateGROUPVEL() instead";
563
564 G4Exception("G4MaterialPropertiesTable::SetGROUPVEL()", "Obsolete",
565 JustWarning, message);
566 return CalculateGROUPVEL();
567}
568
569std::map< G4String, G4MaterialPropertyVector*, std::less<G4String> >*
570G4MaterialPropertiesTable::GetPropertiesMap()
571{
572 // warning message
573 G4String message("GetPropertiesMap will be obsolete from the next release ");
574 message += "Use G4MaterialPropertiesTable::GetPropertyMap() instead";
575 G4Exception("G4MaterialPropertiesTable::GetPropertiesMap()", "Obsolete",
576 JustWarning, message);
577
578 for (MPiterator miter = MP.begin(); miter != MP.end(); miter++)
579 {
580 if(miter->second) {
581 MPT [ G4MaterialPropertyName[miter->first] ] = miter->second;
582 }
583 else {
584 G4Exception("G4MaterialPropertiesTable::GetPropertiesMap()","NullPointer",
585 JustWarning, "Null Pointer for Material Property");
586 continue;
587 }
588 }
589 return &MPT;
590}
591
592std::map< G4String, G4double, std::less<G4String> >* G4MaterialPropertiesTable::GetPropertiesCMap()
593{
594 // warning message
595 G4String message("GetPropertiesCMap will be obsolete from the next release ");
596 message += "Use G4MaterialPropertiesTable::GetConstPropertyMap() instead";
597 G4Exception("G4MaterialPropertiesTable::GetPropertiesCMap()", "Obsolete",
598 JustWarning, message);
599
600 for (MCPiterator miter = MCP.begin(); miter != MCP.end(); miter++) {
601 MPTC[ G4MaterialConstPropertyName[miter->first] ] = miter->second;
602 }
603 return &MPTC;
604}
605
606std::vector<G4String> G4MaterialPropertiesTable::GetMaterialPropertyNames() const
607{
608 return G4MaterialPropertyName;;
609}
610
611std::vector<G4String> G4MaterialPropertiesTable::GetMaterialConstPropertyNames() const
612{
613 return G4MaterialConstPropertyName;
614}
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:65
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
G4Log
G4double G4Log(G4double x)
Definition: G4Log.hh:226
G4MaterialPropertyVector
G4PhysicsOrderedFreeVector G4MaterialPropertyVector
Definition: G4MaterialPropertyVector.hh:60
G4MUTEX_INITIALIZER
#define G4MUTEX_INITIALIZER
Definition: G4Threading.hh:85
G4Mutex
std::mutex G4Mutex
Definition: G4Threading.hh:81
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4MaterialPropertiesTable::GetMaterialPropertyNames
std::vector< G4String > GetMaterialPropertyNames() const
Definition: G4MaterialPropertiesTable.cc:606
G4MaterialPropertiesTable::GetProperty
G4MaterialPropertyVector * GetProperty(const char *key, G4bool warning=false)
Definition: G4MaterialPropertiesTable.cc:278
G4MaterialPropertiesTable::GetMaterialConstPropertyNames
std::vector< G4String > GetMaterialConstPropertyNames() const
Definition: G4MaterialPropertiesTable.cc:611
G4MaterialPropertiesTable::GetPropertiesCMap
std::map< G4String, G4double, std::less< G4String > > * GetPropertiesCMap()
Definition: G4MaterialPropertiesTable.cc:592
G4MaterialPropertiesTable::GetPropertyIndex
G4int GetPropertyIndex(const G4String &key, G4bool warning=false) const
Definition: G4MaterialPropertiesTable.cc:203
G4MaterialPropertiesTable::GetConstPropertyIndex
G4int GetConstPropertyIndex(const G4String &key, G4bool warning=false) const
Definition: G4MaterialPropertiesTable.cc:185
G4MaterialPropertiesTable::AddProperty
G4MaterialPropertyVector * AddProperty(const G4String &key, const std::vector< G4double > &photonEnergies, const std::vector< G4double > &propertyValues)
Definition: G4MaterialPropertiesTable.cc:299
G4MaterialPropertiesTable::ConstPropertyExists
G4bool ConstPropertyExists(const G4String &key) const
Definition: G4MaterialPropertiesTable.cc:258
G4MaterialPropertiesTable::GetPropertiesMap
std::map< G4String, G4MaterialPropertyVector *, std::less< G4String > > * GetPropertiesMap()
Definition: G4MaterialPropertiesTable.cc:570
G4MaterialPropertiesTable::GetConstProperty
G4double GetConstProperty(const G4String &key) const
Definition: G4MaterialPropertiesTable.cc:235
G4MaterialPropertiesTable::AddEntry
void AddEntry(const G4String &key, G4double aPhotonEnergy, G4double aPropertyValue)
Definition: G4MaterialPropertiesTable.cc:376
G4PhysicsOrderedFreeVector::InsertValues
void InsertValues(G4double energy, G4double value)
Definition: G4PhysicsOrderedFreeVector.cc:88
G4PhysicsVector::Energy
G4double Energy(std::size_t index) const
G4PhysicsVector::GetVectorLength
std::size_t GetVectorLength() const