index = ii
zeta = fz.get_zeta(NH2[index])
print("CR ionization rate = ", zeta, "compared to Ntot",
fz.get_zeta(Ntot[index]), "NH2 = ", NH2[index], "Ntot = ",
Ntot[index])
#zeta = fz.get_zeta(fH2shield[ii])
############################################################################################
Jpe, Je, Jh, Jc, ZZall = fz.compute_currents([nH[index], nC[index]],
[xHp[index], xCp[index]],
xH2[index],
temp[index],
zeta,
grain_size,
Ntot[index],
grain_type,
Qabs,
G0=G0)
JCRe, JCRpe, ZZnew = fz.compute_CR_currents(nH[index], zeta,
grain_size, grain_type,
Qabs)
zeq = fz.get_zeq_vec(Jpe, Je, Jh, Jc, ZZall, grain_size, grain_type)
new_zmin, new_zmax = fz.get_new_zmin_zmax([nH[index], nC[index]],
[xHp[index], xCp[index]],
temp[index],
grain_size,
Ntot[index],
grain_type,
for ii in range(3):
print("Running %s grain with size %i in phase %s" %
(grain_type, grain_size[kk], phases[ii]))
# Get the CR ionization rate given the Column density.
# Update to the total column density instead of the weird Flash function.
zeta = fz.get_zeta(Ntot[ii])
############################################################################################
# Run the charge distribution calculation!!!
Jpe, Je, Jh, Jc, ZZall = fz.compute_currents([nH[ii], nC[ii]],
[xe[ii], 0.0],
xH2[ii],
temp[ii],
zeta,
grain_size[kk],
Ntot[ii],
grain_type,
Qabs[kk],
G0=G0)
JCRe, JCRpe, ZZnew = fz.compute_CR_currents(nH[ii], zeta,
grain_size[kk], grain_type,
Qabs[kk])
zeq = fz.get_zeq_vec(Jpe, Je, Jh, Jc, ZZall, grain_size[kk],
grain_type)
new_zmin, new_zmax = fz.get_new_zmin_zmax([nH[ii], nC[ii]],
[xe[ii], 0.0],
temp[ii],
grain_size[kk],
Ntot[ii],
grain_type,
def netHeating_full(grain_size,
grain_type,
nH,
temp,
xe,
xH2,
Ntot,
NH2,
G0=1.7,
save_output=False,
outdir="default",
pedantic=False):
"""
Perform the full calculation of the net heating by a single grain given the ISM ambient parameters.
"""
import _pickle as pickle
import compute_charge_dist as fz
import numpy as np
import PeHeat_Functions as peh
#Full calculation of the net heating by a grain at a given cell.
Qabs = fz.get_QabsTable(grain_type, grain_size)
#print("Running grain size %i, "%(grain_size))
zeta = fz.get_zeta(NH2)
# Compute the charge distribution.
############################################################################################
Jpe, Je, Jh, Jc, ZZall = fz.compute_currents([nH, nH * 1.0e-4],
[xe, 1.0e4 * min(xe, 1.0e-4)],
xH2,
temp,
zeta,
grain_size,
Ntot,
grain_type,
Qabs,
G0=G0)
JCRe, JCRpe, ZZnew = fz.compute_CR_currents(nH, zeta, grain_size,
grain_type, Qabs)
zeq = fz.get_zeq_vec(Jpe, Je, Jh, Jc, ZZall, grain_size, grain_type)
new_zmin, new_zmax = fz.get_new_zmin_zmax([nH, nH * 1.0e-4],
[xe, 1.0e4 * min(xe, 1.0e-4)],
temp,
grain_size,
Ntot,
grain_type,
Qabs,
zeta,
zeq=zeq,
G0=G0,
includeCR=True)
ffzCR, ZZfz = fz.vector_fz(Jpe,
Je,
Jh,
Jc,
JCRe,
JCRpe,
ZZall,
new_zmin,
new_zmax,
includeCR=True)
# Compute the minimum and maximum allowd charges by this grain
Zmin, Zmax = fz.get_Zmin(grain_size,
grain_type), fz.get_Zmax(grain_size, grain_type)
Znum = int(Zmax + abs(Zmin) + 1)
ZZ_all = np.linspace(Zmin, Zmax, num=Znum)
Gamma_dotdot_Z = np.zeros_like(ZZ_all, dtype=np.float)
for i in range(Znum):
Gamma_dotdot_Z[i] = peh.get_Gamma_pe_dotdot(grain_size, ZZ_all[i],
grain_type, Ntot, Qabs)
Cooling = peh.Cool_per_Grain(grain_size, grain_type, ZZfz, ffzCR, nH, xe,
temp)
Av = Ntot / 1.87e21
Geff = G0 * np.exp(-2.5 * Av)
G_CR = fz.get_G_CR(NH2)
Gtot = Geff + G_CR
Heating = peh.Gamma_per_grain(ZZ_all, Gamma_dotdot_Z, ZZfz, ffzCR)
netHeating = Heating - Cooling
if save_output:
if nH < 1.0:
phase = "WNM"
elif nH > 1.0 and nH < 100:
phase = "CNM"
else:
phase = "CMM"
if outdir == "default":
outdir = "/home/jcibanezm/codes/run/PeHeat"
filename = "%s/TotalHeating_ISM%s_%s_%.3fAA.pkl" % (
outdir, phase, grain_type, grain_size)
dictionary = {
"info":
"Saving the Heating, Cooling, charge array and charge distribution."
}
dictionary["netHeating"] = netHeating
dictionary["Heating"] = Heating
dictionary["Cooling"] = Cooling
dictionary["grain_size"] = grain_size
dictionary["grain_type"] = grain_type
dictionary["ffz"] = ffzCR
dictionary["ZZ"] = ZZfz
dictionary["nH"] = nH
dictionary["temp"] = temp
dictionary["Geff"] = Geff
dictionary["Gtot"] = Gtot
dictionary["zeta"] = zeta
dictionary["Ntot"] = Ntot
dictionary["NH2"] = NH2
dictionary["ne"] = nH * xe
dictionary["xe"] = xe
dictionary["xH2"] = xH2
dictionary["zmin"] = new_zmin
dictionary["zmax"] = new_zmax
if pedantic == True:
print(
"Saving a file with the information of the net Heating and Cooling in this cell."
)
print("Cell properties:")
print("grain size = %.1f, grain type = %s" %
(grain_size, grain_type))
print("ntot = %.2g \t temp = %.2g \t Geff = %.2g \t Gtot = %.2g" %
(nH, temp, Geff, Gtot))
print("zeta = %.2g \t Ntot = %.2g \t NH2 = %.2g \t ne = %.2g" %
(zeta, Ntot, NH2, nH * xe))
print("xe = %.2g \t xH2 = %.2g" % (xe, xH2))
print("netHeating = %.2g erg s-1 \t Cooling %.2g erg s-1" %
(netHeating, Cooling))
print("ZZ =", ZZfz)
print("f(Z) = ", ffzCR)
outfile = open('%s' % (filename), 'wb')
pickle.dump(dictionary, outfile)
outfile.close()
#return netHeating, Cooling, ZZfz, ffzCR
return Heating
def charge_dist(filename, pos, num_procs, grain_size, grain_type, test=False):
""" Calculates the charge distribution """
import compute_charge_dist as fz
import yt
import numpy as np
import sys
mH = 1.6733e-24 # g
mC = 12.011 * mH
print_to_logfile("Reading Flash file. \t proc = %i" % pos,
grain_size=grain_size,
grain_type=grain_type,
filename=filename,
first_call=True)
pf = yt.load("%s" % (filename))
ppc = 3.085677e18
le = [-15 * ppc, -4.93696000e+19, -4.93696000e+19]
re = [+15 * ppc, +4.93696000e+19, +4.93696000e+19]
dd = pf.box(le, re)
if pos == 0:
print("Total number of cells = %i" % len(dd["dens"]))
#dd = pf.all_data()
# Read file and calculate the number of cells.
if test == True:
num_cells = 5 * num_procs
else:
num_cells = len(dd["dens"])
# calculate the number of cells to be distributed per processor. [has to be an interger number]
# Calculate the offset in the array to
cells_per_proc = num_cells // num_procs
# Find the offset in the array where the information is coming from.
offset = cells_per_proc * pos
# The missing cells are handled by the last processor
if pos == (num_procs - 1): cells_per_proc += num_cells % num_procs
dens = np.array(np.zeros(cells_per_proc))
temp, Av = np.zeros_like(dens), np.zeros_like(dens)
ih2, iha, ihp, ico, icp, dx, xx, yy, zz = np.zeros_like(
dens), np.zeros_like(dens), np.zeros_like(dens), np.zeros_like(
dens), np.zeros_like(dens), np.zeros_like(dens), np.zeros_like(
dens), np.zeros_like(dens), np.zeros_like(dens)
zmean, zmode, zstd = np.zeros_like(dens), np.zeros_like(
dens), np.zeros_like(dens)
nH, nC, xHp, xCp, ne, xe = np.zeros_like(dens), np.zeros_like(
dens), np.zeros_like(dens), np.zeros_like(dens), np.zeros_like(
dens), np.zeros_like(dens)
zminmax = np.array(np.zeros(2 * cells_per_proc))
tauz = np.zeros_like(dens)
fdist = []
#fdist = np.zeros_like(dens)
dictionary = {
"info": "charge distribution calculated in processor %i" % pos
}
############################################################################
# I should read the Qabs table here, and pass it to the Jrate, calculation.
############################################################################
Qabs = fz.get_QabsTable(grain_type, grain_size)
#########################################################################################################
# Charge distribution loop over all cells.
#########################################################################################################
print_to_logfile("Looping over %i cells in proc = %i" %
(cells_per_proc, pos),
grain_size=grain_size,
grain_type=grain_type,
filename=filename)
for ii in range(cells_per_proc):
index = offset + ii
if ii % 1.0e4 == 0:
print("I'm proc %i, running cell %i" % (pos, index))
dens[ii] = dd["dens"][index].value
temp[ii] = dd["temp"][index].value
Av[ii] = dd["cdto"][index].value
ih2[ii] = dd["ih2 "][index].value
iha[ii] = dd["iha "][index].value
ihp[ii] = dd["ihp "][index].value
ico[ii] = dd["ico "][index].value
icp[ii] = dd["icp "][index].value
dx[ii] = dd["dx"][index].value
xx[ii] = dd["x"][index].value
yy[ii] = dd["y"][index].value
zz[ii] = dd["z"][index].value
# Number density of hydrogen atoms.
nH[ii] = dd["dens"][index].value * (
dd["ihp "][index].value + dd["iha "][index].value +
dd["ih2 "][index].value) / (1.4 * mH)
nH2 = dd["dens"][index].value * (dd["ih2 "][index].value) / (1.4 * mH)
# Number density of carbon atoms.
nC[ii] = dd["dens"][index].value * (
dd["icp "][index].value + dd["ico "][index].value) / (1.4 * mC)
# fraction of ionized hydrogen and carbon
xHp[ii] = dd["dens"][index].value * dd["ihp "][index].value / (
1.4 * mH) / nH[ii]
xCp[ii] = dd["dens"][index].value * dd["icp "][index].value / (
1.4 * mC) / nC[ii]
# Number density of electrons
ne[ii] = dd["dens"][index].value * (dd["ihp "][index].value /
(1.4 * mH) +
dd["icp "][index].value /
(1.4 * mC))
# electron fraction.
xe[ii] = ne[ii] / (nH[ii] + nC[ii])
############################################################################################
# Run the charge distribution calculation!!!
Jpe, Je, Jh, Jc, ZZall = fz.compute_currents([nH[ii], nC[ii]],
[xHp[ii], xCp[ii]],
temp[ii], grain_size,
Av[ii], grain_type, Qabs)
# Compute CR currents
JCRe, JCRpe, ZZnew = fz.compute_CR_currents(nH2, grain_size,
grain_type)
zeq = fz.get_zeq_vec(Jpe, Je, Jh, Jc, ZZall, grain_size, grain_type)
new_zmin, new_zmax = fz.get_new_zmin_zmax([nH[ii], nC[ii]],
[xHp[ii], xCp[ii]],
temp[ii],
grain_size,
Av[ii],
grain_type,
Qabs,
zeq=zeq)
ffz, ZZ = fz.vector_fz(Jpe,
Je,
Jh,
Jc,
JCRe,
JCRpe,
ZZall,
new_zmin,
new_zmax,
includeCR=True)
# This should be updated accordingly!!!
tauz[ii] = fz.tauz_vec(Jpe, Je, Jh, Jc, ZZall, ffz, new_zmin, new_zmax)
######## Commented on Feb 13 2018 #### Before including CR currents.
# zeq = fz.get_zeq_vec (Jpe, Je, Jh, Jc, ZZall, grain_size, grain_type)
# new_zmin, new_zmax = fz.get_new_zmin_zmax([nH[ii], nC[ii]], [xHp[ii], xCp[ii]], temp[ii], grain_size, Av[ii], grain_type, Qabs, zeq=zeq)
# ffz, ZZ = fz.vector_fz (Jpe, Je, Jh, Jc, ZZall, new_zmin, new_zmax)
# tauz[ii] = fz.tauz_vec (Jpe, Je, Jh, Jc, ZZall, ffz, new_zmin, new_zmax)
#zeq = fz.get_zeq ([nH[ii], nC[ii]], [xHp[ii], xCp[ii]], temp[ii], grain_size, Av[ii], grain_type)
#new_zmin, new_zmax = fz.get_new_zmin_zmax([nH[ii], nC[ii]], [xHp[ii], xCp[ii]], temp[ii], grain_size, Av[ii], grain_type, zeq=zeq)
#ffz, ZZ = fz.compute_fz_speed ([nH[ii], nC[ii]], [xHp[ii], xCp[ii]], temp[ii], grain_size, Av[ii], grain_type, zmin=new_zmin, zmax=new_zmax)
#tauz[ii] = fz.get_tauz(grain_size, grain_type, [nH[ii], nC[ii]], [xHp[ii], xCp[ii]], temp[ii], Av[ii], ZZ, ffz)
Zm = fz.get_Zmode(ZZ, ffz)
zmode[ii] = Zm
avg, std = fz.weighted_avg_and_std(ZZ, ffz)
zmean[ii] = avg
zstd[ii] = std
zminmax[ii * 2] = new_zmin
zminmax[ii * 2 + 1] = new_zmax
#fdist[ii] = offset + ii
for jj in range(len(ffz)):
fdist.append(ffz[jj])
print_to_logfile(
"Finished loop over all cells in this processor. \t proc=%i" % pos,
grain_size=grain_size,
grain_type=grain_type,
filename=filename)
dictionary["dens"] = dens
dictionary["temp"] = temp
dictionary["Av"] = Av
dictionary["zmean"] = zmean
dictionary["zmode"] = zmode
dictionary["zstd"] = zstd
dictionary["tauz"] = tauz
dictionary["fdist"] = np.array(fdist)
dictionary["zminmax"] = np.array(zminmax)
dictionary["nH"] = nH
dictionary["nC"] = nC
dictionary["xHp"] = xHp
dictionary["xCp"] = xCp
dictionary["ne"] = ne
dictionary["xe"] = xe
dictionary["iha"] = iha
dictionary["ihp"] = ihp
dictionary["ih2"] = ih2
dictionary["ico"] = ico
dictionary["icp"] = icp
dictionary["dx"] = dx
dictionary["xx"] = xx
dictionary["yy"] = yy
dictionary["zz"] = zz
del dens, temp, Av, zmean, zmode, zstd, fdist, zminmax, nH, nC, ne, xe, xHp, xCp, tauz
del pf, dd, iha, ihp, ih2, ico, icp, dx, xx, yy, zz
gc.collect()
return dictionary