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