alpha = 2.59e-13 # Recombination rate at T=1e4 K
nH = 1e-3 # Hydrogen density
lum = 5e48 # Ionizing photon luminosity
trec = 1.0 / (alpha * nH) # Recombination time
rs = ((3 * lum) / (4 * np.pi * alpha * nH**2))**(1.0 / 3)
anyl_radius = rs * (1.0 - np.exp(-time / trec))**(1.0 / 3)
#print("anyl_radius = ", anyl_radius)
anyl_radius = YTArray(anyl_radius, 'cm')
#print("anyl_radius = ", anyl_radius.to('kpc'))
ratio = radius / anyl_radius
error = np.abs(1 - ratio)
imax = np.where(error == error.max())[0]
p = plt.subplot(211)
p.plot(time / Myr, radius.in_units('kpc'), 'ro')
p.plot(time / Myr, anyl_radius.to('kpc'), 'k-')
p.set_ylabel(r'$r_{\rm IF}$ (kpc)')
p = plt.subplot(212)
p.plot(time / Myr, ratio, 'k-')
p.set_ylabel(r'$r_{\rm IF} / r_{\rm anyl}$')
p.set_xlabel("Time (Myr)")
plt.savefig("StroemgrenRadius.png")
########################################################################
# Some basic analysis on the final output
########################################################################
pf = yt.load("DD%4.4d/data%4.4d" % (last, last))
myfields = ["HI_kph", "Neutral_Fraction", "El_fraction"]
pc = yt.SlicePlot(pf, 2, center=[0.5, 0.5, 1.0 / 64], fields=myfields)
pc.save()
def make_xrb_particles(data_source, age_field, scale_length,
sfr_time_range=(1.0, "Gyr"), prng=None):
r"""
This routine generates an in-memory dataset composed of X-ray binary particles
from an input data source containing star particles.
Parameters
----------
data_source : :class:`~yt.data_objects.data_containers.YTSelectionContainer`
The yt data source to obtain the data from, such as a sphere, box, disk,
etc.
age_field : string or (type, name) field tuple
The stellar age field. Must be in some kind of time units.
scale_length : string, (ftype, fname) tuple, (value, unit) tuple, :class:`~yt.units.yt_array.YTQuantity`, or :class:`~astropy.units.Quantity`
The radial length scale over which to scatter the XRB particles
from their parent star particle. Can be the name of a smoothing
length field for the stars, a (value, unit) tuple, or a YTQuantity.
sfr_time_range : string, (ftype, fname) tuple, (value, unit) tuple, :class:`~yt.units.yt_array.YTQuantity`, or :class:`~astropy.units.Quantity`, optional
The recent time range over which to calculate the star formation rate from
the current time in the dataset. Default: 1.0 Gyr
prng : integer or :class:`~numpy.random.RandomState` object
A pseudo-random number generator. Typically will only be specified
if you have a reason to generate the same set of random numbers, such as for a
test. Default is to use the :mod:`numpy.random` module.
"""
prng = parse_prng(prng)
ds = data_source.ds
ptype = data_source._determine_fields(age_field)[0][0]
t = data_source[age_field].to("Gyr")
m = data_source[(ptype, "particle_mass")].to("Msun")
sfr_time_range = parse_value(sfr_time_range, "Gyr")
recent = t < sfr_time_range
n_recent = recent.sum()
if n_recent == 0:
sfr = 0.0
else:
sfr = (m[recent].sum()/sfr_time_range).to("Msun/yr").v
mylog.info("%d star particles were formed in the last " % n_recent +
"%s for a SFR of %4.1f Msun/yr." % (sfr_time_range, sfr))
mtot = m.sum()
npart = m.size
scale_field = None
if isinstance(scale_length, tuple):
if isinstance(scale_length[0], string_types):
scale_field = scale_length
elif isinstance(scale_length, string_types):
scale_field = (ptype, scale_length)
if scale_field is None:
if isinstance(scale_length, tuple):
scale = YTArray([scale_length[0]]*npart, scale_length[1])
elif isinstance(scale_length, YTQuantity):
scale = YTArray([scale_length]*npart)
else:
scale = YTArray([scale_length[0]]*npart, "kpc")
else:
scale = data_source[scale_length]
scale = scale.to('kpc').d
N_l = lmxb_cdf(Lcut)*mtot.v*1.0e-11
N_h = hmxb_cdf(Lcut)*sfr
N_all = N_l+N_h
if N_all == 0.0:
raise RuntimeError("There are no X-ray binaries to generate!")
# Compute conversion factors from luminosity to count rate
lmxb_factor = get_scale_factor(alpha_lmxb, emin_lmxb, emax_lmxb)
hmxb_factor = get_scale_factor(alpha_hmxb, emin_hmxb, emax_hmxb)
xp = []
yp = []
zp = []
vxp = []
vyp = []
vzp = []
lp = []
rp = []
ap = []
if N_l > 0.0:
F_l = np.zeros(nbins+1)
for i in range(1, nbins+1):
F_l[i] = lmxb_cdf(Lbins[i])
F_l /= F_l[-1]
invcdf_l = InterpolatedUnivariateSpline(F_l, logLbins)
n_l = prng.poisson(lam=N_l*m/mtot)
mylog.info("Number of low-mass X-ray binaries: %s" % n_l.sum())
for i, n in enumerate(n_l):
if n > 0:
randvec = prng.uniform(size=n)
l = YTArray(10**invcdf_l(randvec)*1.0e38, "erg/s")
r = YTArray(l.v*lmxb_factor, "photons/s/keV")
# Now convert output luminosities to bolometric
l *= bc_lmxb
x = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
y = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
z = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
x += data_source[ptype, "particle_position_x"][i].to("kpc")
y += data_source[ptype, "particle_position_y"][i].to("kpc")
z += data_source[ptype, "particle_position_z"][i].to("kpc")
vx = YTArray([data_source[ptype, "particle_velocity_x"][i]]*n).to('km/s')
vy = YTArray([data_source[ptype, "particle_velocity_y"][i]]*n).to('km/s')
vz = YTArray([data_source[ptype, "particle_velocity_z"][i]]*n).to('km/s')
xp.append(x)
yp.append(y)
zp.append(z)
vxp.append(vx)
vyp.append(vy)
vzp.append(vz)
lp.append(l)
rp.append(r)
ap.append(np.array([alpha_lmxb]*n))
if N_h > 0.0:
F_h = np.zeros(nbins+1)
for i in range(1, nbins+1):
F_h[i] = hmxb_cdf(Lbins[i])
F_h /= F_h[-1]
invcdf_h = InterpolatedUnivariateSpline(F_h, logLbins)
n_h = prng.poisson(lam=N_h*m/mtot)
mylog.info("Number of high-mass X-ray binaries: %s" % n_h.sum())
for i, n in enumerate(n_h):
if n > 0:
randvec = prng.uniform(size=n)
l = YTArray(10**invcdf_h(randvec)*1.0e38, "erg/s")
r = YTArray(l.v*hmxb_factor, "photons/s/keV")
# Now convert output luminosities to bolometric
l *= bc_hmxb
x = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
y = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
z = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
x += data_source[ptype, "particle_position_x"][i].to("kpc")
y += data_source[ptype, "particle_position_y"][i].to("kpc")
z += data_source[ptype, "particle_position_z"][i].to("kpc")
vx = YTArray([data_source[ptype, "particle_velocity_x"][i]]*n).to('km/s')
vy = YTArray([data_source[ptype, "particle_velocity_y"][i]]*n).to('km/s')
vz = YTArray([data_source[ptype, "particle_velocity_z"][i]]*n).to('km/s')
xp.append(x)
yp.append(y)
zp.append(z)
vxp.append(vx)
vyp.append(vy)
vzp.append(vz)
lp.append(l)
rp.append(r)
ap.append(np.array([alpha_hmxb]*n))
xp = uconcatenate(xp)
yp = uconcatenate(yp)
zp = uconcatenate(zp)
vxp = uconcatenate(vxp)
vyp = uconcatenate(vyp)
vzp = uconcatenate(vzp)
lp = uconcatenate(lp)
rp = uconcatenate(rp)
ap = uconcatenate(ap)
data = {"particle_position_x": (xp.d, str(xp.units)),
"particle_position_y": (yp.d, str(yp.units)),
"particle_position_z": (zp.d, str(zp.units)),
"particle_velocity_x": (vxp.d, str(vxp.units)),
"particle_velocity_y": (vyp.d, str(vyp.units)),
"particle_velocity_z": (vzp.d, str(vzp.units)),
"particle_luminosity": (lp.d, str(lp.units)),
"particle_count_rate": (rp.d, str(rp.units)),
"particle_spectral_index": ap}
dle = ds.domain_left_edge.to("kpc").v
dre = ds.domain_right_edge.to("kpc").v
bbox = np.array([[dle[i], dre[i]] for i in range(3)])
new_ds = load_particles(data, bbox=bbox, length_unit="kpc",
time_unit="Myr", mass_unit="Msun",
velocity_unit="km/s")
return new_ds
def make_xrb_particles(data_source,
age_field,
scale_length,
sfr_time_range=(1.0, "Gyr"),
prng=None):
r"""
This routine generates an in-memory dataset composed of X-ray binary particles
from an input data source containing star particles.
Parameters
----------
data_source : :class:`~yt.data_objects.data_containers.YTSelectionContainer`
The yt data source to obtain the data from, such as a sphere, box, disk,
etc.
age_field : string or (type, name) field tuple
The stellar age field. Must be in some kind of time units.
scale_length : string, (ftype, fname) tuple, (value, unit) tuple, :class:`~yt.units.yt_array.YTQuantity`, or :class:`~astropy.units.Quantity`
The radial length scale over which to scatter the XRB particles
from their parent star particle. Can be the name of a smoothing
length field for the stars, a (value, unit) tuple, or a YTQuantity.
sfr_time_range : string, (ftype, fname) tuple, (value, unit) tuple, :class:`~yt.units.yt_array.YTQuantity`, or :class:`~astropy.units.Quantity`, optional
The recent time range over which to calculate the star formation rate from
the current time in the dataset. Default: 1.0 Gyr
prng : integer or :class:`~numpy.random.RandomState` object
A pseudo-random number generator. Typically will only be specified
if you have a reason to generate the same set of random numbers, such as for a
test. Default is to use the :mod:`numpy.random` module.
"""
prng = parse_prng(prng)
ds = data_source.ds
ptype = data_source._determine_fields(age_field)[0][0]
t = data_source[age_field].to("Gyr")
m = data_source[(ptype, "particle_mass")].to("Msun")
sfr_time_range = parse_value(sfr_time_range, "Gyr")
recent = t < sfr_time_range
n_recent = recent.sum()
if n_recent == 0:
sfr = 0.0
else:
sfr = (m[recent].sum() / sfr_time_range).to("Msun/yr").v
mylog.info("%d star particles were formed in the last " % n_recent +
"%s for a SFR of %4.1f Msun/yr." % (sfr_time_range, sfr))
mtot = m.sum()
npart = m.size
scale_field = None
if isinstance(scale_length, tuple):
if isinstance(scale_length[0], string_types):
scale_field = scale_length
elif isinstance(scale_length, string_types):
scale_field = (ptype, scale_length)
if scale_field is None:
if isinstance(scale_length, tuple):
scale = YTArray([scale_length[0]] * npart, scale_length[1])
elif isinstance(scale_length, YTQuantity):
scale = YTArray([scale_length] * npart)
else:
scale = YTArray([scale_length[0]] * npart, "kpc")
else:
scale = data_source[scale_length]
scale = scale.to('kpc').d
N_l = lmxb_cdf(Lcut) * mtot.v * 1.0e-11
N_h = hmxb_cdf(Lcut) * sfr
N_all = N_l + N_h
if N_all == 0.0:
raise RuntimeError("There are no X-ray binaries to generate!")
# Compute conversion factors from luminosity to count rate
lmxb_factor = get_scale_factor(alpha_lmxb, emin_lmxb, emax_lmxb)
hmxb_factor = get_scale_factor(alpha_hmxb, emin_hmxb, emax_hmxb)
xp = []
yp = []
zp = []
vxp = []
vyp = []
vzp = []
lp = []
rp = []
ap = []
if N_l > 0.0:
F_l = np.zeros(nbins + 1)
for i in range(1, nbins + 1):
F_l[i] = lmxb_cdf(Lbins[i])
F_l /= F_l[-1]
invcdf_l = InterpolatedUnivariateSpline(F_l, logLbins)
n_l = prng.poisson(lam=N_l * m / mtot)
mylog.info("Number of low-mass X-ray binaries: %s" % n_l.sum())
for i, n in enumerate(n_l):
if n > 0:
randvec = prng.uniform(size=n)
l = YTArray(10**invcdf_l(randvec) * 1.0e38, "erg/s")
r = YTArray(l.v * lmxb_factor, "photons/s/keV")
# Now convert output luminosities to bolometric
l *= bc_lmxb
x = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
y = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
z = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
x += data_source[ptype, "particle_position_x"][i].to("kpc")
y += data_source[ptype, "particle_position_y"][i].to("kpc")
z += data_source[ptype, "particle_position_z"][i].to("kpc")
vx = YTArray([data_source[ptype, "particle_velocity_x"][i]] *
n).to('km/s')
vy = YTArray([data_source[ptype, "particle_velocity_y"][i]] *
n).to('km/s')
vz = YTArray([data_source[ptype, "particle_velocity_z"][i]] *
n).to('km/s')
xp.append(x)
yp.append(y)
zp.append(z)
vxp.append(vx)
vyp.append(vy)
vzp.append(vz)
lp.append(l)
rp.append(r)
ap.append(np.array([alpha_lmxb] * n))
if N_h > 0.0:
F_h = np.zeros(nbins + 1)
for i in range(1, nbins + 1):
F_h[i] = hmxb_cdf(Lbins[i])
F_h /= F_h[-1]
invcdf_h = InterpolatedUnivariateSpline(F_h, logLbins)
n_h = prng.poisson(lam=N_h * m / mtot)
mylog.info("Number of high-mass X-ray binaries: %s" % n_h.sum())
for i, n in enumerate(n_h):
if n > 0:
randvec = prng.uniform(size=n)
l = YTArray(10**invcdf_h(randvec) * 1.0e38, "erg/s")
r = YTArray(l.v * hmxb_factor, "photons/s/keV")
# Now convert output luminosities to bolometric
l *= bc_hmxb
x = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
y = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
z = YTArray(prng.normal(scale=scale[i], size=n), "kpc")
x += data_source[ptype, "particle_position_x"][i].to("kpc")
y += data_source[ptype, "particle_position_y"][i].to("kpc")
z += data_source[ptype, "particle_position_z"][i].to("kpc")
vx = YTArray([data_source[ptype, "particle_velocity_x"][i]] *
n).to('km/s')
vy = YTArray([data_source[ptype, "particle_velocity_y"][i]] *
n).to('km/s')
vz = YTArray([data_source[ptype, "particle_velocity_z"][i]] *
n).to('km/s')
xp.append(x)
yp.append(y)
zp.append(z)
vxp.append(vx)
vyp.append(vy)
vzp.append(vz)
lp.append(l)
rp.append(r)
ap.append(np.array([alpha_hmxb] * n))
xp = uconcatenate(xp)
yp = uconcatenate(yp)
zp = uconcatenate(zp)
vxp = uconcatenate(vxp)
vyp = uconcatenate(vyp)
vzp = uconcatenate(vzp)
lp = uconcatenate(lp)
rp = uconcatenate(rp)
ap = uconcatenate(ap)
data = {
"particle_position_x": (xp.d, str(xp.units)),
"particle_position_y": (yp.d, str(yp.units)),
"particle_position_z": (zp.d, str(zp.units)),
"particle_velocity_x": (vxp.d, str(vxp.units)),
"particle_velocity_y": (vyp.d, str(vyp.units)),
"particle_velocity_z": (vzp.d, str(vzp.units)),
"particle_luminosity": (lp.d, str(lp.units)),
"particle_count_rate": (rp.d, str(rp.units)),
"particle_spectral_index": ap
}
dle = ds.domain_left_edge.to("kpc").v
dre = ds.domain_right_edge.to("kpc").v
bbox = np.array([[dle[i], dre[i]] for i in range(3)])
new_ds = load_particles(data,
bbox=bbox,
length_unit="kpc",
time_unit="Myr",
mass_unit="Msun",
velocity_unit="km/s")
return new_ds
