def load_training_images(type, **kwargs):
if type is 'mnist':
# MNIST dataset (use train and testing images to get more samples)
(images, _), (test_images, _) = mnist.load_data()
images = np.concatenate((images, test_images), axis=0)
if type is 'cifar10':
# CIFAR10 dataset
class_to_train = int(kwargs['class_to_train'])
(images, y_images), (test_images, y_test_images) = cifar10.load_data()
images = images[np.array([item[0]
for item in y_images]) == class_to_train]
test_images = test_images[np.array([item[0]
for item in y_test_images]) == 4]
images = np.concatenate((images, test_images), axis=0)
if type is 'local':
# Local dataset
images = load_data('./pictures')
# Convert RGB values to float values
images = (images.astype(np.float32) - 127.5) / 127.5
# Resize images
images = images.reshape((len(images), 28**2))
return images
def get_tf(rs, xHII, xHeII, dlnz, coarsen_factor=1):
"""
Returns the interpolated transfer functions.
Parameters
----------
rs : float
The current redshift (1+z) to obtain the functions.
xHII : float
The ionization fraction nHII/nH.
xHeII : float
The ionization fraction nHeII/nH.
dlnz : float
The dlnz of the output transfer functions.
coarsen_factor : int
The coarsening factor for the output transfer functions.
Returns
-------
tuple
Contains the high-energy photon, low-energy photon, low-energy
electron, upscattered CMB photon energy and high-energy deposition
transfer functions.
"""
# Load data.
dep_tf_data = load_data('dep_tf')
highengphot_tf_interp = dep_tf_data['highengphot']
lowengphot_tf_interp = dep_tf_data['lowengphot']
lowengelec_tf_interp = dep_tf_data['lowengelec']
highengdep_interp = dep_tf_data['highengdep']
if coarsen_factor > 1:
# rs_to_interpolate = rs
rs_to_interpolate = np.exp(np.log(rs) - dlnz * coarsen_factor / 2)
else:
rs_to_interpolate = rs
highengphot_tf = highengphot_tf_interp.get_tf(xHII, xHeII,
rs_to_interpolate)
lowengphot_tf = lowengphot_tf_interp.get_tf(xHII, xHeII, rs_to_interpolate)
lowengelec_tf = lowengelec_tf_interp.get_tf(xHII, xHeII, rs_to_interpolate)
highengdep_arr = highengdep_interp.get_val(xHII, xHeII, rs_to_interpolate)
if coarsen_factor > 1:
prop_tf = np.zeros_like(highengphot_tf._grid_vals)
for i in np.arange(coarsen_factor):
prop_tf += matrix_power(highengphot_tf._grid_vals, i)
lowengphot_tf._grid_vals = np.matmul(prop_tf, lowengphot_tf._grid_vals)
lowengelec_tf._grid_vals = np.matmul(prop_tf, lowengelec_tf._grid_vals)
highengphot_tf._grid_vals = matrix_power(highengphot_tf._grid_vals,
coarsen_factor)
# cmbloss_arr = np.matmul(prop_tf, cmbloss_arr)/coarsen_factor
highengdep_arr = (np.matmul(prop_tf, highengdep_arr) / coarsen_factor)
return (highengphot_tf, lowengphot_tf, lowengelec_tf, highengdep_arr)
def struct_boost_func(model='einasto_subs', model_params=None):
"""Structure formation boost factor 1+B(z).
Parameters
----------
model : {'einasto_subs', 'einasto_no_subs', 'NFW_subs', 'NFW_no_subs', 'erfc'}
Model to use. See 1604.02457.
model_params : tuple of floats
Model parameters (b_h, delta, z_h) for 'erfc' option.
Returns
-------
float or ndarray
Boost factor.
Notes
-----
Refer to 1408.1109 for erfc model, 1604.02457 for all other model
descriptions and parameters.
"""
if model == 'erfc':
from scipy.special import erfc
if model_params is None:
# Smallest boost in 1408.1109.
b_h = 1.6e5
delta = 1.54
z_h = 19.5
else:
b_h = model_params[0]
delta = model_params[1]
z_h = model_params[2]
def func(rs):
return 1. + b_h / rs**delta * erfc(rs / (1 + z_h))
else:
struct_data = load_data('struct')[model]
log_struct_interp = interp1d(np.log(struct_data[:, 0]),
np.log(struct_data[:, 1]),
bounds_error=False,
fill_value=(np.nan, 0.))
def func(rs):
return np.exp(log_struct_interp(np.log(rs)))
return func
def xHeII_std(rs):
"""Baseline nHeII/nH value.
Parameters
----------
rs : float
The redshift (1+z).
Returns
-------
float
nHeII/nH.
"""
global _xHeII_std
if _xHeII_std is None:
rs_vec = load_data('hist')['rs']
xHeII_vec = load_data('hist')['xHeII']
_xHeII_std = interp1d(rs_vec, xHeII_vec)
return _xHeII_std(rs)
def Tm_std(rs):
"""Baseline Tm value.
Parameters
----------
rs : float
The redshift (1+z).
Returns
-------
float
Tm in eV.
"""
global _Tm_std
if _Tm_std is None:
rs_vec = load_data('hist')['rs']
Tm_vec = load_data('hist')['Tm']
_Tm_std = interp1d(rs_vec, Tm_vec)
return _Tm_std(rs)
def dial_old(root):
if root is None:
dialw = Tk()
else:
dialw = Toplevel(root)
shop_frames = []
srch_entry = Entry(
dialw,
validate="key",
validatecommand=(dialw.register(
lambda x, y, z, t=shop_frames: srch_upd(x, y, z, t)), '%P', '%i',
'%d'))
srch_entry.pack()
# add list of ...
# my shops and their orders
# list of scheduled calls
shops = load_data("shops")
shops_frame = Frame(dialw)
shops_frame.pack()
row = 1
for s in shops:
#print(s[0], s[4])
if s[4] != "Да":
continue
fr = Frame(shops_frame)
shop_label = Label(fr, text=s[0], width=36)
shop_label.pack(side=LEFT, fill=X, expand=True)
ph = normalize_phone(s[1]) or 'Общий'
shop_phone = Button(
fr,
text=ph,
width=15,
command=lambda s=s[0], ph=ph, eid=s[5]: order_window(s, ph, eid))
shop_phone.pack(side=LEFT)
fr.grid(column=0, row=row, sticky=W)
shop_frames.append((fr, s[0], row, ph))
row += 1
srch_entry.focus()
if not root:
dialw.mainloop()
def update_leads_window():
global leads_window
leads_window.leads.delete(0, END)
x = config.load_data("leads")
fields = x.get('keymap')
if not fields:
print("no leads data")
return
data = x.get('list')
print(fields)
leads_window.leadsmap = {}
leads_window.leadskeys = fields
for l1 in data:
print(l1[fields['l_shop_phone']])
print(l1[fields['l_client_phone']])
lead_key = "%s -> %s" % (l1[fields['l_shop_phone']],
l1[fields['l_client_phone']])
leads_window.leadsmap[lead_key] = l1
leads_window.leads.insert(END, lead_key)
return # is there leads to call immediately for this operator
def f_std(mDM,
rs,
inj_particle=None,
inj_type=None,
struct=False,
channel=None):
"""energy deposition fraction into channel c, f_c(z), as a function of dark matter mass and redshift.
Parameters
----------
mDM : float
Dark matter mass
inj_particle : string
Injected particle, either set to 'phot' for photons, or 'elec' for electrons.
inj_type : string
Type of energy injection, either 'swave' or 'decay
struct : bool
If *True*, include structure formation, if *False* assume no structure formation. Default is *False*. This option makes no difference for decays.
"""
if (inj_particle != 'phot') and (inj_particle != 'elec'):
raise ValueError("inj_particle must either be 'phot' or 'elec'")
if (inj_type != 'decay') and (inj_type != 'swave'):
raise ValueError("inj_type must either be 'swave' or 'decay'")
if channel not in ['H ion', 'cont', 'exc', 'heat', 'He ion']:
raise ValueError(
"channel must be in ['H ion', 'He ion', 'exc', 'heat', 'cont']")
if isinstance(mDM, (int, float)):
mDM = np.array([mDM]) * 1.
else:
mDM = np.array(mDM) * 1.
if isinstance(rs, (int, float)):
rs = np.array([rs]) * 1.
else:
rs = np.array(rs) * 1.
struct_str = ''
if inj_type == 'swave':
if inj_particle == 'phot':
Einj = mDM
else:
Einj = mDM - me
if struct:
struct_str = '_struct'
else:
if inj_particle == 'phot':
Einj = mDM / 2
else:
Einj = mDM / 2 - me
ind_dict = {'H ion': 0, 'He ion': 1, 'exc': 2, 'heat': 3, 'cont': 4}
ind = ind_dict[channel]
f_data_baseline = load_data('f')[inj_particle + '_' + inj_type +
struct_str]
Einj[Einj < 5.001e3] = 5.001e3
Einj[Einj > 10**12.6015] = 10**12.6015
if inj_particle != 'phot' or inj_type != 'swave':
rs[rs < 4.017] = 4.017
else:
rs[rs < 5.2] = 5.2
rs[rs > 3000] = 3000
return np.exp(f_data_baseline((np.log10(Einj), np.log(rs)))[:, ind])
FileName = filename,#.replace("#",""),
FilePath = webpath,
page = zipcount,
FileSize = -1)
if force_save:
ind_data.save()
if fext[1:] in configdata["filetypes"]["image_safe_files"] and skippable:
break
#count += 1
# if index_data.objects.values("id").filter(fqpndirectory=webpath.lower(),
# ignore=False).count() != count:
# print("Running Validate")
# validate_database(dir_to_scan)
return webpath.replace(os.sep, r"/")
if __name__ == '__main__':
from config import configdata
import config
cfg_path = os.path.abspath(r"../cfg")
config.load_data(os.path.join(cfg_path, "paths.ini"))
config.load_data(os.path.join(cfg_path, "settings.ini"))
config.load_data(os.path.join(cfg_path, "filetypes.ini"))
import doctest
doctest.testmod()
else:
from frontend.config import configdata
def get_elec_cooling_tf(
eleceng, photeng, rs, xHII, xHeII=0,
raw_thomson_tf=None, raw_rel_tf=None, raw_engloss_tf=None,
coll_ion_sec_elec_specs=None, coll_exc_sec_elec_specs=None,
ics_engloss_data=None,
check_conservation_eng = False, verbose=False
):
"""Transfer functions for complete electron cooling through inverse Compton scattering (ICS) and atomic processes.
Parameters
----------
eleceng : ndarray, shape (m, )
The electron kinetic energy abscissa.
photeng : ndarray
The photon energy abscissa.
rs : float
The redshift (1+z).
xHII : float
Ionized hydrogen fraction, nHII/nH.
xHeII : float, optional
Singly-ionized helium fraction, nHe+/nH. Default is 0.
raw_thomson_tf : TransFuncAtRedshift, optional
Thomson ICS scattered photon spectrum transfer function. If None, uses the default transfer function. Default is None.
raw_rel_tf : TransFuncAtRedshift, optional
Relativistic ICS scattered photon spectrum transfer function. If None, uses the default transfer function. Default is None.
raw_engloss_tf : TransFuncAtRedshift, optional
Thomson ICS scattered electron net energy loss transfer function. If None, uses the default transfer function. Default is None.
coll_ion_sec_elec_specs : tuple of 3 ndarrays, shapes (m, m), optional
Normalized collisional ionization secondary electron spectra, order HI, HeI, HeII, indexed by injected electron energy by outgoing electron energy. If None, the function calculates this. Default is None.
coll_exc_sec_elec_specs : tuple of 3 ndarray, shapes (m, m), optional
Normalized collisional excitation secondary electron spectra, order HI, HeI, HeII, indexed by injected electron energy by outgoing electron energy. If None, the function calculates this. Default is None.
ics_engloss_data : EnglossRebinData
An `EnglossRebinData` object which stores rebinning information (based on ``eleceng`` and ``photeng``) for speed. Default is None.
check_conservation_eng : bool
If True, lower=True, checks for energy conservation. Default is False.
verbose : bool
If True, prints energy conservation checks. Default is False.
Returns
-------
tuple
Transfer functions for electron cooling deposition and spectra.
See Also
---------
:class:`.TransFuncAtRedshift`
:class:`.EnglossRebinData`
:mod:`.ics`
Notes
-----
The entries of the output tuple are (see Sec IIIC of the paper):
0. The secondary propagating photon transfer function :math:`\\overline{\\mathsf{T}}_\\gamma`;
1. The low-energy electron transfer function :math:`\\overline{\\mathsf{T}}_e`;
2. Energy deposited into ionization :math:`\\overline{\\mathbf{R}}_\\text{ion}`;
3. Energy deposited into excitation :math:`\\overline{\\mathbf{R}}_\\text{exc}`;
4. Energy deposited into heating :math:`\\overline{\\mathbf{R}}_\\text{heat}`;
5. Upscattered CMB photon total energy :math:`\\overline{\\mathbf{R}}_\\text{CMB}`, and
6. Numerical error away from energy conservation.
Items 2--5 are vectors that when dotted into an electron spectrum with abscissa ``eleceng``, return the energy deposited/CMB energy upscattered for that spectrum.
Items 0--1 are :class:`.TransFuncAtRedshift` objects. For each of these objects ``tf`` and a given electron spectrum ``elec_spec``, ``tf.sum_specs(elec_spec)`` returns the propagating photon/low-energy electron spectrum after cooling.
The default version of the three ICS transfer functions that are required by this function is provided in :mod:`.tf_data`.
"""
# Use default ICS transfer functions if not specified.
ics_tf = load_data('ics_tf')
raw_thomson_tf = ics_tf['thomson']
raw_rel_tf = ics_tf['rel']
raw_engloss_tf = ics_tf['engloss']
if coll_ion_sec_elec_specs is None:
# Compute the (normalized) collisional ionization spectra.
coll_ion_sec_elec_specs = (
phys.coll_ion_sec_elec_spec(eleceng, eleceng, species='HI'),
phys.coll_ion_sec_elec_spec(eleceng, eleceng, species='HeI'),
phys.coll_ion_sec_elec_spec(eleceng, eleceng, species='HeII')
)
if coll_exc_sec_elec_specs is None:
# Compute the (normalized) collisional excitation spectra.
id_mat = np.identity(eleceng.size)
# Electron with energy eleceng produces a spectrum with one particle
# of energy eleceng - phys.lya.eng. Similar for helium.
coll_exc_sec_elec_tf_HI = tf.TransFuncAtRedshift(
np.squeeze(id_mat[:, np.where(eleceng > phys.lya_eng)]),
in_eng = eleceng, rs = -1*np.ones_like(eleceng),
eng = eleceng[eleceng > phys.lya_eng] - phys.lya_eng,
dlnz = -1, spec_type = 'N'
)
coll_exc_sec_elec_tf_HeI = tf.TransFuncAtRedshift(
np.squeeze(
id_mat[:, np.where(eleceng > phys.He_exc_eng['23s'])]
),
in_eng = eleceng, rs = -1*np.ones_like(eleceng),
eng = (
eleceng[eleceng > phys.He_exc_eng['23s']]
- phys.He_exc_eng['23s']
),
dlnz = -1, spec_type = 'N'
)
coll_exc_sec_elec_tf_HeII = tf.TransFuncAtRedshift(
np.squeeze(id_mat[:, np.where(eleceng > 4*phys.lya_eng)]),
in_eng = eleceng, rs = -1*np.ones_like(eleceng),
eng = eleceng[eleceng > 4*phys.lya_eng] - 4*phys.lya_eng,
dlnz = -1, spec_type = 'N'
)
# Rebin the data so that the spectra stored above now have an abscissa
# of eleceng again (instead of eleceng - phys.lya_eng for HI etc.)
coll_exc_sec_elec_tf_HI.rebin(eleceng)
coll_exc_sec_elec_tf_HeI.rebin(eleceng)
coll_exc_sec_elec_tf_HeII.rebin(eleceng)
# Put them in a tuple.
coll_exc_sec_elec_specs = (
coll_exc_sec_elec_tf_HI.grid_vals,
coll_exc_sec_elec_tf_HeI.grid_vals,
coll_exc_sec_elec_tf_HeII.grid_vals
)
# Set the electron fraction.
xe = xHII + xHeII
# v/c of electrons
beta_ele = np.sqrt(1 - 1/(1 + eleceng/phys.me)**2)
#####################################
# Inverse Compton
#####################################
T = phys.TCMB(rs)
# Photon transfer function for single primary electron single scattering.
# This is dN/(dE dt), dt = 1 s.
phot_ICS_tf = ics_spec(
eleceng, photeng, T, thomson_tf = raw_thomson_tf, rel_tf = raw_rel_tf
)
# Downcasting speeds up np.dot
phot_ICS_tf._grid_vals = phot_ICS_tf.grid_vals.astype('float64')
# Energy loss transfer function for single primary electron
# single scattering. This is dN/(dE dt), dt = 1 s.
engloss_ICS_tf = engloss_spec(
eleceng, photeng, T, thomson_tf = raw_engloss_tf, rel_tf = raw_rel_tf
)
# Downcasting speeds up np.dot
engloss_ICS_tf._grid_vals = engloss_ICS_tf.grid_vals.astype('float64')
# Switch the spectra type here to type 'N'.
if phot_ICS_tf.spec_type == 'dNdE':
phot_ICS_tf.switch_spec_type()
if engloss_ICS_tf.spec_type == 'dNdE':
engloss_ICS_tf.switch_spec_type()
# Define some useful lengths.
N_eleceng = eleceng.size
N_photeng = photeng.size
# Create the secondary electron transfer functions.
# ICS transfer function.
elec_ICS_tf = tf.TransFuncAtRedshift(
np.zeros((N_eleceng, N_eleceng)), in_eng = eleceng,
rs = rs*np.ones_like(eleceng), eng = eleceng,
dlnz = -1, spec_type = 'N'
)
if ics_engloss_data is not None:
elec_ICS_tf._grid_vals = ics_engloss_data.rebin(
engloss_ICS_tf.grid_vals
)
else:
elec_ICS_tf._grid_vals = spectools.engloss_rebin_fast(
eleceng, photeng, engloss_ICS_tf.grid_vals, eleceng
)
# Total upscattered photon energy.
cont_loss_ICS_vec = np.zeros_like(eleceng)
# Deposited energy, enforces energy conservation.
deposited_ICS_vec = np.zeros_like(eleceng)
#########################
# Collisional Excitation
#########################
# Collisional excitation rates.
rate_vec_exc_HI = (
(1 - xHII)*phys.nH*rs**3 * phys.coll_exc_xsec(eleceng, species='HI') * beta_ele * phys.c
)
rate_vec_exc_HeI = (
(phys.nHe/phys.nH - xHeII)*phys.nH*rs**3 * phys.coll_exc_xsec(eleceng, species='HeI') * beta_ele * phys.c
)
rate_vec_exc_HeII = (
xHeII*phys.nH*rs**3 * phys.coll_exc_xsec(eleceng, species='HeII') * beta_ele * phys.c
)
# Normalized electron spectrum after excitation.
elec_exc_HI_tf = tf.TransFuncAtRedshift(
rate_vec_exc_HI[:, np.newaxis]*coll_exc_sec_elec_specs[0],
in_eng = eleceng, rs = rs*np.ones_like(eleceng),
eng = eleceng, dlnz = -1, spec_type = 'N'
)
elec_exc_HeI_tf = tf.TransFuncAtRedshift(
rate_vec_exc_HeI[:, np.newaxis]*coll_exc_sec_elec_specs[1],
in_eng = eleceng, rs = rs*np.ones_like(eleceng),
eng = eleceng, dlnz = -1, spec_type = 'N'
)
elec_exc_HeII_tf = tf.TransFuncAtRedshift(
rate_vec_exc_HeII[:, np.newaxis]*coll_exc_sec_elec_specs[2],
in_eng = eleceng, rs = rs*np.ones_like(eleceng),
eng = eleceng, dlnz = -1, spec_type = 'N'
)
# Deposited energy for excitation.
deposited_exc_vec = np.zeros_like(eleceng)
#########################
# Collisional Ionization
#########################
# Collisional ionization rates.
rate_vec_ion_HI = (
(1 - xHII)*phys.nH*rs**3
* phys.coll_ion_xsec(eleceng, species='HI') * beta_ele * phys.c
)
rate_vec_ion_HeI = (
(phys.nHe/phys.nH - xHeII)*phys.nH*rs**3
* phys.coll_ion_xsec(eleceng, species='HeI') * beta_ele * phys.c
)
rate_vec_ion_HeII = (
xHeII*phys.nH*rs**3
* phys.coll_ion_xsec(eleceng, species='HeII') * beta_ele * phys.c
)
# Normalized secondary electron spectra after ionization.
elec_spec_ion_HI = (
rate_vec_ion_HI[:,np.newaxis] * coll_ion_sec_elec_specs[0]
)
elec_spec_ion_HeI = (
rate_vec_ion_HeI[:,np.newaxis] * coll_ion_sec_elec_specs[1]
)
elec_spec_ion_HeII = (
rate_vec_ion_HeII[:,np.newaxis] * coll_ion_sec_elec_specs[2]
)
# Construct TransFuncAtRedshift objects.
elec_ion_HI_tf = tf.TransFuncAtRedshift(
elec_spec_ion_HI, in_eng = eleceng, rs = rs*np.ones_like(eleceng),
eng = eleceng, dlnz = -1, spec_type = 'N'
)
elec_ion_HeI_tf = tf.TransFuncAtRedshift(
elec_spec_ion_HeI, in_eng = eleceng, rs = rs*np.ones_like(eleceng),
eng = eleceng, dlnz = -1, spec_type = 'N'
)
elec_ion_HeII_tf = tf.TransFuncAtRedshift(
elec_spec_ion_HeII, in_eng = eleceng, rs = rs*np.ones_like(eleceng),
eng = eleceng, dlnz = -1, spec_type = 'N'
)
# Deposited energy for ionization.
deposited_ion_vec = np.zeros_like(eleceng)
#############################################
# Heating
#############################################
dE_heat_dt = phys.elec_heating_engloss_rate(eleceng, xe, rs)
deposited_heat_vec = np.zeros_like(eleceng)
# new_eleceng = eleceng - dE_heat_dt
# if not np.all(new_eleceng[1:] > eleceng[:-1]):
# utils.compare_arr([new_eleceng, eleceng])
# raise ValueError('heating loss is too large: smaller time step required.')
# # After the check above, we can define the spectra by
# # manually assigning slightly less than 1 particle along
# # diagonal, and a small amount in the bin below.
# # N_n-1 E_n-1 + N_n E_n = E_n - dE_dt
# # N_n-1 + N_n = 1
# # therefore, (1 - N_n) E_n-1 - (1 - N_n) E_n = - dE_dt
# # i.e. N_n = 1 + dE_dt/(E_n-1 - E_n)
elec_heat_spec_grid = np.identity(eleceng.size)
elec_heat_spec_grid[0,0] -= dE_heat_dt[0]/eleceng[0]
elec_heat_spec_grid[1:, 1:] += np.diag(
dE_heat_dt[1:]/(eleceng[:-1] - eleceng[1:])
)
elec_heat_spec_grid[1:, :-1] -= np.diag(
dE_heat_dt[1:]/(eleceng[:-1] - eleceng[1:])
)
#############################################
# Initialization of secondary spectra
#############################################
# Low and high energy boundaries
loweng = 3000
eleceng_high = eleceng[eleceng > loweng]
eleceng_high_ind = np.arange(eleceng.size)[eleceng > loweng]
eleceng_low = eleceng[eleceng <= loweng]
eleceng_low_ind = np.arange(eleceng.size)[eleceng <= loweng]
if eleceng_low.size == 0:
raise TypeError('Energy abscissa must contain a low energy bin below 3 keV.')
# Empty containers for quantities.
# Final secondary photon spectrum.
sec_phot_tf = tf.TransFuncAtRedshift(
np.zeros((N_eleceng, N_photeng)), in_eng = eleceng,
rs = rs*np.ones_like(eleceng), eng = photeng,
dlnz = -1, spec_type = 'N'
)
# Final secondary low energy electron spectrum.
sec_lowengelec_tf = tf.TransFuncAtRedshift(
np.zeros((N_eleceng, N_eleceng)), in_eng = eleceng,
rs = rs*np.ones_like(eleceng), eng = eleceng,
dlnz = -1, spec_type = 'N'
)
# Continuum energy loss rate per electron, dU_CMB/dt.
CMB_upscatter_eng_rate = phys.thomson_xsec*phys.c*phys.CMB_eng_density(T)
# Secondary scattered electron spectrum.
sec_elec_spec_N_arr = (
elec_ICS_tf.grid_vals
+ elec_exc_HI_tf.grid_vals
+ elec_exc_HeI_tf.grid_vals
+ elec_exc_HeII_tf.grid_vals
+ elec_ion_HI_tf.grid_vals
+ elec_ion_HeI_tf.grid_vals
+ elec_ion_HeII_tf.grid_vals
+ elec_heat_spec_grid
)
# Secondary photon spectrum (from ICS).
sec_phot_spec_N_arr = phot_ICS_tf.grid_vals
# Deposited ICS array.
deposited_ICS_eng_arr = (
np.sum(elec_ICS_tf.grid_vals, axis=1)*eleceng
- np.dot(elec_ICS_tf.grid_vals, eleceng)
- (np.dot(sec_phot_spec_N_arr, photeng) - CMB_upscatter_eng_rate)
)
# Energy loss is not taken into account for eleceng > 20*phys.me
deposited_ICS_eng_arr[eleceng > 20*phys.me - phys.me] -= (
CMB_upscatter_eng_rate
)
# Continuum energy loss array.
continuum_engloss_arr = CMB_upscatter_eng_rate*np.ones_like(eleceng)
# Energy loss is not taken into account for eleceng > 20*phys.me
continuum_engloss_arr[eleceng > 20*phys.me - phys.me] = 0
# Deposited excitation array.
deposited_exc_eng_arr = (
phys.lya_eng*np.sum(elec_exc_HI_tf.grid_vals, axis=1)
+ phys.He_exc_eng['23s']*np.sum(elec_exc_HeI_tf.grid_vals, axis=1)
+ 4*phys.lya_eng*np.sum(elec_exc_HeII_tf.grid_vals, axis=1)
)
# Deposited ionization array.
deposited_ion_eng_arr = (
phys.rydberg*np.sum(elec_ion_HI_tf.grid_vals, axis=1)/2
+ phys.He_ion_eng*np.sum(elec_ion_HeI_tf.grid_vals, axis=1)/2
+ 4*phys.rydberg*np.sum(elec_ion_HeII_tf.grid_vals, axis=1)/2
)
# Deposited heating array.
deposited_heat_eng_arr = dE_heat_dt
# Remove self-scattering, re-normalize.
np.fill_diagonal(sec_elec_spec_N_arr, 0)
toteng_no_self_scatter_arr = (
np.dot(sec_elec_spec_N_arr, eleceng)
+ np.dot(sec_phot_spec_N_arr, photeng)
- continuum_engloss_arr
+ deposited_ICS_eng_arr
+ deposited_exc_eng_arr
+ deposited_ion_eng_arr
+ deposited_heat_eng_arr
)
fac_arr = eleceng/toteng_no_self_scatter_arr
sec_elec_spec_N_arr *= fac_arr[:, np.newaxis]
sec_phot_spec_N_arr *= fac_arr[:, np.newaxis]
continuum_engloss_arr *= fac_arr
deposited_ICS_eng_arr *= fac_arr
deposited_exc_eng_arr *= fac_arr
deposited_ion_eng_arr *= fac_arr
deposited_heat_eng_arr *= fac_arr
# Zero out deposition/ICS processes below loweng.
deposited_ICS_eng_arr[eleceng < loweng] = 0
deposited_exc_eng_arr[eleceng < loweng] = 0
deposited_ion_eng_arr[eleceng < loweng] = 0
deposited_heat_eng_arr[eleceng < loweng] = 0
continuum_engloss_arr[eleceng < loweng] = 0
sec_phot_spec_N_arr[eleceng < loweng] = 0
# Scattered low energy and high energy electrons.
# Needed for final low energy electron spectra.
sec_lowengelec_N_arr = np.identity(eleceng.size)
sec_lowengelec_N_arr[eleceng >= loweng] = 0
sec_lowengelec_N_arr[eleceng_high_ind[0]:, :eleceng_high_ind[0]] += sec_elec_spec_N_arr[eleceng_high_ind[0]:, :eleceng_high_ind[0]]
sec_highengelec_N_arr = np.zeros_like(sec_elec_spec_N_arr)
sec_highengelec_N_arr[:, eleceng_high_ind[0]:] = (
sec_elec_spec_N_arr[:, eleceng_high_ind[0]:]
)
# T = E.T + Prompt
deposited_ICS_vec = solve_triangular(
np.identity(eleceng.size) - sec_elec_spec_N_arr,
deposited_ICS_eng_arr, lower=True, check_finite=False
)
deposited_exc_vec = solve_triangular(
np.identity(eleceng.size) - sec_elec_spec_N_arr,
deposited_exc_eng_arr, lower=True, check_finite=False
)
deposited_ion_vec = solve_triangular(
np.identity(eleceng.size) - sec_elec_spec_N_arr,
deposited_ion_eng_arr, lower=True, check_finite=False
)
deposited_heat_vec = solve_triangular(
np.identity(eleceng.size) - sec_elec_spec_N_arr,
deposited_heat_eng_arr, lower=True, check_finite=False
)
cont_loss_ICS_vec = solve_triangular(
np.identity(eleceng.size) - sec_elec_spec_N_arr,
continuum_engloss_arr, lower=True, check_finite=False
)
sec_phot_specs = solve_triangular(
np.identity(eleceng.size) - sec_elec_spec_N_arr,
sec_phot_spec_N_arr, lower=True, check_finite=False
)
# Prompt: low energy e produced in secondary spectrum upon scattering (sec_lowengelec_N_arr).
# T : high energy e produced (sec_highengelec_N_arr).
sec_lowengelec_specs = solve_triangular(
np.identity(eleceng.size) - sec_highengelec_N_arr,
sec_lowengelec_N_arr, lower=True, check_finite=False
)
# Subtract continuum from sec_phot_specs. After this point,
# sec_phot_specs will contain the *distortions* to the CMB.
# Normalized CMB spectrum.
norm_CMB_spec = Spectrum(
photeng, phys.CMB_spec(photeng, phys.TCMB(rs)), spec_type='dNdE'
)
norm_CMB_spec /= norm_CMB_spec.toteng()
# Get the CMB spectrum upscattered from cont_loss_ICS_vec.
upscattered_CMB_grid = np.outer(cont_loss_ICS_vec, norm_CMB_spec.N)
# Subtract this spectrum from sec_phot_specs to get the final
# transfer function.
sec_phot_tf._grid_vals = sec_phot_specs - upscattered_CMB_grid
sec_lowengelec_tf._grid_vals = sec_lowengelec_specs
# Conservation checks.
failed_conservation_check = False
if check_conservation_eng:
conservation_check = (
eleceng
- np.dot(sec_lowengelec_tf.grid_vals, eleceng)
# + cont_loss_ICS_vec
- np.dot(sec_phot_tf.grid_vals, photeng)
- deposited_exc_vec
- deposited_ion_vec
- deposited_heat_vec
)
if np.any(np.abs(conservation_check/eleceng) > 0.1):
failed_conservation_check = True
if verbose or failed_conservation_check:
for i,eng in enumerate(eleceng):
print('***************************************************')
print('rs: ', rs)
print('injected energy: ', eng)
print(
'Fraction of Energy in low energy electrons: ',
np.dot(sec_lowengelec_tf.grid_vals[i], eleceng)/eng
)
# print('Energy in photons: ',
# np.dot(sec_phot_tf.grid_vals[i], photeng)
# )
# print('Continuum_engloss: ', cont_loss_ICS_vec[i])
print(
'Fraction of Energy in photons - Continuum: ', (
np.dot(sec_phot_tf.grid_vals[i], photeng)/eng
# - cont_loss_ICS_vec[i]
)
)
print(
'Fraction Deposited in ionization: ',
deposited_ion_vec[i]/eng
)
print(
'Fraction Deposited in excitation: ',
deposited_exc_vec[i]/eng
)
print(
'Fraction Deposited in heating: ',
deposited_heat_vec[i]/eng
)
print(
'Energy is conserved up to (%): ',
conservation_check[i]/eng*100
)
print('Fraction Deposited in ICS (Numerical Error): ',
deposited_ICS_vec[i]/eng
)
print(
'Energy conservation with deposited (%): ',
(conservation_check[i] - deposited_ICS_vec[i])/eng*100
)
print('***************************************************')
if failed_conservation_check:
raise RuntimeError('Conservation of energy failed.')
return (
sec_phot_tf, sec_lowengelec_tf,
deposited_ion_vec, deposited_exc_vec, deposited_heat_vec,
cont_loss_ICS_vec, deposited_ICS_vec
)
_, test_loss = test(NN, X_test, Y_test)
plot_error(epoch, error, test_loss, plt)
print("Training\nAccuracy: %f Loss: %f " % test(NN, X_train, Y_train))
print_images(NN, X_train, Y_train, X_test, Y_test)
def test(NN, X_test, Y_test):
loss = 0
correct = 0
for X, Y in zip(X_test, Y_test):
y = NN.forward(X)
loss += mse(Y, y)
if cf.configuration == 1:
idx = np.argmax(y.flatten())
y = np.zeros((10, 1))
y[idx, 0] = 1
else:
y = (y >= 0.5)
if np.array_equal(Y, y):
correct += 1
else:
pass
return correct / len(X_test) * 100, loss / len(X_test)
if __name__ == '__main__':
NN = NN.model(cf.number_of_layers, cf.lr, cf.layers, cf.activations, bias=bias)
X_train, Y_train, X_test, Y_test = cf.load_data()
train(NN, X_train, Y_train, X_test, Y_test)
accuracy, loss = test(NN, X_test, Y_test)
print("Testing")
print("\tAccuracy: %f%% Loss %f" % (accuracy, loss))
plt.pause(10000)
def load_shops():
print("Dialw: load shops")
shops = load_data("shops")
shops.sort(key=lambda x: x[0].lower())
return shops
from dataset_tricks import f_score
from dataset_tricks import xgboost_feature_selection
from dataset_tricks import cat_to_num
from dataset_tricks import feature_variances
from dataset_tricks import data_binning
from dataset_tricks import reduce_variances
from data_cleaning import countNaNs
from Model import train, validate, predict
from datetime import datetime
beginning = datetime.now()
print("Loading Data...")
#Load the data
train_df = config.load_data(config.TRAIN_DATASET_PATH)
target_df = config.load_data(config.TARGET_DATASET_PATH)
test_df = config.load_data(config.TEST_DATASET_PATH)
# xgboost_features = config.load_data(config.XGBOOST_FEATURE_PATH)
print("Reducing Memory Allocation...")
#Save some memory
train_df = memoryReduce(train_df)
target_df = memoryReduce(target_df)
test_df = memoryReduce(test_df)
# uncomment to check the data types and memory allocations
# train_df.info()
# test_df.info()
# target_df.info()
def load(self):
for s in load_data("shops"):
#print(s)
self.by_phone[s[1]] = self.by_dest[s[3]] = self.by_name[s[0]] = s
self.by_dest = {}
self.by_name = {}
def load(self):
for s in load_data("shops"):
#print(s)
self.by_phone[s[1]] = self.by_dest[s[3]] = self.by_name[s[0]] = s
# name, script, phone
shops = ShopsData()
shops.load()
#print(shops.by_dest); exit()
call_tags = []
for tag_id, tag_name in load_data("tags"):
call_tags.append(tag_name)
#print(call_tags)
#print(dir(root))
#print(root.winfo_screenwidth(), root.winfo_screenheight())
bgthread = threading.Thread(target=bg_task)
bg_run = True
bg_run_showpage = None
bgthread.start()
def init_help_window():
global bg_run, bg_run_showpage
try:
import statsmodels.formula.api as sm
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn import tree
from sklearn.cross_validation import train_test_split
from config import categorical_features, numerical_features
from config import FPlength_dict, Pill_dict, CycleVar_dict, NCbefore_dict, ExitStatus_dict
from config import load_data, encode_all, get_algo_performance
describe_and_plot = 0
#****************************************************************
# Read in and pre-process the input data
data = load_data()
# ***************************************************************
# Explore and visualize the data
if describe_and_plot:
data.describe()
# Print out the statistics for categorical features
for c in categorical_features:
data[c].value_counts()
fig = plt.figure()
data[c].value_counts().plot(kind='bar')
plt.savefig('visualization/general/' + c + '.pdf')
def evolve(in_spec_elec=None,
in_spec_phot=None,
rate_func_N=None,
rate_func_eng=None,
DM_process=None,
mDM=None,
sigmav=None,
lifetime=None,
primary=None,
struct_boost=None,
start_rs=None,
end_rs=4,
helium_TLA=False,
reion_switch=False,
reion_rs=None,
photoion_rate_func=None,
photoheat_rate_func=None,
xe_reion_func=None,
init_cond=None,
coarsen_factor=1,
backreaction=True,
compute_fs_method='no_He',
mxstep=1000,
rtol=1e-4,
use_tqdm=True,
cross_check=False):
"""
Main function computing histories and spectra.
Parameters
-----------
in_spec_elec : :class:`.Spectrum`, optional
Spectrum per injection event into electrons. *in_spec_elec.rs*
of the :class:`.Spectrum` must be the initial redshift.
in_spec_phot : :class:`.Spectrum`, optional
Spectrum per injection event into photons. *in_spec_phot.rs*
of the :class:`.Spectrum` must be the initial redshift.
rate_func_N : function, optional
Function returning number of injection events per volume per time, with redshift :math:`(1+z)` as an input.
rate_func_eng : function, optional
Function returning energy injected per volume per time, with redshift :math:`(1+z)` as an input.
DM_process : {'swave', 'decay'}, optional
Dark matter process to use.
sigmav : float, optional
Thermally averaged cross section for dark matter annihilation.
lifetime : float, optional
Decay lifetime for dark matter decay.
primary : string, optional
Primary channel of annihilation/decay. See :func:`.get_pppc_spec` for complete list. Use *'elec_delta'* or *'phot_delta'* for delta function injections of a pair of photons/an electron-positron pair.
struct_boost : function, optional
Energy injection boost factor due to structure formation.
start_rs : float, optional
Starting redshift :math:`(1+z)` to evolve from. Default is :math:`(1+z)` = 3000. Specify only for use with *DM_process*. Otherwise, initialize *in_spec_elec.rs* and/or *in_spec_phot.rs* directly.
end_rs : float, optional
Final redshift :math:`(1+z)` to evolve to. Default is 1+z = 4.
reion_switch : bool
Reionization model included if *True*, default is *False*.
helium_TLA : bool
If *True*, the TLA is solved with helium. Default is *False*.
reion_rs : float, optional
Redshift :math:`(1+z)` at which reionization effects turn on.
photoion_rate_func : tuple of functions, optional
Functions take redshift :math:`1+z` as input, return the photoionization rate in s\ :sup:`-1` of HI, HeI and HeII respectively. If not specified, defaults to :func:`.photoion_rate`.
photoheat_rate_func : tuple of functions, optional
Functions take redshift :math:`1+z` as input, return the photoheating rate in s\ :sup:`-1` of HI, HeI and HeII respectively. If not specified, defaults to :func:`.photoheat_rate`.
xe_reion_func : function, optional
Specifies a fixed ionization history after reion_rs.
init_cond : tuple of floats
Specifies the initial (xH, xHe, Tm). Defaults to :func:`.Tm_std`, :func:`.xHII_std` and :func:`.xHeII_std` at the *start_rs*.
coarsen_factor : int
Coarsening to apply to the transfer function matrix. Default is 1.
backreaction : bool
If *False*, uses the baseline TLA solution to calculate :math:`f_c(z)`. Default is True.
compute_fs_method : {'no_He', 'He_recomb', 'He'}
mxstep : int, optional
The maximum number of steps allowed for each integration point. See *scipy.integrate.odeint()* for more information. Default is *1000*.
rtol : float, optional
The relative error of the solution. See *scipy.integrate.odeint()* for more information. Default is *1e-4*.
use_tqdm : bool, optional
Uses tqdm if *True*. Default is *True*.
cross_check : bool, optional
If *True*, compare against 1604.02457 by using original MEDEA files, turning off partial binning, etc. Default is *False*.
Examples
--------
1. *Dark matter annihilation* -- dark matter mass of 50 GeV, annihilation cross section :math:`2 \\times 10^{-26}` cm\ :sup:`3` s\ :sup:`-1`, annihilating to :math:`b \\bar{b}`, solved without backreaction, a coarsening factor of 32 and the default structure formation boost: ::
import darkhistory.physics as phys
out = evolve(
DM_process='swave', mDM=50e9, sigmav=2e-26,
primary='b', start_rs=3000.,
backreaction=False,
struct_boost=phys.struct_boost_func()
)
2. *Dark matter decay* -- dark matter mass of 100 GeV, decay lifetime :math:`3 \\times 10^{25}` s, decaying to a pair of :math:`e^+e^-`, solved with backreaction, a coarsening factor of 16: ::
out = evolve(
DM_process='decay', mDM=1e8, lifetime=3e25,
primary='elec_delta', start_rs=3000.,
backreaction=True
)
See Also
---------
:func:`.get_pppc_spec`
:func:`.struct_boost_func`
:func:`.photoion_rate`, :func:`.photoheat_rate`
:func:`.Tm_std`, :func:`.xHII_std` and :func:`.xHeII_std`
"""
#########################################################################
#########################################################################
# Input #
#########################################################################
#########################################################################
#####################################
# Initialization for DM_process #
#####################################
# Load data.
binning = load_data('binning')
photeng = binning['phot']
eleceng = binning['elec']
dep_tf_data = load_data('dep_tf')
highengphot_tf_interp = dep_tf_data['highengphot']
lowengphot_tf_interp = dep_tf_data['lowengphot']
lowengelec_tf_interp = dep_tf_data['lowengelec']
highengdep_interp = dep_tf_data['highengdep']
ics_tf_data = load_data('ics_tf')
ics_thomson_ref_tf = ics_tf_data['thomson']
ics_rel_ref_tf = ics_tf_data['rel']
engloss_ref_tf = ics_tf_data['engloss']
# Handle the case where a DM process is specified.
if DM_process == 'swave':
if sigmav is None or start_rs is None:
raise ValueError('sigmav and start_rs must be specified.')
# Get input spectra from PPPC.
in_spec_elec = pppc.get_pppc_spec(mDM, eleceng, primary, 'elec')
in_spec_phot = pppc.get_pppc_spec(mDM, photeng, primary, 'phot')
# Initialize the input spectrum redshift.
in_spec_elec.rs = start_rs
in_spec_phot.rs = start_rs
# Convert to type 'N'.
in_spec_elec.switch_spec_type('N')
in_spec_phot.switch_spec_type('N')
# If struct_boost is none, just set to 1.
if struct_boost is None:
def struct_boost(rs):
return 1.
# Define the rate functions.
def rate_func_N(rs):
return (phys.inj_rate('swave', rs, mDM=mDM, sigmav=sigmav) *
struct_boost(rs) / (2 * mDM))
def rate_func_eng(rs):
return (phys.inj_rate('swave', rs, mDM=mDM, sigmav=sigmav) *
struct_boost(rs))
if DM_process == 'decay':
if lifetime is None or start_rs is None:
raise ValueError('lifetime and start_rs must be specified.')
# The decay rate is insensitive to structure formation
def struct_boost(rs):
return 1
# Get spectra from PPPC.
in_spec_elec = pppc.get_pppc_spec(mDM,
eleceng,
primary,
'elec',
decay=True)
in_spec_phot = pppc.get_pppc_spec(mDM,
photeng,
primary,
'phot',
decay=True)
# Initialize the input spectrum redshift.
in_spec_elec.rs = start_rs
in_spec_phot.rs = start_rs
# Convert to type 'N'.
in_spec_elec.switch_spec_type('N')
in_spec_phot.switch_spec_type('N')
# Define the rate functions.
def rate_func_N(rs):
return (phys.inj_rate('decay', rs, mDM=mDM, lifetime=lifetime) /
mDM)
def rate_func_eng(rs):
return phys.inj_rate('decay', rs, mDM=mDM, lifetime=lifetime)
#####################################
# Input Checks #
#####################################
if (not np.array_equal(in_spec_elec.eng, eleceng)
or not np.array_equal(in_spec_phot.eng, photeng)):
raise ValueError(
'in_spec_elec and in_spec_phot must use config.photeng and config.eleceng respectively as abscissa.'
)
if (highengphot_tf_interp.dlnz != lowengphot_tf_interp.dlnz
or highengphot_tf_interp.dlnz != lowengelec_tf_interp.dlnz
or lowengphot_tf_interp.dlnz != lowengelec_tf_interp.dlnz):
raise ValueError(
'TransferFuncInterp objects must all have the same dlnz.')
if in_spec_elec.rs != in_spec_phot.rs:
raise ValueError('Input spectra must have the same rs.')
if cross_check:
print(
'cross_check has been set to True -- No longer using all MEDEA files and no longer using partial-binning.'
)
#####################################
# Initialization #
#####################################
# Initialize start_rs for arbitrary injection.
start_rs = in_spec_elec.rs
# Initialize the initial x and Tm.
if init_cond is None:
# Default to baseline
xH_init = phys.xHII_std(start_rs)
xHe_init = phys.xHeII_std(start_rs)
Tm_init = phys.Tm_std(start_rs)
else:
# User-specified.
xH_init = init_cond[0]
xHe_init = init_cond[1]
Tm_init = init_cond[2]
# Initialize redshift/timestep related quantities.
# Default step in the transfer function. Note highengphot_tf_interp.dlnz
# contains 3 different regimes, and we start with the first.
dlnz = highengphot_tf_interp.dlnz[-1]
# The current redshift.
rs = start_rs
# The timestep between evaluations of transfer functions, including
# coarsening.
dt = dlnz * coarsen_factor / phys.hubble(rs)
# tqdm set-up.
if use_tqdm:
from tqdm import tqdm_notebook as tqdm
pbar = tqdm(total=np.ceil((np.log(rs) - np.log(end_rs)) / dlnz /
coarsen_factor))
def norm_fac(rs):
# Normalization to convert from per injection event to
# per baryon per dlnz step.
return rate_func_N(rs) * (dlnz * coarsen_factor / phys.hubble(rs) /
(phys.nB * rs**3))
def rate_func_eng_unclustered(rs):
# The rate excluding structure formation for s-wave annihilation.
# This is the correct normalization for f_c(z).
if struct_boost is not None:
return rate_func_eng(rs) / struct_boost(rs)
else:
return rate_func_eng(rs)
# If there are no electrons, we get a speed up by ignoring them.
elec_processes = False
if in_spec_elec.totN() > 0:
elec_processes = True
if elec_processes:
#####################################
# High-Energy Electrons #
#####################################
# Get the data necessary to compute the electron cooling results.
# coll_ion_sec_elec_specs is \bar{N} for collisional ionization,
# and coll_exc_sec_elec_specs \bar{N} for collisional excitation.
# Heating and others are evaluated in get_elec_cooling_tf
# itself.
# Contains information that makes converting an energy loss spectrum
# to a scattered electron spectrum fast.
(coll_ion_sec_elec_specs, coll_exc_sec_elec_specs,
ics_engloss_data) = get_elec_cooling_data(eleceng, photeng)
#########################################################################
#########################################################################
# Pre-Loop Preliminaries #
#########################################################################
#########################################################################
# Initialize the arrays that will contain x and Tm results.
x_arr = np.array([[xH_init, xHe_init]])
Tm_arr = np.array([Tm_init])
# Initialize Spectra objects to contain all of the output spectra.
out_highengphot_specs = Spectra([], spec_type='N')
out_lowengphot_specs = Spectra([], spec_type='N')
out_lowengelec_specs = Spectra([], spec_type='N')
# Define these methods for speed.
append_highengphot_spec = out_highengphot_specs.append
append_lowengphot_spec = out_lowengphot_specs.append
append_lowengelec_spec = out_lowengelec_specs.append
# Initialize arrays to store f values.
f_low = np.empty((0, 5))
f_high = np.empty((0, 5))
# Initialize array to store high-energy energy deposition rate.
highengdep_grid = np.empty((0, 4))
# Object to help us interpolate over MEDEA results.
MEDEA_interp = make_interpolator(interp_type='2D', cross_check=cross_check)
#########################################################################
#########################################################################
# LOOP! LOOP! LOOP! LOOP! #
#########################################################################
#########################################################################
while rs > end_rs:
# Update tqdm.
if use_tqdm:
pbar.update(1)
#############################
# First Step Special Cases #
#############################
if rs == start_rs:
# Initialize the electron and photon arrays.
# These will carry the spectra produced by applying the
# transfer function at rs to high-energy photons.
highengphot_spec_at_rs = in_spec_phot * 0
lowengphot_spec_at_rs = in_spec_phot * 0
lowengelec_spec_at_rs = in_spec_elec * 0
highengdep_at_rs = np.zeros(4)
#####################################################################
#####################################################################
# Electron Cooling #
#####################################################################
#####################################################################
# Get the transfer functions corresponding to electron cooling.
# These are \bar{T}_\gamma, \bar{T}_e and \bar{R}_c.
if elec_processes:
if backreaction:
xHII_elec_cooling = x_arr[-1, 0]
xHeII_elec_cooling = x_arr[-1, 1]
else:
xHII_elec_cooling = phys.xHII_std(rs)
xHeII_elec_cooling = phys.xHeII_std(rs)
(ics_sec_phot_tf, elec_processes_lowengelec_tf, deposited_ion_arr,
deposited_exc_arr, deposited_heat_arr, continuum_loss,
deposited_ICS_arr) = get_elec_cooling_tf(
eleceng,
photeng,
rs,
xHII_elec_cooling,
xHeII=xHeII_elec_cooling,
raw_thomson_tf=ics_thomson_ref_tf,
raw_rel_tf=ics_rel_ref_tf,
raw_engloss_tf=engloss_ref_tf,
coll_ion_sec_elec_specs=coll_ion_sec_elec_specs,
coll_exc_sec_elec_specs=coll_exc_sec_elec_specs,
ics_engloss_data=ics_engloss_data)
# Apply the transfer function to the input electron spectrum.
# Low energy electrons from electron cooling, per injection event.
elec_processes_lowengelec_spec = (
elec_processes_lowengelec_tf.sum_specs(in_spec_elec))
# Add this to lowengelec_at_rs.
lowengelec_spec_at_rs += (elec_processes_lowengelec_spec *
norm_fac(rs))
# High-energy deposition into ionization,
# *per baryon in this step*.
deposited_ion = np.dot(deposited_ion_arr,
in_spec_elec.N * norm_fac(rs))
# High-energy deposition into excitation,
# *per baryon in this step*.
deposited_exc = np.dot(deposited_exc_arr,
in_spec_elec.N * norm_fac(rs))
# High-energy deposition into heating,
# *per baryon in this step*.
deposited_heat = np.dot(deposited_heat_arr,
in_spec_elec.N * norm_fac(rs))
# High-energy deposition numerical error,
# *per baryon in this step*.
deposited_ICS = np.dot(deposited_ICS_arr,
in_spec_elec.N * norm_fac(rs))
#######################################
# Photons from Injected Electrons #
#######################################
# ICS secondary photon spectrum after electron cooling,
# per injection event.
ics_phot_spec = ics_sec_phot_tf.sum_specs(in_spec_elec)
# Get the spectrum from positron annihilation, per injection event.
# Only half of in_spec_elec is positrons!
positronium_phot_spec = pos.weighted_photon_spec(photeng) * (
in_spec_elec.totN() / 2)
positronium_phot_spec.switch_spec_type('N')
# Add injected photons + photons from injected electrons
# to the photon spectrum that got propagated forward.
if elec_processes:
highengphot_spec_at_rs += (in_spec_phot + ics_phot_spec +
positronium_phot_spec) * norm_fac(rs)
else:
highengphot_spec_at_rs += in_spec_phot * norm_fac(rs)
# Set the redshift correctly.
highengphot_spec_at_rs.rs = rs
#####################################################################
#####################################################################
# Save the Spectra! #
#####################################################################
#####################################################################
# At this point, highengphot_at_rs, lowengphot_at_rs and
# lowengelec_at_rs have been computed for this redshift.
append_highengphot_spec(highengphot_spec_at_rs)
append_lowengphot_spec(lowengphot_spec_at_rs)
append_lowengelec_spec(lowengelec_spec_at_rs)
#####################################################################
#####################################################################
# Compute f_c(z) #
#####################################################################
#####################################################################
if elec_processes:
# High-energy deposition from input electrons.
highengdep_at_rs += np.array([
deposited_ion / dt, deposited_exc / dt, deposited_heat / dt,
deposited_ICS / dt
])
# Values of (xHI, xHeI, xHeII) to use for computing f.
if backreaction:
# Use the previous values with backreaction.
x_vec_for_f = np.array(
[1. - x_arr[-1, 0], phys.chi - x_arr[-1, 1], x_arr[-1, 1]])
else:
# Use baseline values if no backreaction.
x_vec_for_f = np.array([
1. - phys.xHII_std(rs), phys.chi - phys.xHeII_std(rs),
phys.xHeII_std(rs)
])
f_raw = compute_fs(MEDEA_interp,
lowengelec_spec_at_rs,
lowengphot_spec_at_rs,
x_vec_for_f,
rate_func_eng_unclustered(rs),
dt,
highengdep_at_rs,
method=compute_fs_method,
cross_check=cross_check)
# Save the f_c(z) values.
f_low = np.concatenate((f_low, [f_raw[0]]))
f_high = np.concatenate((f_high, [f_raw[1]]))
# print(f_low, f_high)
# Save CMB upscattered rate and high-energy deposition rate.
highengdep_grid = np.concatenate((highengdep_grid, [highengdep_at_rs]))
# Compute f for TLA: sum of low and high.
f_H_ion = f_raw[0][0] + f_raw[1][0]
f_exc = f_raw[0][2] + f_raw[1][2]
f_heat = f_raw[0][3] + f_raw[1][3]
if compute_fs_method == 'old':
# The old method neglects helium.
f_He_ion = 0.
else:
f_He_ion = f_raw[0][1] + f_raw[1][1]
#####################################################################
#####################################################################
# ********* AFTER THIS, COMPUTE QUANTITIES FOR NEXT STEP ********* #
#####################################################################
#####################################################################
# Define the next redshift step.
next_rs = np.exp(np.log(rs) - dlnz * coarsen_factor)
#####################################################################
#####################################################################
# TLA Integration #
#####################################################################
#####################################################################
# Initial conditions for the TLA, (Tm, xHII, xHeII, xHeIII).
# This is simply the last set of these variables.
init_cond_TLA = np.array([Tm_arr[-1], x_arr[-1, 0], x_arr[-1, 1], 0])
# Solve the TLA for x, Tm for the *next* step.
new_vals = tla.get_history(np.array([rs, next_rs]),
init_cond=init_cond_TLA,
f_H_ion=f_H_ion,
f_H_exc=f_exc,
f_heating=f_heat,
injection_rate=rate_func_eng_unclustered,
reion_switch=reion_switch,
reion_rs=reion_rs,
photoion_rate_func=photoion_rate_func,
photoheat_rate_func=photoheat_rate_func,
xe_reion_func=xe_reion_func,
helium_TLA=helium_TLA,
f_He_ion=f_He_ion,
mxstep=mxstep,
rtol=rtol)
#####################################################################
#####################################################################
# Photon Cooling Transfer Functions #
#####################################################################
#####################################################################
# Get the transfer functions for this step.
if not backreaction:
# Interpolate using the baseline solution.
xHII_to_interp = phys.xHII_std(rs)
xHeII_to_interp = phys.xHeII_std(rs)
else:
# Interpolate using the current xHII, xHeII values.
xHII_to_interp = x_arr[-1, 0]
xHeII_to_interp = x_arr[-1, 1]
highengphot_tf, lowengphot_tf, lowengelec_tf, highengdep_arr = (get_tf(
rs,
xHII_to_interp,
xHeII_to_interp,
dlnz,
coarsen_factor=coarsen_factor))
# Get the spectra for the next step by applying the
# transfer functions.
highengdep_at_rs = np.dot(np.swapaxes(highengdep_arr, 0, 1),
out_highengphot_specs[-1].N)
highengphot_spec_at_rs = highengphot_tf.sum_specs(
out_highengphot_specs[-1])
lowengphot_spec_at_rs = lowengphot_tf.sum_specs(
out_highengphot_specs[-1])
lowengelec_spec_at_rs = lowengelec_tf.sum_specs(
out_highengphot_specs[-1])
highengphot_spec_at_rs.rs = next_rs
lowengphot_spec_at_rs.rs = next_rs
lowengelec_spec_at_rs.rs = next_rs
if next_rs > end_rs:
# Only save if next_rs < end_rs, since these are the x, Tm
# values for the next redshift.
# Save the x, Tm data for the next step in x_arr and Tm_arr.
Tm_arr = np.append(Tm_arr, new_vals[-1, 0])
if helium_TLA:
# Append the calculated xHe to x_arr.
x_arr = np.append(x_arr, [[new_vals[-1, 1], new_vals[-1, 2]]],
axis=0)
else:
# Append the baseline solution value.
x_arr = np.append(x_arr,
[[new_vals[-1, 1],
phys.xHeII_std(next_rs)]],
axis=0)
# Re-define existing variables.
rs = next_rs
dt = dlnz * coarsen_factor / phys.hubble(rs)
#########################################################################
#########################################################################
# END OF LOOP! END OF LOOP! #
#########################################################################
#########################################################################
if use_tqdm:
pbar.close()
f_to_return = (f_low, f_high)
# Some processing to get the data into presentable shape.
f_low_dict = {
'H ion': f_low[:, 0],
'He ion': f_low[:, 1],
'exc': f_low[:, 2],
'heat': f_low[:, 3],
'cont': f_low[:, 4]
}
f_high_dict = {
'H ion': f_high[:, 0],
'He ion': f_high[:, 1],
'exc': f_high[:, 2],
'heat': f_high[:, 3],
'cont': f_high[:, 4]
}
f = {'low': f_low_dict, 'high': f_high_dict}
data = {
'rs': out_highengphot_specs.rs,
'x': x_arr,
'Tm': Tm_arr,
'highengphot': out_highengphot_specs,
'lowengphot': out_lowengphot_specs,
'lowengelec': out_lowengelec_specs,
'f': f
}
return data
def get_pppc_spec(mDM, eng, pri, sec, decay=False):
""" Returns the PPPC4DMID spectrum.
This is the secondary spectrum to e+e-/photons normalized to one annihilation or decay event to the species specified in ``pri``. These results include electroweak corrections. The full list of allowed channels is:
- :math:`\\delta`\ -function injections: ``elec_delta, phot_delta``
- Leptons: ``e_L, e_R, e, mu_L, mu_R, mu, tau_L, tau_R, tau``
- Quarks: ``q, c, b, t``
- Gauge bosons: ``gamma, g, W_L, W_T, W, Z_L, Z_T, Z``
- Higgs: ``h``
``elec_delta`` and ``phot_delta`` assumes annihilation or decay to two electrons and photons respectively with no EW corrections or ISR/FSR.
Variables with subscripts, e.g. ``e_L``, correspond to particles with different polarizations. These polarizations are suitably averaged to obtain the spectra returned in their corresponding variables without subscripts, e.g. ``e``.
Parameters
----------
mDM : float
The mass of the annihilating/decaying dark matter particle (in eV).
eng : ndarray
The energy abscissa for the output spectrum (in eV).
pri : string
One of the available channels (see above).
sec : {'elec', 'phot'}
The secondary spectrum to obtain.
decay : bool, optional
If ``True``, returns the result for decays.
Returns
-------
Spectrum
Output :class:`.Spectrum` object, ``spec_type == 'dNdE'``.
"""
if decay:
# Primary energies is for 1 GeV decay = 0.5 GeV annihilation.
_mDM = mDM / 2.
else:
_mDM = mDM
if _mDM < mass_threshold[pri]:
# This avoids the absurd situation where mDM is less than the
# threshold but we get a nonzero spectrum due to interpolation.
raise ValueError(
'mDM is below the threshold to produce pri particles.')
if pri == 'elec_delta':
# Exact kinetic energy of each electron.
if not decay:
eng_elec = mDM - phys.me
else:
eng_elec = (mDM - 2 * phys.me) / 2
# Find the correct bin in eleceng.
eng_to_inj = eng[eng < eng_elec][-1]
# Place 2*eng_elec worth of electrons into that bin. Use
# rebinning to accomplish this.
if sec == 'elec':
return rebin_N_arr(np.array([2 * eng_elec / eng_to_inj]),
np.array([eng_to_inj]), eng)
elif sec == 'phot':
return Spectrum(eng, np.zeros_like(eng), spec_type='dNdE')
else:
raise ValueError('invalid sec.')
if pri == 'phot_delta':
# Exact kinetic energy of each photon.
if not decay:
eng_phot = mDM
else:
eng_phot = mDM / 2
# Find the correct bin in photeng.
eng_to_inj = eng[eng < eng_phot][-1]
# Place 2*eng_phot worth of photons into that bin. Use
# rebinning to accomplish this.
if sec == 'elec':
return Spectrum(eng, np.zeros_like(eng), spec_type='dNdE')
elif sec == 'phot':
return rebin_N_arr(np.array([2 * eng_phot / eng_to_inj]),
np.array([eng_to_inj]), eng)
else:
raise ValueError('invalid sec.')
log10x = np.log10(eng / _mDM)
# Refine the binning so that the spectrum is accurate.
# Do this by checking that in the relevant range, there are at
# least 50,000 bins. If not, double (unless an absurd number
# of bins already).
if (log10x[(log10x < 1) & (log10x > 1e-9)].size > 0
and log10x.size < 500000):
while log10x[(log10x < 1) & (log10x > 1e-9)].size < 50000:
log10x = np.interp(np.arange(0, log10x.size - 0.5, 0.5),
np.arange(log10x.size), log10x)
# Get the interpolator.
dlNdlxIEW_interp = load_data('pppc')
# Get the spectrum from the interpolator.
dN_dlog10x = 10**dlNdlxIEW_interp[sec][pri].get_val(_mDM / 1e9, log10x)
# Recall that dN/dE = dN/dlog10x * dlog10x/dE
x = 10**log10x
spec = Spectrum(x * _mDM,
dN_dlog10x / (x * _mDM * np.log(10)),
spec_type='dNdE')
# Rebin down to the original binning.
# The highest bin of spec.eng should be the same as eng[-1], based on
# the interpolation strategy above. However, sometimes a floating point
# error is picked up. We'll get rid of this so that rebin doesn't
# complain.
spec.eng[-1] = eng[-1]
spec.rebin(eng)
return spec
