def snop_opacity(element, dens, tele, nu, full_output=False):
"""
Parameters:
-----------
- element [str]: chemical element
- dens [ndarray]: array of densities [g.cm⁻³]
- dens [ndarray]: array of electron temperatures [eV]
- nu [ndarray]: array of energies [eV]
must be between [10 eV, 30 keV]
Returns:
--------
opacity in cm⁻¹
"""
db = matdb(element)
s_args = dict(db.snop)
s_args['arho'] = dens
s_args['atele'] = np.fmax(tele, 1e-3) # just to be safe
s_args['dsm'] = db.solid_dens
for key, val in {'lte': False, 'lsff': True,
'lsbf': True, 'lsbb':True}.iteritems():
s_args[key] = [val]*len(s_args['z'])
s_args['fg'] = np.array([np.min(nu)*1e-3, np.max(nu)*1e-3])
s_args['nu'] = nu
s_args['nout'] = 1
d = run_snop(**s_args)
if full_output:
return d
else:
op = d['op_total'].copy()
del d
return op
def xray_filter_transmission(nu, element=None, thickness=None, layers=None):
"""
Computes filter transmission for solid foils
Parameters:
-----------
- nu [ndarray] photon frequency array [eV]
- element: [str] filter element, should be in matdb
- thickness: [float] foil thickness [cm]
- layers: [dict] dict of layers
{'element1': thickness1, 'element2': thickness2, ...}
"""
wrong_args = np.array(
[arg is None for arg in [element, thickness, layers]])
if wrong_args.all() or (~wrong_args).all():
raise ValueError(
'You should provide either element and thickness or layers dict!')
if layers is None:
op = cold_opacity(element,
hedp.matdb(element).solid_dens, nu, 'pickle')
return np.exp(-op * thickness)
else:
Transmissions = [xray_filter_transmission(nu, el, thick)\
for el, thick in layers.iteritems()]
return np.prod(np.array(Transmissions), axis=0)
def cold_opacity(element, dens=0.1, nu=None, hdf5_backend='pytables'):
"""
Parameters:
-----------
- element [str]: chemical element
- dens [float or ndarray]: array of densities [g.cm⁻³]
- nu [ndarray]: array of energies [eV]
must be between [10 eV, 30 keV]
- hdf5_backend [str]: pytables or h5py [use because of
a bug between pytables and yt]
Returns:
--------
opacity in cm⁻¹
"""
#hdf5_backend = 'h5py'
if hdf5_backend == 'h5py':
import h5py
with h5py.File(HENKE_DATA_PATH+'.h5', 'r') as f:
if not '/'+element in f:
print("Warning: couldn't find cold opacity for {0} ; trying to download...".format(element))
f.close()
download_full(element)
f = h5py.File(HENKE_DATA_PATH+'.h5', 'r')
nu0 = f[element]['nu'][:]
op0 = f[element]['op'][:]
f.close()
elif hdf5_backend == 'pytables':
import tables
with tables.open_file(HENKE_DATA_PATH+'.h5', 'a') as f:
if not '/'+element in f:
print("Warning: couldn't find cold opacity for {0} ; trying to download...".format(element))
f.close()
download_full(element)
f = tables.openFile(HENKE_DATA_PATH+'.h5', 'r')
nu0 = getattr(f.root, element).nu[:]
op0 = getattr(f.root, element).op[:]
f.close()
sync_pickle_db()
elif hdf5_backend == 'pickle':
import pickle
with open(HENKE_DATA_PATH+'.pickle', 'rb') as handle:
mdict = pickle.load(handle)
nu0, op0 = mdict[element]
else:
raise ValueError
#print hdf5_backend
if nu is not None:
op = interp1d(nu0, op0)(nu)
else:
op = op0
if isinstance(dens, numbers.Number):
if dens < 0:
dens = hedp.matdb(element).solid_dens
return op*dens
elif dens.ndim <= 1:
return op*dens.reshape(-1,1)
elif dens.ndim == 2:
return dens[:,:,np.newaxis]*op[np.newaxis, np.newaxis, :]
def download_full(element, dens=None):
"""
Download files to database for given element
"""
import tables
db = hedp.matdb(element)
op_tot = []
nu_tot = []
for nu in [(10,100),(100, 1000), (1000, 9000), (9000, 30000)]:
if dens is None:
if db.solid_dens:
if db.solid_dens>0.1:
solid_dens = db.solid_dens
else:
solid_dens = 1e4*db.solid_dens # this is a gas
else:
solid_dens = 0.1
else:
solid_dens=dens
nu_arr, op_arr = download(db.formula, solid_dens, nu=nu)
nu_tot.append(nu_arr)
op_tot.append(op_arr)
op = np.concatenate(op_tot)
nu = np.concatenate(nu_tot)
_, mask = np.unique(nu, return_index=True)
data = {'op': op[mask], 'nu': nu[mask]}
with tables.openFile(HENKE_DATA_PATH+'.h5', 'a') as f:
atom = tables.Atom.from_dtype(data['op'].dtype)
group = f.createGroup(f.root, element)
for name, arr in data.iteritems():
ds = f.createCArray(group, name, atom, arr.shape)
ds[:] = arr
def Kalpha_profile(el, nu, sigma=100):
"""
Computes the Kalpha line profile
Parameters:
-----------
- nu [ndarray] photon frequency array [eV]
- element: [str] filter element, should be in matdb
- sigma: [float] gaussian with in eV
Returns:
--------
- profile: [ndarray] Kα line profile as a normalized gaussian
"""
nu0 = hedp.matdb(el).spect[u'Kα1'] #Heα1'] #Kα1']
return 1./(sigma*(2*np.pi)**0.5)* np.exp(-(nu-nu0)**2/(2*sigma**2))
def Kalpha_profile(el, nu, sigma=100):
"""
Computes the Kalpha line profile
Parameters:
-----------
- nu [ndarray] photon frequency array [eV]
- element: [str] filter element, should be in matdb
- sigma: [float] gaussian with in eV
Returns:
--------
- profile: [ndarray] Kα line profile as a normalized gaussian
"""
nu0 = hedp.matdb(el).spect[u'Kα1'] #Heα1'] #Kα1']
return 1. / (sigma * (2 * np.pi)**0.5) * np.exp(-(nu - nu0)**2 /
(2 * sigma**2))
def xray_filter_transmission(nu, element=None, thickness=None,layers=None):
"""
Computes filter transmission for solid foils
Parameters:
-----------
- nu [ndarray] photon frequency array [eV]
- element: [str] filter element, should be in matdb
- thickness: [float] foil thickness [cm]
- layers: [dict] dict of layers
{'element1': thickness1, 'element2': thickness2, ...}
"""
wrong_args = np.array([arg is None for arg in [element, thickness, layers]])
if wrong_args.all() or (~wrong_args).all():
raise ValueError('You should provide either element and thickness or layers dict!')
if layers is None:
op = cold_opacity(element,
hedp.matdb(element).solid_dens,
nu, 'pickle')
return np.exp(-op*thickness)
else:
Transmissions = [xray_filter_transmission(nu, el, thick)\
for el, thick in layers.iteritems()]
return np.prod(np.array(Transmissions), axis=0)
def snop_opacity(element, dens, tele, nu, full_output=False):
"""
Parameters:
-----------
- element [str]: chemical element
- dens [ndarray]: array of densities [g.cm⁻³]
- dens [ndarray]: array of electron temperatures [eV]
- nu [ndarray]: array of energies [eV]
must be between [10 eV, 30 keV]
Returns:
--------
opacity in cm⁻¹
"""
db = matdb(element)
s_args = dict(db.snop)
s_args['arho'] = dens
s_args['atele'] = np.fmax(tele, 1e-3) # just to be safe
s_args['dsm'] = db.solid_dens
for key, val in {
'lte': False,
'lsff': True,
'lsbf': True,
'lsbb': True
}.iteritems():
s_args[key] = [val] * len(s_args['z'])
s_args['fg'] = np.array([np.min(nu) * 1e-3, np.max(nu) * 1e-3])
s_args['nu'] = nu
s_args['nout'] = 1
d = run_snop(**s_args)
if full_output:
return d
else:
op = d['op_total'].copy()
del d
return op
import opacplot2 as opp
from opacplot2.smooth import psedo_maxwell_loops, eint_offset, CheckEosConsistency,\
insure_monotonicity, interp_isochores_1d
import numpy as np
import hedp
import pysnop
from hedp.eos import thomas_fermi_ionization
table_id = 7592
#table_id = 3720
#table_id = 2140
#mat = 'polystyrene'
mat = 'Fe'
filename = '{0}-ses-{1:4d}-v2-1.cn4'.format(mat.lower(), int(table_id))
mat_dict = hedp.matdb(mat)
SESAME_DIR = '../../sesame/'
print 'Loading SESAME db...'
eos_sesame = opp.OpgSesame(os.path.join(SESAME_DIR, "xsesame_ascii"), opp.OpgSesame.SINGLE, verbose=False)
eos_i = eos_sesame.data[table_id]
eos_w = copy.deepcopy(eos_i)
eos_w['ioncc_pres'] = psedo_maxwell_loops(eos_i['ioncc_dens'], eos_i['ioncc_temps'], eos_i['ioncc_pres'])
print 'ioncc_pres',
eos_w['ioncc_pres'] = insure_monotonicity(eos_w['ioncc_dens'], eos_w['ioncc_temps'], eos_w['ioncc_pres'], axis='dens')
print 'ele_pres',
eos_w['ele_pres'] = insure_monotonicity(eos_i['ele_dens'], eos_i['ele_temps'], eos_i['ele_pres'], axis='dens')
import sys
import os.path
import copy
import opacplot2 as opp
from opacplot2.smooth import CheckEosConsistency
import numpy as np
import hedp
from hedp.eos import thomas_fermi_ionization
table_id = 2962
mat = 'Ti'
rho0 = 4.42
filename = '{0}-ses-{1:4d}-v2.cn4'.format(mat.lower(), int(table_id))
mat_dict = hedp.matdb(mat)
SESAME_DIR = '/mnt/EoS_tables/sesame/'
print 'Loading SESAME db...'
eos_sesame = opp.OpgSesame(os.path.join(SESAME_DIR, "xsesame_ascii"), opp.OpgSesame.SINGLE, verbose=False)
eos_i = eos_sesame.data[table_id]
eos_w = copy.deepcopy(eos_i)
# merge Ion and Ele grids
eos_o = opp.adapt.EosMergeGrids(eos_w,
filter_dens=lambda x: (x>0),
filter_temps=lambda x: (x>0.5), # remove everything bellow 0.62 eV to avoid negative values
