def silicate_xs( nproc=4 ):
egrid_sil = np.copy(_egrid_lores)
for edge in [_ANGSTROMS_OK, _ANGSTROMS_FeL, _ANGSTROMS_MgSi]:
egrid_sil = _insert_edge_grid(egrid_sil, _hc/edge[::-1])
print(egrid_sil)
sil_params = [_amin_s, _amax_s, _p_s, _rho_s, _mdust, 'Silicate']
print("Making Silicate cross section with\n\tamin=%.3f\n\tamax=%.3f\n\tp=%.2f\n\trho=%.2f" \
% (_amin_s, _amax_s, _p_s, _rho_s) )
print("Output will be sent to %s" % (_outdir+_silfile))
"""
def _tau_sca(E):
result = ss.Kappascat(E=E, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate'))
return result.kappa[0] * _mdust
def _tau_ext(E):
result = ss.Kappaext(E=E, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate'))
return result.kappa[0] * _mdust
pool = multiprocessing.Pool(processes=nproc)
sca_sil = pool.map(_tau_sca, egrid_sil)
ext_sil = pool.map(_tau_ext, egrid_sil)
pool.close()"""
Ksca_sil = ss.Kappascat(E=egrid_sil, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate'))
Kext_sil = ss.Kappaext(E=egrid_sil, dist=_dustspec(sil_params), scatm=ss.makeScatmodel('Mie','Silicate'))
sca_sil = Ksca_sil.kappa * _mdust
ext_sil = Kext_sil.kappa * _mdust
_write_all_xs_fits(_outdir+_silfile, egrid_sil, ext_sil, sca_sil, sil_params)
return
def graphite_xs( nproc=4 ):
egrid_gra = np.copy(_egrid_lores)
egrid_gra = _insert_edge_grid(egrid_gra, _hc/_ANGSTROMS_OK[::-1])
gra_params = [_amin_g, _amax_g, _p_g, _rho_g, _mdust, 'Graphite']
print("Making Graphite cross section with\n\tamin=%.3f\n\tamax=%.3f\n\tp=%.2f\n\trho=%.2f" \
% (_amin_g, _amax_g, _p_g, _rho_g))
print("Output will be sent to %s" % (_outdir+_grafile))
"""
def _tau_sca(E):
result = ss.Kappascat(E=E, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite'))
return result.kappa[0] * _mdust
def _tau_ext(E):
result = ss.Kappascat(E=E, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite'))
return result.kappa[0]] * _mdust
pool = multiprocessing.Pool(processes=nproc)
sca_gra = pool.map(_tau_sca, egrid_gra)
ext_sil = pool.map(_tau_ext, egrid_gra)
pool.close()"""
Ksca_gra = ss.Kappascat(E=egrid_gra, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite'))
Kext_gra = ss.Kappaext(E=egrid_gra, dist=_dustspec(gra_params), scatm=ss.makeScatmodel('Mie','Graphite'))
sca_gra = Ksca_gra.kappa * _mdust
ext_gra = Kext_gra.kappa * _mdust
# smooth the xs behavior for energies > esmooth
def _smooth_xs(esmooth, xs, pslope):
ipow = np.where(egrid_gra >= esmooth)[0] # closest value to the desired esmooth value
result = np.copy(xs)
result[ipow] = xs[ipow[0]] * np.power(egrid_gra[ipow]/egrid_gra[ipow[0]], pslope)
return result
if _smooth_graphite_xs:
ESMOOTH, PSCA, PABS = 1.0, -2.0, -2.9 # determined by hand
print("Smoothing Graphite cross section with\n\tp=%.2f (scattering)\n\tp=%.2f (absorption)" % (PSCA,PABS))
new_sca_gra = _smooth_xs(ESMOOTH, sca_gra, PSCA)
new_abs_gra = _smooth_xs(ESMOOTH, ext_gra-sca_gra, PABS)
new_ext_gra = new_sca_gra + new_abs_gra
_write_all_xs_fits(_outdir+_grafile, egrid_gra, new_ext_gra, new_sca_gra, gra_params)
else:
_write_all_xs_fits(_outdir+_grafile, egrid_gra, ext_gra, sca_gra, gra_params)
return
def multiscreen_tau(sample, d2g=0.009, scatm=ss.makeScatmodel("RG", "Drude")):
result = []
for walker in sample:
logNHu, logNHs, a_u, a_s, p_u, p_s, x_s = walker
MDu, MDs = np.power(10.0, logNHu) * c.mp() * d2g, np.power(10.0, logNHs) * c.mp() * d2g
da_u, da_s = (a_u - AMIN) / 10.0, (a_s - AMIN) / 10.0
Udust = dust.Dustdist(rad=np.arange(AMIN, a_u + da_u, da_u), p=p_u)
Sdust = dust.Dustdist(rad=np.arange(AMIN, a_s + da_s, da_s), p=p_s)
Ukappa = ss.Kappascat(E=1.0, dist=dust.Dustspectrum(rad=Udust, md=MDu), scatm=scatm).kappa[0]
Skappa = ss.Kappascat(E=1.0, dist=dust.Dustspectrum(rad=Sdust, md=MDs), scatm=scatm).kappa[0]
result.append(Ukappa * MDu + Skappa * MDs)
return np.array(result)
def multiscreen_tau( sample, d2g=0.009, scatm=ss.makeScatmodel('RG','Drude') ):
result = []
for walker in sample:
logNHu, logNHs, a_u, a_s, p_u, p_s, x_s = walker
MDu, MDs = np.power(10.0,logNHu) * c.m_p * d2g, np.power(10.0,logNHs) * c.m_p * d2g
da_u, da_s = (a_u-AMIN)/10.0, (a_s-AMIN)/10.0
Udust = dust.Powerlaw(AMIN, a_u, na=(a_u-AMIN)/da_u, p=p_u)
Sdust = dust.Powerlaw(AMIN, a_s, na=(a_s-AMIN)/da_s, p=p_s)
Ukappa = ss.Kappascat( E=1.0, dist=dust.Dustspectrum( rad=Udust, md=MDu ), scatm=scatm ).kappa[0]
Skappa = ss.Kappascat( E=1.0, dist=dust.Dustspectrum( rad=Sdust, md=MDs ), scatm=scatm ).kappa[0]
result.append( Ukappa*MDu + Skappa*MDs )
return np.array( result )
def sample_extinction(sample, lam, isample, NA=20, d2g=0.009, scatm=ss.makeScatmodel("RG", "Drude")):
energy = c.kev2lam() / lam # lam must be in cm to get keV
logMD = sample_logMD(sample)
MD = np.power(10.0, logMD)
result = []
for i in isample:
logNH, amax, p = sample[i]
print "logNH =", logNH, "\tamax =", amax, "\tp =", p
da = (amax - AMIN) / np.float(NA)
dist = dust.Dustdist(rad=np.arange(AMIN, amax + da, da), p=p)
spec = dust.Dustspectrum(rad=dist, md=MD[i])
kappa = ss.Kappascat(E=energy, dist=spec, scatm=scatm).kappa
result.append(1.086 * MD[i] * kappa)
return result
def sample_extinction( sample, lam, isample, \
NA=20, d2g=0.009, scatm=ss.makeScatmodel('RG','Drude') ):
energy = c.hc / lam # lam must be in cm to get keV
logMD = sample_logMD( sample )
MD = np.power( 10.0, logMD )
result = []
for i in isample:
logNH, amax, p = sample[i]
print('logNH =', logNH, '\tamax =', amax, '\tp =', p)
da = (amax-AMIN)/np.float(NA)
dist = dust.Powerlaw(AMIN, amax, na=(amax-AMIN)/da, p=p)
spec = dust.Dustspectrum( rad=dist, md=MD[i] )
kappa = ss.Kappascat( E=energy, dist=spec, scatm=scatm ).kappa
result.append( 1.086 * MD[i] * kappa )
return result
# dust radius range to compute (in um)
# up to 0.25 um
MRN_RANGE = np.arange(0.005,0.25001,0.05)
# larger range going up to 1.5 um
BIG_RANGE = np.arange(0.005, 1.5, 0.05)
MRN_RANGE = BIG_RANGE
# define dust distribution: A powerlaw with index 3.5
MRN_sil = dust.Dustdist( rad=MRN_RANGE, p=3.5, rho=RHO_SIL )
MRN_gra = dust.Dustdist( rad=MRN_RANGE, p=3.5, rho=RHO_GRA )
MRN_avg = dust.Dustdist( rad=MRN_RANGE, p=3.5, rho=RHO_AVG )
print('Defining Kappaext and Dustspectrum...')
print(' Mie scattering with Drude approximation')
RGD_mrn = ss.Kappaext( E=ERANGE, dist=dust.Dustspectrum(rad=MRN_avg, md=dust_mass), scatm=ss.makeScatmodel('Mie','Drude') )
print(' Mie scattering for the small grain MRN distribution')
Mie_mrn_sil = ss.Kappaext( E=ERANGE, dist=dust.Dustspectrum(rad=MRN_sil, md=dust_mass), scatm=ss.makeScatmodel('Mie','Silicate') )
Mie_mrn_gra = ss.Kappaext( E=ERANGE, dist=dust.Dustspectrum(rad=MRN_gra, md=dust_mass), scatm=ss.makeScatmodel('Mie','Graphite') )
print('plotting...')
plt.plot( RGD_mrn.E, RGD_mrn.kappa * MD, '0.4', lw=2, label='Mie-Drude' )
plt.plot( Mie_mrn_sil.E, Mie_mrn_sil.kappa * MD, 'g', lw=2, label='Mie-Silicate' )
plt.plot( Mie_mrn_gra.E, Mie_mrn_gra.kappa * MD, 'b', lw=2, label='Mie-Graphite' )
plt.legend( loc='upper right', fontsize=12 )
plt.loglog()
plt.xlim(0.3,10)
plt.ion()
import dust
import sigma_scat as ss
# Set up the grain size distribution. Let's assume all the dust grains are silicate.
AMIN, AMAX = 0.005, 0.25 # microns
NA = 50 # number of points to use to sample distribution
RHO = 3.8 # grain density (g cm^-3)
P = 3.5 # power law slope
mrn = dust.Dustdist(rad=np.linspace(AMIN, AMAX, NA), rho=RHO, p=P)
# Calculate the scattering and extinction opacity
ENERGY = np.logspace(-1, 1, 50)
MDUST = 1.0e22 * dust.c.mp() * 0.009 # magic numbers (dust mass per 10^22 H)
kappascat = ss.Kappascat(E=ENERGY, dist=dust.Dustspectrum(rad=mrn), scatm=ss.makeScatmodel("Mie", "Silicate"))
# The Python Profiler helps you identify the bottlenecks in your code. In general, you want to use the C version of it: cProfile. The simplest way to run it is to execute it via: `cProfile.run(command,filename)`, where command is a string containing the command you wish to profile, and filename is the file you want to write the results to.
import cProfile
import pstats
profile_name = "Kappascat.prof"
cProfile.run("kappascat(with_mp=False)", filename=profile_name)
# cProfile.run("kappascat(with_mp=True)",filename=profile_name)
stats = pstats.Stats(profile_name)
stats.strip_dirs()
stats.sort_stats("cumtime").print_stats(10)
"""Test code for kernprof.py"""
import numpy as np
import dust
import sigma_scat as ss
# Set up the grain size distribution. Let's assume all the dust grains are silicate.
AMIN, AMAX = 0.005, 0.25 # microns
NA = 5 # number of points to use to sample distribution
RHO = 3.8 # grain density (g cm^-3)
P = 3.5 # power law slope
mrn = dust.Dustdist( rad=np.linspace(AMIN,AMAX,NA), rho=RHO, p=P )
# Calculate the scattering and extinction opacity
ENERGY = np.logspace(-1,1,50)
MDUST = 1.e22 * dust.c.mp() * 0.009 # magic numbers (dust mass per 10^22 H)
kappascat = ss.Kappascat( E=ENERGY, dist=dust.Dustspectrum(rad=mrn), scatm=ss.makeScatmodel('Mie','Silicate') )
kappascat()
def _tau_ext_E( E, params ):
amin, amax, p, rho, mdust, gtype = parmas
result = ss.Kappaext(E=E, dist=_dustspec(params), scatm=ss.makeScatmodel('Mie',gtype))
return result.kappa[0] * mdust
