def load_stars(snapnum, snapfile):
"""
Parameters
----------
snapnum : int
snapshot number of simulation
snapfile : str
path to snapshot directory
Returns
-------
indx : np.array
"""
s = read_hdf5.snapshot(snapnum, snapfile)
s.read([
"Coordinates", "Masses", "Velocities", "GFM_StellarFormationTime",
"GFM_StellarPhotometrics"
],
parttype=[4])
age = (s.data['GFM_StellarFormationTime']['stars']).astype('float64')
star_pos = s.data['Coordinates']['stars'][age >= 0, :]
star_vel = s.data['Velocities']['stars'][age >= 0, :]
star_mass = s.data['Masses']['stars'][age >= 0] #[Msol]
star_mag = s.data['GFM_StellarPhotometrics']['stars'][age >=
0] #[Bol. Mag]
star = {
'Pos': star_pos,
'Vel': star_vel,
'Mass': star_mass,
'Mag': star_mag,
}
return star
def load_snapshot(self, snapnum, hfdir):
"""
Load data of subhalos and particles
"""
self.snapshot = read_hdf5_eagle.snapshot(snapnum, part_file)
# Subhalos
if self.halofinder == 'Rockstar':
df = pd.read_csv(args["rksdir"] + 'halos_%d.dat' % snapnum,
sep='\s+',
skiprows=np.arange(1, 16))
df = df.sort_values(by=['#ID'])
df = df.set_index('#ID')
subhalo = hdata.loc[hdata['#ID'] == HFID]
HPos = subhalo[['X', 'Y', 'Z']].values[0]
Vrms = subhalo['Vrms'].values[0]
M200 = subhalo['Mvir'].values[0]
hvel = subhalo[['VX', 'VY', 'VZ']].values[0]
epva = subhalo[['A[x]', 'A[y]', 'A[z]']].values[0]
epvb = subhalo[['B[x]', 'B[y]', 'B[z]']].values[0]
epvc = subhalo[['C[x]', 'C[y]', 'C[z]']].values[0]
elif self.halofinder == 'Subfind':
s = read_hdf5.snapshot(snapnum, hfdir)
s.group_catalog([
"SubhaloIDMostbound", "SubhaloPos", "SubhaloVel",
"SubhaloMass", "SubhaloVelDisp", "SubhaloHalfmassRadType",
"SubhaloLenType"
])
df = pd.DataFrame({
'HF_ID':
self.snapshot.cat['SubhaloIDMostbound'],
'Vrms': (s.cat['SubhaloVelDisp']),
'Mass':
s.cat['SubhaloMass'],
'Npart': (self.snapshot.cat["SubhaloLenType"][:, 4])
})
subhalo_offset = (np.cumsum(df['Npart'].values) - \
df['Npart'].values).astype(int)
df['offset'] = pd.Series(subhalo_offset,
index=dfpart.index,
dtype=int)
s1 = pd.Series(dict(
list(
enumerate(s.cat['SubhaloPos'] *
self.snapshot.header.hubble * 1e-3))),
index=df.index)
df['Pos'] = s1
s1 = pd.Series(dict(list(enumerate(s.cat['SubhaloVel']))),
index=dmdf.index)
df['Vel'] = s1
df = df.sort_values(by=['HF_ID'])
df = df.set_index('HF_ID')
indx = self.df.index.intersection(df.index)
self.df["M200"]
def load_dm(snapnum, snapfile):
s = read_hdf5.snapshot(snapnum, snapfile)
s.read([
"Coordinates",
"Masses",
], parttype=[1])
dm_pos = s.data['Coordinates']['dm']
dm_mass = s.data['Masses']['dm'] #[Msol]
dm = {'Pos': dm_pos, 'Mass': dm_mass}
return dm
def __init__(self, h5_dir: str, snapnum: int):
'''
Args:
h5_dir: directory containing tng data
snapnum: Snapshot number to read
'''
self.snapnum = snapnum
self.snapshot = read_hdf5.snapshot(snapnum, h5_dir)
# Useful definitions
self.dm = 1
self.stars = 4
self.dm_particle_mass = self.snapshot.header.massarr[self.dm] * 1.0e10
self.output_dir = '/cosma6/data/dp004/dc-cues1/tng_dataframes/'
def load_gas(snapnum, snapfile):
"""
Parameters
----------
snapnum : int
snapshot number of simulation
snapfile : str
path to snapshot directory
Returns
-------
indx : np.array
"""
s = read_hdf5.snapshot(snapnum, snapfile)
s.read([
"Coordinates",
"Masses",
], parttype=[0])
gas = {
'Pos': s.data['Coordinates']['gas'],
'Mass': s.data['Masses']['gas'],
}
return gas
def load_subhalos(snapnum, snapfile, lafile, strong_lensing=1):
"""
Parameters
----------
snapnum : int
snapshot number of simulation
snapfile : str
path to snapshot directory
lafile : str
path to lensing analysis results
subhalo_tag : boolean
switch to ouput all subhalo acting as
strong lenses or not
Returns
-------
df : pd.DataFrame
"""
# load snapshot data
s = read_hdf5.snapshot(snapnum, snapfile)
s.group_catalog([
"SubhaloIDMostbound", "SubhaloPos", "SubhaloVel", "SubhaloMass",
"SubhaloVelDisp", "SubhaloHalfmassRadType", "SubhaloLenType",
"GroupLenType", "GroupNsubs", "GroupFirstSub"
])
df = pd.DataFrame({
'HF_ID': s.cat['SubhaloIDMostbound'],
'Vrms': s.cat['SubhaloVelDisp'],
'Mass': s.cat['SubhaloMass'],
'Rstellarhalfmass': s.cat['SubhaloHalfmassRadType'][:, 4],
'sNpart': s.cat["SubhaloLenType"][:, 4].astype('int'),
'dmNpart': s.cat["SubhaloLenType"][:, 1].astype('int')
})
s1 = pd.Series(dict(list(enumerate(s.cat['SubhaloPos']))), index=df.index)
df['Pos'] = s1
s1 = pd.Series(dict(list(enumerate(s.cat['SubhaloVel']))), index=df.index)
df['Vel'] = s1
df['Index'] = df.index.values
df = df.sort_values(by=['HF_ID'])
df = df.set_index('HF_ID')
if strong_lensing == True:
LA = pickle.load(open(lafile, "rb")) #, encoding='latin1')
print('Processing the following file: \n %s' % (lafile))
print('which contains %d lenses' % len(LA['HF_ID'][:]))
print('with max. einst. radius: %f', np.max(LA['Sources']['Rein'][:]))
# Output only subhalos acting as gravitational strong lenses
# Find intersection
ladf = pd.DataFrame({
'HF_ID': LA["HF_ID"],
'ZS': LA["zs"],
'FOV': LA["FOV"],
'Rein': LA["Sources"]["Rein"],
})
ladf['Nimg'] = pd.Series(0, index=ladf.index)
ladf['theta'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['delta_t'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['mu'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['TCC'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['DMAP'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
for ll in range(len(ladf.index.values)):
ladf['Nimg'][ll] = len(LA['Sources']['mu'][ll])
ladf['theta'][ll] = LA['Sources']['theta'][ll]
ladf['delta_t'][ll] = LA['Sources']['delta_t'][ll]
ladf['mu'][ll] = LA['Sources']['mu'][ll]
ladf['TCC'][ll] = LA['Sources']['TCC'][ll]
ladf['DMAP'][ll] = LA['DMAP'][ll]
ladf = ladf.sort_values(by=['HF_ID'])
ladf = ladf.set_index('HF_ID') # may contain dublicates
#df = df[df.index.isin(ladf.index.values)]
# Attach df to ladf
ladf = ladf.join(df, how='inner')
ladf['ZL'] = pd.Series(s.header.redshift, index=ladf.index)
#df['Rein'] = ladf['Rein']
#df['ZS'] = ladf['ZS']
#df['Nimg'] = ladf['Nimg']
#df['FOV'] = ladf['FOV']
#df['theta'] = ladf['theta']
#df['delta_t'] = ladf['delta_t']
#df['mu'] = ladf['mu']
#df['DMAP'] = ladf['DMAP']
# Find bound particles for lenses
BPF = BoundParticleFinder(s)
subhalo_particles = BPF.find_bound_subhalo_particles(
ladf['Index'].values, 4)
ladf['BPF'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
for ll in range(len(ladf.index.values)):
ladf['BPF'][ll] = subhalo_particles[ll].astype(int)
# Initialize
ladf['Mlens'] = pd.Series(0, index=ladf.index)
elif strong_lensing == False:
ladf = pd.read_hdf(lafile, key='nonlenses')
ladf = ladf.sort_values(by=['HF_ID'])
ladf = ladf.set_index('HF_ID')
print('Processing the following file: \n %s' % (lafile))
print('which contains %d subhalos' % len(ladf.index.values))
# Output only subhalos do not act as gravitational strong lenses
# Attach df to ladf
ladf = ladf.rename(columns={'zl': 'ZL'})
ladf = ladf.rename(columns={'zs': 'ZS'})
ladf = ladf.join(df, how='inner')
# Initialize
ladf['Mdyn'] = pd.Series(0, index=ladf.index)
ladf['Mtotal'] = pd.Series(0, index=ladf.index)
ladf['Vrms_Rein'] = pd.Series(0, index=ladf.index)
ladf['Vrms_Rhm'] = pd.Series(0, index=ladf.index)
ladf['PA'] = pd.Series(0.0, dtype=np.float, index=ladf.index)
ladf['Ellip2D'] = pd.Series(0.0, dtype=np.float, index=ladf.index)
ladf['Eccen2D'] = pd.Series(0.0, dtype=np.float, index=ladf.index)
ladf['Ellip3D'] = pd.Series(0.0, dtype=np.float, index=ladf.index)
ladf['Eccen3D'] = pd.Series(0.0, dtype=np.float, index=ladf.index)
ladf['Prolat3D'] = pd.Series(0.0, dtype=np.float, index=ladf.index)
ladf['VelProfRad'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['VelProfMeas'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['VrmsProfRad'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['VrmsProfMeas'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['SDensProfRad'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['SDensProfMeas'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['SMProfRad'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['SMProfMeas'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['SCVProfRad'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['SCVProfMeas'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['DMDensProfRad'] = pd.Series(0, index=df.index).astype(np.ndarray)
ladf['DMDensProfMeas'] = pd.Series(0, index=df.index).astype(np.ndarray)
ladf['GDensProfRad'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['GDensProfMeas'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['power_law_index'] = pd.Series(0, index=ladf.index).astype(np.ndarray)
ladf['power_law_profile'] = pd.Series(0,
index=ladf.index).astype(np.ndarray)
#df['DMMProfRad'] = pd.Series(0, index=df.index).astype(np.ndarray)
#df['DMMProfMeas'] = pd.Series(0, index=df.index).astype(np.ndarray)
#df['DMCVProfRad'] = pd.Series(0, index=df.index).astype(np.ndarray)
#df['DMCVProfMeas'] = pd.Series(0, index=df.index).astype(np.ndarray)
return ladf
def create_density_maps():
# Get command line arguments
args = {}
if comm_rank == 0:
print(':Registered %d processes' % comm_size)
args["simdir"] = sys.argv[1]
args["hfdir"] = sys.argv[2]
args["lcdir"] = sys.argv[3]
args["ncells"] = int(sys.argv[4])
args["outbase"] = sys.argv[5]
args = comm.bcast(args)
label = args["simdir"].split('/')[-2].split('_')[2]
# Organize devision of Sub-&Halos over Processes on Proc. 0
if comm_rank == 0:
# Characteristics
hflabel = whichhalofinder(args["lcdir"])
# Load LightCone Contents
lchdf = h5py.File(args["lcdir"], 'r')
lcdfhalo = pd.DataFrame(
{'HF_ID' : lchdf['Halo_Rockstar_ID'].value,
'ID' : lchdf['Halo_ID'].value,
'Halo_z' : lchdf['Halo_z'].value,
'snapnum' : lchdf['snapnum'].value,
#'Vrms' : lchdf['VelDisp'].value,
#'fov_Mpc' : lchdf['FOV'][:, 1],
('HaloPosBox', 'X') : lchdf['HaloPosBox'][:, 0],
('HaloPosBox', 'Y') : lchdf['HaloPosBox'][:, 1],
('HaloPosBox', 'Z') : lchdf['HaloPosBox'][:, 2],})
nhalo_per_snapshot = lcdfhalo.groupby('snapnum').count()['HF_ID']
print('Number of Sub-&Halos in Snapshot:')
print(nhalo_per_snapshot.values)
print(np.sum(nhalo_per_snapshot.values))
print(nhalo_per_snapshot.index.values)
print(nhalo_per_snapshot.values[0])
if nhalo_per_snapshot.values[0] > comm_size:
hist_edges = procdiv.histedges_equalN(lcdfhalo[('HaloPosBox', 'X')],
comm_size)
SH = procdiv.cluster_subhalos(lcdfhalo['ID'].values,
#lcdfhalo['Vrms'],
#lcdfhalo['fov_Mpc'],
lcdfhalo[('HaloPosBox', 'X')].values,
lcdfhalo[('HaloPosBox', 'X')].values,
lcdfhalo[('HaloPosBox', 'Y')].values,
lcdfhalo[('HaloPosBox', 'Z')].values,
hist_edges, comm_size)
print('dict test', SH.keys())
elif nhalo_per_snapshot.values[0] < comm_size:
pass
# Define Cosmology
cosmo = LambdaCDM(H0=s.header.hubble*100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
cosmosim = {'omega_M_0' : s.header.omega_m,
'omega_lambda_0' : s.header.omega_l,
'omega_k_0' : 0.0,
'h' : s.header.hubble}
redshift = s.header.redshift
print(': Redshift: %f' % redshift)
# Sort Sub-&Halos over Processes
df = pd.read_csv(args["hfdir"]+'halos_%d.dat' % args["snapnum"],
sep='\s+', skiprows=16,
usecols=[0, 2, 4, 9, 10, 11],
names=['ID', 'Mvir', 'Vrms', 'X', 'Y', 'Z'])
df = df[df['Mvir'] > 5e11]
sh_id = df['ID'].values.astype('float64')
sh_vrms = df['Vrms'].values.astype('float64')
sh_x = df['X'].values.astype('float64')
sh_y = df['Y'].values.astype('float64')
sh_z = df['Z'].values.astype('float64')
del df
hist_edges = procdiv.histedges_equalN(sh_x, comm_size)
SH = cluster_subhalos(sh_id, sh_vrms, sh_x, sh_y, sh_z, hist_edges, comm_size)
# Load simulation
s = read_hdf5.snapshot(45, args["simdir"])
s.read(["Coordinates", "Masses", "GFM_StellarFormationTime"],
parttype=[0, 1, 4])
scale = 1e-3*s.header.hubble
# Calculate overlap for particle cuboids
c = (const.c).to_value('km/s')
fov_rad = 4*np.pi*(np.percentile(sh_vrms, 90)/c)**2
sh_dist = (cosmo.comoving_distance(redshift)).to_value('Mpc')
alpha = 6 # multiplied by 4 because of Oguri&Marshall
overlap = 0.5*alpha*fov_rad*sh_dist #[Mpc] half of field-of-view
print('Cuboids overlap is: %f [Mpc]' % overlap)
# Sort Particles over Processes
## Dark Matter
dm_mass = (s.data['Masses']['dm']).astype('float64')
dm_x = (s.data['Coordinates']['dm'][:, 0]*scale).astype('float64')
dm_y = (s.data['Coordinates']['dm'][:, 1]*scale).astype('float64')
dm_z = (s.data['Coordinates']['dm'][:, 2]*scale).astype('float64')
dm_mass, dm_x, dm_y, dm_z, dm_split_size_1d, dm_split_disp_1d = cluster_particles(
dm_mass, dm_x, dm_y, dm_z, hist_edges, comm_size)
## Gas
gas_mass = (s.data['Masses']['gas']).astype('float64')
gas_x = (s.data['Coordinates']['gas'][:, 0]*scale).astype('float64')
gas_y = (s.data['Coordinates']['gas'][:, 1]*scale).astype('float64')
gas_z = (s.data['Coordinates']['gas'][:, 2]*scale).astype('float64')
gas_mass, gas_x, gas_y, gas_z, gas_split_size_1d, gas_split_disp_1d = cluster_particles(gas_mass, gas_x, gas_y, gas_z, hist_edges, comm_size)
## Stars
star_mass = (s.data['Masses']['stars']).astype('float64')
star_x = (s.data['Coordinates']['stars'][:, 0]*scale).astype('float64')
star_y = (s.data['Coordinates']['stars'][:, 1]*scale).astype('float64')
star_z = (s.data['Coordinates']['stars'][:, 2]*scale).astype('float64')
star_age = s.data['GFM_StellarFormationTime']['stars']
star_x = star_x[star_age >= 0] #[Mpc]
star_y = star_y[star_age >= 0] #[Mpc]
star_z = star_z[star_age >= 0] #[Mpc]
star_mass = star_mass[star_age >= 0]
del star_age
star_mass, star_x, star_y, star_z, star_split_size_1d, star_split_disp_1d = cluster_particles(star_mass, star_x, star_y, star_z, hist_edges, comm_size)
else:
c=None; alpha=None; overlap=None
cosmosim=None; cosmo=None; redshift=None; hist_edges=None;
SH=None;
dm_mass=None; dm_x=None; dm_y=None; dm_z=None
dm_split_size_1d=None; dm_split_disp_1d=None
gas_mass=None; gas_x=None; gas_y=None; gas_z=None
gas_split_size_1d=None; gas_split_disp_1d=None
star_mass=None; star_x=None; star_y=None; star_z=None
star_split_size_1d=None; star_split_disp_1d=None
# Broadcast variables over all processors
sh_split_size_1d = comm.bcast(SH['sh_split_size_1d'], root=0)
sh_split_disp_1d = comm.bcast(SH['sh_split_disp_1d'], root=0)
dm_split_size_1d = comm.bcast(dm_split_size_1d, root=0)
dm_split_disp_1d = comm.bcast(dm_split_disp_1d, root=0)
gas_split_size_1d = comm.bcast(gas_split_size_1d, root=0)
gas_split_disp_1d = comm.bcast(gas_split_disp_1d, root=0)
star_split_size_1d = comm.bcast(star_split_size_1d, root=0)
star_split_disp_1d = comm.bcast(star_split_disp_1d, root=0)
c = comm.bcast(c, root=0)
alpha = comm.bcast(alpha, root=0)
overlap = comm.bcast(overlap, root=0)
cosmo = comm.bcast(cosmo, root=0)
redshift = comm.bcast(redshift, root=0)
hist_edges = comm.bcast(hist_edges, root=0)
# Initiliaze variables for each processor
sh_id_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_vrms_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_x_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_y_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_z_local = np.zeros((int(sh_split_size_1d[comm_rank])))
dm_mass_local = np.zeros((int(dm_split_size_1d[comm_rank])))
dm_x_local = np.zeros((int(dm_split_size_1d[comm_rank])))
dm_y_local = np.zeros((int(dm_split_size_1d[comm_rank])))
dm_z_local = np.zeros((int(dm_split_size_1d[comm_rank])))
gas_mass_local = np.zeros((int(gas_split_size_1d[comm_rank])))
gas_x_local = np.zeros((int(gas_split_size_1d[comm_rank])))
gas_y_local = np.zeros((int(gas_split_size_1d[comm_rank])))
gas_z_local = np.zeros((int(gas_split_size_1d[comm_rank])))
star_mass_local = np.zeros((int(star_split_size_1d[comm_rank])))
star_x_local = np.zeros((int(star_split_size_1d[comm_rank])))
star_y_local = np.zeros((int(star_split_size_1d[comm_rank])))
star_z_local = np.zeros((int(star_split_size_1d[comm_rank])))
def __init__(
self,
overdensity,
h5_dir="/cosma7/data/TNG/TNG300-1-Dark/",
snapshot_number=99
):
"""
Load data of particles that belong to resolved halos
Args:
overdensity: int
Out to which radius halo properties are measured.
R200 - default SubFind radii
R2500 - where galaxy formation takes place
h5_dir: str
path to particle data
snapshot_number: int
"""
self.snapshot = read_hdf5.snapshot(
snapshot_number, h5_dir, check_total_particle_number=True
)
# read simulation settings
self.h = self.snapshot.header.hubble
# read subfind & fof data
self.snapshot.group_catalog(
[
"Group_M_Crit200",
"Group_R_Crit200",
"GroupLenType",
"GroupFirstSub",
"GroupPos",
"GroupVel",
"SubhaloVmax",
]
)
# associate particles to subfind & fof objects
self.N_particles = self.snapshot.cat['GroupLenType'][:,1].astype(np.int64)
self.firstsub = (self.snapshot.cat['GroupFirstSub']).astype(np.int64)
self.cum_N_particles= np.cumsum(self.N_particles) - self.N_particles
self.ID_DMO = np.arange(0, len(self.N_particles))
# get only resolved halos
self.halo_mass_thresh = 5.0e10
self.halo_mass_cut = (
self.snapshot.cat["Group_M_Crit200"][:]*self.snapshot.header.hubble>self.halo_mass_thresh
)
# filter subfind & fof objects
self.N_particles = self.N_particles[self.halo_mass_cut]
self.firstsub = self.firstsub[self.halo_mass_cut]
self.cum_N_particles = self.cum_N_particles[self.halo_mass_cut]
self.ID_DMO = self.ID_DMO[self.halo_mass_cut]
self.halo_pos = self.snapshot.cat['GroupPos'][self.halo_mass_cut]
self.halo_vel = self.snapshot.cat['GroupVel'][self.halo_mass_cut]
self.r200c = self.snapshot.cat['Group_R_Crit200'][self.halo_mass_cut]
self.m200c = self.snapshot.cat['Group_M_Crit200'][self.halo_mass_cut] * \
self.h
self.vmax = self.snapshot.cat['SubhaloVmax'][self.firstsub]
self.N_halos = len(self.vmax)
# read particle data
self.snapshot.read(["Coordinates", "Velocities"], parttype=[1])
self.coordinates = self.snapshot.data['Coordinates']['dm'][:]
self.velocities = self.snapshot.data['Velocities']['dm'][:]
# dm particle mass
self.Mpart = (
self.snapshot.header.massarr[1] * 1e10 / self.h
) #[Msun] particle mass
# if halo properties aren't to be found at r200c
if overdensity != 200:
self.overdensity = overdensity
self.find_overdensity_radius()
def __init__(self, simulation, snapnum, nepoch):
"""
"""
self.simulation = simulation
if (self.simulation == "christian_dm"):
self.sh_orig_file = "/cosma5/data/dp004/dc-oles1/dhalo/data/GR/"
self.sh_reor_file = "/cosma5/data/dp004/dc-beck3/Galaxy_Evolution/" \
"SubFind/dm_only/L62_N512_GR/subfind.0.hdf5"
self.mt_file = "/cosma5/data/dp004/dc-oles1/dhalo/out/trees/GR/" \
"treedir_075/tree_075.0.hdf5"
self.snapshot = read_hdf5.snapshot(snapnum, self.sh_orig_file)
print(':Loading snapshot at z=%f' % self.snapshot.header.redshift)
elif (self.simulation == 'christian_fp'):
self.sh_orig_file = "/cosma6/data/dp004/dc-arno1/SZ_project/" \
"full_physics/L62_N512_GR_kpc/"
self.sh_reor_file = "/cosma5/data/dp004/dc-beck3/Galaxy_Evolution/" \
"SubFind/fp/L62_N512_GR/subfind.0.hdf5"
self.mt_file = "/cosma/home/dp004/dc-oles1/var/data/dhalo/out/" \
"trees/full_physics_GR/treedir_045/tree_045.0.hdf5"
self.snapshot = read_hdf5.snapshot(snapnum, self.sh_orig_file)
print(':Loading snapshot at z=%f' % self.snapshot.header.redshift)
elif (self.simulation == "EAGLE"):
self.sh_file = "/gpfs/data/Eagle/yanTestRuns/MergerTree/" \
"Dec14/L0100N1504/EAGLE_L0100N1504_db.hdf5"
self.part_file = "/cosma5/data/Eagle/ScienceRuns/Planck1/" \
"L0100N1504/PE/REFERENCE/data/"
self.mt_file = "/gpfs/data/Eagle/yanTestRuns/MergerTree/" \
"Dec14/L0100N1504/EAGLE_L0100N1504_db.hdf5"
self.snapshot = read_hdf5_eagle.snapshot(snapnum, self.part_file)
print(':Loading snapshot at z=%f' % self.snapshot.header.redshift)
# Load the useful fields
if (self.simulation == 'christian_dm'):
# First Hand Data
## Snapshot particle related data
self.snapshot.group_catalog(["SubhaloLenType",
"SubhaloPos",
"SubhaloIDMostbound"])
dfpart = pd.DataFrame(
{'id_mostbound' : (self.snapshot.cat['SubhaloIDMostbound']).astype(np.int64),
'X' : (self.snapshot.cat['SubhaloPos'][:, 0]).astype(np.float64),
'Y' : (self.snapshot.cat['SubhaloPos'][:, 1]).astype(np.float64),
'Z' : (self.snapshot.cat['SubhaloPos'][:, 2]).astype(np.float64),
'n_part' : (self.snapshot.cat["SubhaloLenType"][:, 1]).astype(np.int64)}
)
print(':Original data-set contains %d subhalos' % (dfpart.shape[0]))
subhalo_offset = (np.cumsum(dfpart['n_part'].values) - \
dfpart['n_part'].values).astype(int)
dfpart['offset'] = pd.Series(subhalo_offset, index=dfpart.index, dtype=int)
self.snapshot.read(["Coordinates"], parttype=[1])
del subhalo_offset, self.snapshot.cat
## Read with respect to the merger-tree re-ordered SubFind file
hdf = h5py.File(self.sh_reor_file, 'r')
self.df = pd.DataFrame({'snapnum' : hdf['Subhalo']['SnapNum'][:],
'mass_total' : hdf['Subhalo']['SubhaloMass'][:],
'halfmassrad' : hdf['Subhalo']['SubhaloHalfmassRad'][:],
'sigma' : hdf['Subhalo']['SubhaloVelDisp'][:],
'nodeIndex' : hdf['Subhalo']['nodeIndex'][:],
'id_mostbound' : hdf['Subhalo']['SubhaloIDMostbound'][:]})
_indx = self.df[self.df['snapnum'] == snapnum].index
self.df = self.df[self.df['snapnum'] == snapnum]
self.df.index = range(len(self.df.index))
spin = hdf['Subhalo']['SubhaloSpin'][:]
spin = spin[_indx, :]
spin = [np.sqrt((spin[ii, 0]**2 + spin[ii, 1]**2 + spin[ii, 2]**2)/3) for ii in range(len(spin))]
self.df['spin'] = pd.Series(spin, index=self.df.index, dtype=float)
## Filter
_indx = self.match_halos(self.df['id_mostbound'].values, dfpart['id_mostbound'].values)
self.df = self.df.iloc[_indx]
self.df.index = range(len(self.df.index))
_indx = self.match_halos(dfpart['id_mostbound'].values, self.df['id_mostbound'].values)
dfpart = dfpart.iloc[_indx]
dfpart.index = range(len(dfpart.index))
# Second Hand Data
self.principal_axis(dfpart)
self.progenitors(snapnum-nepoch, snapnum)
print(':Final data-set contains %d subhalos' % (self.df.shape[0]))
elif (self.simulation == 'christian_fp'):
# First Hand Data
## Snapshot particle related data
self.snapshot.group_catalog(["SubhaloLenType",
"SubhaloPos",
"SubhaloIDMostbound"])
dfpart = pd.DataFrame(
{'id_mostbound' : (self.snapshot.cat['SubhaloIDMostbound']).astype(np.int64),
'X' : (self.snapshot.cat['SubhaloPos'][:, 0]).astype(np.float64),
'Y' : (self.snapshot.cat['SubhaloPos'][:, 1]).astype(np.float64),
'Z' : (self.snapshot.cat['SubhaloPos'][:, 2]).astype(np.float64),
'n_part' : (self.snapshot.cat["SubhaloLenType"][:, 1]).astype(np.int64)}
)
print(':Original data-set contains %d subhalos' % (dfpart.shape[0]))
subhalo_offset = (np.cumsum(dfpart['n_part'].values) - \
dfpart['n_part'].values).astype(int)
dfpart['offset'] = pd.Series(subhalo_offset, index=dfpart.index, dtype=int)
self.snapshot.read(["Coordinates"], parttype=[1])
del subhalo_offset, self.snapshot.cat
## Read with respect to the merger-tree re-ordered SubFind file
hdf = h5py.File(self.sh_reor_file, 'r')
self.df = pd.DataFrame({'snapnum' : hdf['Subhalo']['SnapNum'][:],
'mass_total' : hdf['Subhalo']['SubhaloMass'][:],
'sfr' : hdf['Subhalo']['SubhaloSFR'][:],
'halfmassrad' : hdf['Subhalo']['SubhaloHalfmassRadType'][:, 4],
'sigma' : hdf['Subhalo']['SubhaloVelDisp'][:],
'nodeIndex' : hdf['Subhalo']['nodeIndex'][:],
'id_mostbound' : hdf['Subhalo']['SubhaloIDMostbound'][:]})
_indx = self.df[self.df['snapnum'] == snapnum].index
self.df = self.df[self.df['snapnum'] == snapnum]
self.df.index = range(len(self.df.index))
print('::::: SFR:', self.df['sfr'])
spin = hdf['Subhalo']['SubhaloSpin'][:]
spin = spin[_indx, :]
spin = [np.sqrt((spin[ii, 0]**2 + spin[ii, 1]**2 + spin[ii, 2]**2)/3) for ii in range(len(spin))]
self.df['spin'] = pd.Series(spin, index=self.df.index, dtype=float)
## Filter
_indx = self.match_halos(self.df['id_mostbound'].values, dfpart['id_mostbound'].values)
self.df = self.df.iloc[_indx]
self.df.index = range(len(self.df.index))
_indx = self.match_halos(dfpart['id_mostbound'].values, self.df['id_mostbound'].values)
dfpart = dfpart.iloc[_indx]
dfpart.index = range(len(dfpart.index))
# Second Hand Data
self.principal_axis(dfpart)
self.progenitors(snapnum-nepoch, snapnum)
print(':Final data-set contains %d subhalos' % (self.df.shape[0]))
elif (self.simulation == 'EAGLE'):
# First Hand Data
## Snapshot particle related data
#self.snapshot.group_catalog(["SubLengthType",
# "CentreOfMass",
# "IDMostBound"])
#dfpart = pd.DataFrame(
# {'id_mostbound' : (self.snapshot.cat['IDMostBound']).astype(np.int64),
# 'X' : (self.snapshot.cat['CentreOfMass'][:, 0]).astype(np.float64),
# 'Y' : (self.snapshot.cat['CentreOfMass'][:, 1]).astype(np.float64),
# 'Z' : (self.snapshot.cat['CentreOfMass'][:, 2]).astype(np.float64),
# 'n_part' : (self.snapshot.cat["SubLengthType"][:, 1]).astype(np.int64)}
# )
#print(':Original data-set contains %d subhalos' % (dfpart.shape[0]))
#subhalo_offset = (np.cumsum(dfpart['n_part'].values) - \
# dfpart['n_part'].values).astype(int)
#dfpart['offset'] = pd.Series(subhalo_offset, index=dfpart.index, dtype=int)
#self.snapshot.read(["Coordinates"], parttype=[1])
#del subhalo_offset
## Read with respect to the merger-tree re-ordered SubFind file
hdf = h5py.File(self.sh_file, 'r')
self.df = pd.DataFrame(
{'snapnum' : hdf['Subhalo']['SnapNum'][:],
'mass_total' : hdf['Subhalo']['Mass'][:],
'halfmassrad' : hdf['Subhalo']['HalfMassRad_Star'][:],
'sigma' : hdf['Subhalo']['StellarVelDisp'][:],
'DhaloIndex' : hdf['Subhalo']['DhaloIndex'][:],
'DescendantID' : hdf['MergerTree']['DescendantID'][:],
'HaloID' : hdf['MergerTree']['HaloID'][:],
'LastProgID' : hdf['MergerTree']['LastProgID'][:],
'TopLeafID' : hdf['MergerTree']['TopLeafID'][:]}
)
self.df = self.df[self.df['snapnum'] == snapnum]
self.df.index = range(len(self.df.index))
print(':Original data-set contains %d subhalos' % (self.df.shape[0]))
#self.dfmt = pd.DataFrame(
# {'snapnum' : hdf['MergerTree']['DescendantID'][:],
# 'DescendantID' : hdf['MergerTree']['DescendantID'][:],
# 'HaloID' : hdf['MergerTree']['HaloID'][:],
# 'LastProgID' : hdf['MergerTree']['LastProgID'][:]}
# )
#self.df = self.df[(self.df['snapnum'] >= snapnum-nepoch) & \
# (self.df['snapnum'] <= snapnum)]
#self.df.index = range(len(self.df.index))
self.progenitors(snapnum-nepoch, snapnum, self.simulation)
print(':Final data-set contains %d subhalos' % (self.df.shape[0]))
def lensing_signal():
# Get command line arguments
args = {}
args["simdir"] = sys.argv[1]
args["snapnum"] = int(sys.argv[2])
args["ladir"] = sys.argv[3]
args["rksdir"] = sys.argv[4]
args["outbase"] = sys.argv[5]
args["radius"] = sys.argv[6]
#args["zs"] = sys.argv[7]
snapfile = args["simdir"] + 'snapdir_%03d/snap_%03d'
# Units of Simulation
scale = rf.simulation_units(args["simdir"])
# Cosmological Parameters
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
h = s.header.hubble
zl = s.header.redshift
print('Analyse sub-&halo at z=%f' % zl)
Lens = {"HFID": [], "Vrms": [], "FOV": [], "ELIP": [], "PA": []}
# Run through LensingMap output files
for lm_file in glob.glob(args["ladir"] + "*" + "409.pickle"):
# Load LensingMap Contents
LM = pickle.load(open(lm_file, 'rb'))
print('Processing the following file: \n %s' % (lm_file))
print('which contains %d lenses' % len(LM['HF_ID'][:]))
print('with max. einst. radius: %f', np.max(LM['Sources']['Rein'][:]))
label = args["simdir"].split('/')[-2].split('_')[-2]
snapnum = LM['snapnum']
dfh = pd.read_csv(args["rksdir"] + 'halos_%d.dat' % snapnum,
sep='\s+',
skiprows=np.arange(1, 16))
print(LM['FOV'])
# Run through lenses
for ll in range(len(LM['HF_ID'])):
HFID = int(LM['HF_ID'][ll])
FOV = int(LM['FOV'][ll]) #[arcsec]
# Load Halo Properties
indx = dfh['#ID'][dfh['#ID'] == HFID].index[0]
HPos = [dfh['X'][indx], dfh['Y'][indx], dfh['Z'][indx]]
Vrms = dfh['Vrms'][indx] #[km/s]
hvel = pd.concat([dfh['VX'], dfh['VY'], dfh['VZ']],
axis=1).loc[[indx]].values
epveca = pd.concat([dfh['A[x]'], dfh['A[y]'], dfh['A[z]']],
axis=1).loc[[indx]].values
epvecb = pd.concat([dfh['B[x]'], dfh['B[y]'], dfh['B[z]']],
axis=1).loc[[indx]].values
epvecc = pd.concat([dfh['C[x]'], dfh['C[y]'], dfh['C[z]']],
axis=1).loc[[indx]].values
# Ellipticity (should be between 0.0-0.8)
epval = [
np.linalg.norm(vec)
for vec in np.vstack((epveca, epvecb, epvecc))
]
print('epval', epval)
indx = np.argsort(epval)
a = epval[indx[2]] # major
b = epval[indx[1]] # intermediate
c = epval[indx[0]] # minor
ellipticity = (a - b) / (2 * (a + b + c))
print(a, b, c)
print('ellipticity', ellipticity)
# Position-Angle [rad]
# Based on Stark 1977; Binggeli 1980
"""
[vu, phi] = Euler_angles(sub_av, sub_bv, sub_cv)
j = e1**2*e2**2*np.sin(vu)**2 + \
e1**2*np.cos(vu)*np.cos(phi)**2 + \
e2**2*np.cos(vu)**2*np.sin(phi)**2
l = e1**2*np.sin(phi)**2 + e2**2*np.cos(phi)**2
k = (e1**2 - e2**2)*np.sin(phi)*np.cos(phi)*np.cos(vu)
ep = np.sqrt((j + l + np.sqrt((j - l)**2 + 4*k**2)) /
(j + l - np.sqtr((j - l)**2 + 4*k**2)))
# Observed ellipticity
e = 1 - 1/ep
f = e1**2*np.sin(vu)**2*np.sin(phi)**2 +
e2**2*np.sin(vu)**2*np.cos(phi)**2 + np.cos(vu)**2
"""
PA = 0.
Lens['HFID'].append(HFID)
Lens['FOV'].append(FOV)
Lens['Vrms'].append(Vrms)
Lens['ELIP'].append(ellipticity)
Lens['PA'].append(PA)
df = pd.DataFrame.from_dict(Lens)
zllabel = str(zl).replace('.', '')[:3].zfill(3)
fname = (args["outbase"]+'LPPBox_%s_zl%s.txt' % \
(label, zllabel))
df.to_csv(fname, header=True, index=None, sep=' ', mode='w')
def lensing_signal():
# Get command line arguments
args = {}
args["snapnum"] = int(sys.argv[1])
args["simdir"] = sys.argv[2]
args["hfname"] = sys.argv[3]
args["dmdir"] = sys.argv[4]
args["ncells"] = int(sys.argv[5])
args["outbase"] = sys.argv[6]
args["lenses"] = int(sys.argv[7])
# Organize devision of Sub-&Halos over Processes on Proc. 0
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
unitlength = lt.define_unit(s.header.unitlength, args["hfname"])
fname = glob.glob(args["dmdir"] + '*.h5')
dmfile = []
for ff in range(len(fname)):
#if (os.path.getsize(fname[ff])/(1024*1024.0)) < 1:
# fname[ff] = 0
#else:
dmfile.append(fname[ff])
dmfile = np.asarray(dmfile)
# Cosmological Parameters
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
redshift = s.header.redshift
print('Analyse sub-&halo at z=%f' % redshift)
# Calculate critical surface density
zl = redshift
zs = 0.409
sigma_cr = lt.sigma_crit(zl, zs, cosmo).to_value('Msun %s-2' % unitlength)
lenslistinit()
srclistinit()
# Run through files
for ff in range(len(dmfile)):
print('\n')
print('------------- \n Reading File: %s' %
(fname[ff].split('/')[-2:]))
dmf = h5py.File(dmfile[ff], 'r')
print('Nr. of galxies:', len(dmf['HFID']))
# Run through lenses
for ll in range(len(dmf['HFID'])):
# convert. box size and pixels size from ang. diam. dist. to arcsec
FOV_arc = (dmf['FOV'][ll]/cf.Da(zl, unitlength, cosmo) * \
u.rad).to_value('arcsec')
dsx_arc = FOV_arc / args["ncells"] #[arcsec] pixel size
# initialize the coordinates of grids (light rays on lens plan)
lp1, lp2, lpv = cf.make_r_coor(FOV_arc, args["ncells"])
# Calculate convergence map
kappa = dmf['DMAP'][ll] / sigma_cr
fig = plt.figure()
ax = fig.add_subplot(111)
# Calculate Deflection Maps
alpha1, alpha2, mu_map, phi, detA, lambda_t, lpv = lt.cal_lensing_signals(
kappa, FOV_arc, args["ncells"], lpv)
lp2, lp1 = np.meshgrid(lpv, lpv) #[arcsec] finer resol. in centre
# Mapping light rays from image plane to source plan
[sp1, sp2] = [lp1 - alpha1, lp2 - alpha2] #[arcsec]
# Calculate Einstein Radii
Ncrit, curve_crit_tan, caustic, Rein = lt.einstein_radii(
lp1, lp2, sp1, sp2, detA, lambda_t, cosmo, ax, 'med')
# Calculate Time-Delay and Magnification
beta = np.array([0., 0.])
n_imgs, delta_t, mu, theta = lt.timedelay_magnification(
mu_map, phi, dsx_arc, args["ncells"], lp1, lp2, alpha1, alpha2,
beta, zs, zl, cosmo)
if args["lenses"] == True:
if n_imgs > 1:
#TODO: does n_imgs include the original
print('Galaxy %d/%d got %d multiple lensed images' % \
(ll, len(dmf['HFID']), n_imgs))
# Tree Branch 1
l_HFID.append(int(dmf['HFID'][ll]))
l_fov.append(FOV_arc)
# Tree Branch 2
l_srcbeta.append(beta)
l_tancritcurves.append(curve_crit_tan)
l_caustic.append(caustic)
l_einsteinradius.append(Rein)
# Tree Branch 3
l_srctheta.append(theta)
l_deltat.append(delta_t)
l_mu.append(mu)
elif args["lenses"] == False:
if n_imgs == 1:
l_HFID.append(int(dmf['HFID'][ll]))
l_fov.append(FOV_arc)
l_srcbeta.append(beta)
l_tancritcurves.append(curve_crit_tan)
l_caustic.append(caustic)
l_einsteinradius.append(Rein)
l_srctheta.append(theta)
l_deltat.append(delta_t)
l_mu.append(mu)
########## Save to File ########
if args["lenses"] == True:
print('%d galaxies produce multiple imaged SN Ia' % (len(l_HFID)))
tree = plant_Tree()
# Tree Branches of Node 1 : Lenses
tree['HF_ID'] = l_HFID
tree['snapnum'] = args["snapnum"]
tree['zl'] = redshift
tree['zs'] = zs
tree['FOV'] = l_fov #[arcsec] for glafic
# Tree Branches of Node 1 : Sources
tree['Sources']['beta'] = l_srcbeta
tree['Sources']['CAU'] = l_caustic
tree['Sources']['TCC'] = l_tancritcurves
tree['Sources']['Rein'] = l_einsteinradius
for imgs in range(len(l_mu)):
# Tree Branches of Node 2 : Multiple Images
tree['Sources']['theta'][imgs] = l_srctheta[imgs]
tree['Sources']['delta_t'][imgs] = l_deltat[imgs]
tree['Sources']['mu'][imgs] = l_mu[imgs]
simlabel = args["simdir"].split('/')[-2].split('_')[2]
zllabel = str(redshift).replace('.', '')[:3].zfill(3)
zslabel = '{:<03d}'.format(int(str(zs).replace('.', '')))
filename = args["outbase"]+'LM_%s_%s_zl%szs%s.pickle' % \
(simlabel, 'lens', zllabel, zslabel)
filed = open(filename, 'wb')
pickle.dump(tree, filed)
filed.close()
plt.close(fig)
elif args["lenses"] == False:
print('%d galaxies produce single imaged SN Ia' % (len(l_HFID)))
dicts = {}
dicts['HF_ID'] = l_HFID
dicts['snapnum'] = args["snapnum"]
dicts['zl'] = redshift
dicts['zs'] = zs
dicts['FOV'] = l_fov #[arcsec] for glafic
dicts['beta'] = l_srcbeta
dicts['CAU'] = l_caustic
dicts['TCC'] = l_tancritcurves
dicts['Rein'] = l_einsteinradius
dicts['theta'] = l_srctheta
dicts['delta_t'] = l_deltat
dicts['mu'] = l_mu
df = pd.DataFrame(data=dicts)
simlabel = args["simdir"].split('/')[-2].split('_')[2]
zllabel = str(redshift).replace('.', '')[:3].zfill(3)
zslabel = '{:<03d}'.format(int(str(zs).replace('.', '')))
filename = args["outbase"]+'LM_%s_%s_zl%szs%s.h5' % \
(simlabel, 'nonlens', zllabel, zslabel)
df.to_hdf(filename, key='nonlenses')
plt.close(fig)
snapnum = 45
###############################################################################
# Subfind Results
lc_dir = '/cosma5/data/dp004/dc-beck3/LightCone/full_physics/'
hf_name = 'Subfind'
lc_file = lc_dir+hf_name+'/LC_SN_L62_N512_GR_kpc_rndseed1.h5'
LC = rf.LightCone_with_SN_lens(lc_file, hf_name)
print('length', len(LC['Rhalfmass']))
###############################################################################
# Subfind
hfdir = '/cosma6/data/dp004/dc-arno1/SZ_project/full_physics/L62_N512_GR_kpc/'
blockprint()
s = read_hdf5.snapshot(snapnum, hfdir)
s.group_catalog(["SubhaloVelDisp", "SubhaloHalfmassRad",
"SubhaloMass", "SubhaloPos", "GroupPos", "GroupMass"])
enableprint()
Subfind= {'Pos' : s.cat["SubhaloPos"]*s.header.hubble*1e-3,
'Mass' : s.cat["SubhaloMass"],
'Vrms' : s.cat["SubhaloVelDisp"]}
###############################################################################
# Rockstar
hfdir = ('/cosma5/data/dp004/dc-beck3/rockstar/full_physics/L62_N512_GR_kpc/' + \
'halos_%d.dat' % snapnum)
data = open(hfdir, 'r')
data = data.readlines()
subpos = []
subMvir = []
LCSettings)
################################################################################
# Run through simulations
for sim in range(len(sim_dir)):
# File for lensing-maps
lm_dir = HQ_dir + '/LensingMap/' + sim_phy[sim] + hfname + '/' + sim_name[
sim] + '/'
# Simulation Snapshots
snapfile = sim_dir[sim] + 'snapdir_%03d/snap_%03d'
# Units of Simulation
scale = rf.simulation_units(sim_dir[sim])
# Cosmological Parameters
s = read_hdf5.snapshot(45, sim_dir[sim])
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
h = s.header.hubble
HF_ID = []
HaloLCID = []
SrcID = []
Mdyn = []
Mlens = []
# Run through LensingMap output files
#for lm_file in glob.glob(lm_dir+'LM_1_Proc_*_0.pickle'):
for lm_file in glob.glob(lm_dir + 'LM_new_GR.pickle'):
# Load LensingMap Contents
LM = pickle.load(open(lm_file, 'rb'))
def lensing_signal():
# Get command line arguments
args = {}
#args["snapnum"] = int(sys.argv[1])
#args["ncells"] = int(sys.argv[2])
#args["simdir"] = sys.argv[3]
#args["dmdir"] = sys.argv[4]
#args["outbase"] = sys.argv[5]
args["snapnum"] = 40
args["ncells"] = 1024
args["simdir"] = "/cosma6/data/dp004/dc-arno1/SZ_project/full_physics/L62_N512_GR_kpc/"
args["dmdir"] = "/cosma5/data/dp004/dc-beck3/StrongLensing/DensityMap/full_physics/L62_N512_GR_kpc/z_40/"
args["outbase"] = "/cosma5/data/dp004/dc-beck3/StrongLensing/LensingMap/full_physics/Rockstar/L62_N512_GR_kpc/Box/"
# Organize devision of Sub-&Halos over Processes on Proc. 0
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
fname = glob.glob(args["dmdir"]+'*.h5')
ffname = []
for ff in range(len(fname)):
if (os.path.getsize(fname[ff])/(1024*1024.0)) < 1:
fname[ff] = 0
else:
ffname.append(fname[ff])
ffname = np.asarray(ffname)
print(ffname)
# Cosmological Parameters
cosmo = LambdaCDM(H0=s.header.hubble*100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
redshift = s.header.redshift
# Calculate critical surface density
zl = redshift
zs = 2.
sigma_cr = sigma_crit(zl, zs, cosmo).to_value('Msun Mpc-2')
lenslistinit(); srclistinit()
# Run through files
for ff in range(len(ffname))[:]:
print('Reading File: %s' % (fname[ff].split('/')[-2:]))
dmf = h5py.File(ffname[ff], 'r')
print(len(dmf['subhalo_id'][:]))
# Run through lenses
for ll in range(len(dmf['subhalo_id']))[1:]:
print('Works on lens %d with ID %d' % \
(ll, dmf['subhalo_id'][ll]))
# convert. box size and pixels size from ang. diam. dist. to arcsec
FOV_arc = (dmf['fov_width'][ll]/cf.Da(zl, cosmo)*u.rad).to_value('arcsec') #[arcsec] box size
dsx_arc = FOV_arc/args["ncells"] #[arcsec] pixel size
# initialize the coordinates of grids (light rays on lens plan)
#lp1, lp2 = cf.make_r_coor(FOV_arc, args["ncells"]) #[arcsec]
lpv = np.linspace(-(FOV_arc-dsx_arc)/2, (FOV_arc-dsx_arc)/2, args["ncells"])
lp1, lp2 = np.meshgrid(lpv, lpv) #[arcsec]
# Calculate convergence map
kappa = dmf['density_map'][ll]/sigma_cr
#print('The Kappa place has a max of %f and min of %f' %
# (np.max(kappa), np.min(kappa)))
fig = plt.figure()
ax = fig.add_subplot(111)
# Calculate Deflection Maps
alpha1, alpha2, mu_map, phi, detA, lambda_t = cal_lensing_signals(kappa,
FOV_arc,
args["ncells"])
# Calculate Einstein Radii
print('finish cal_lensing_signals')
Ncrit, curve_crit, curve_crit_tan, Rein = einstein_radii(lp1, lp2,
detA,
lambda_t,
zl, cosmo,
ax, 'med')
print('finish einstein_radii')
# Calculate Time-Delay and Magnification
snia_pos = np.array([0, 0, 0])
n_imgs, delta_t, mu, theta, beta = timedelay_magnification(
mu_map, phi, dsx_arc, args["ncells"],
lp1, lp2, alpha1, alpha2, snia_pos, zs, zl, cosmo)
print('finish timedelay_magnification')
if n_imgs > 1:
print(dmf['subhalo_id'][ll])
print('11111')
l_HFID.append(int(dmf['subhalo_id'][ll]))
print('22222')
print('timedelay_magnification', n_imgs)
# Tree Branch 1
#l_HFID.append(int(dmf['subhalo_id'][ll]))
# Tree Branch 2
l_srcbeta.append(beta)
l_tancritcurves.append(curve_crit_tan)
l_einsteinradius.append(Rein)
# Tree Branch 3
l_srctheta.append(theta)
l_deltat.append(delta_t)
l_mu.append(mu)
########## Save to File ########
print('Plant tree of %d lenses' % (len(l_HFID)))
tree = plant_Tree()
# Tree Branches of Node 1 : Lenses
tree['HF_ID'] = l_HFID
tree['snapnum'] = args["snapnum"]
tree['zl'] = redshift
tree['zs'] = 2.
# Tree Branches of Node 1 : Sources
tree['Sources']['beta'] = l_srcbeta
tree['Sources']['TCC'] = l_tancritcurves
tree['Sources']['Rein'] = l_einsteinradius
for imgs in range(len(l_mu)):
# Tree Branches of Node 2 : Multiple Images
tree['Sources']['theta'][imgs] = l_srctheta[imgs]
tree['Sources']['delta_t'][imgs] = l_deltat[imgs]
tree['Sources']['mu'][imgs] = l_mu[imgs]
print('tree created')
label = args["simdir"].split('/')[-2].split('_')[2]
filename = args["outbase"]+'LM_%s_z%d.pickle' % (label, args["snapnum"])
filed = open(filename, 'wb')
pickle.dump(tree, filed)
filed.close()
plt.close(fig)
print('plt close')
def subhalo_data(hfdir, hfname, snapnum, h, unit):
"""
Input:
hfdir: halo finder output directory
hfname: halo finder name
snapnum: snapshot number
h: hubble parameter
unit: length units of halo positions in simulation
"""
exp = np.floor(np.log10(np.abs(unit))).astype(int)
if hfname == 'Rockstar':
# [X, Y, Z] in [Mpc]
hffile = hfdir + 'halos_%d.dat' % snapnum
df = pd.read_csv(hffile,
sep='\s+',
skiprows=16,
usecols=[0, 2, 4, 9, 10, 11],
names=['ID', 'Mvir', 'Vrms', 'X', 'Y', 'Z'])
df = df[df['Mvir'] > 3e11]
if exp == 23: #[Mpc]
pass
elif exp == 21: #[kpc]
df.loc[:, 'X'] *= 1e3 / h
df.loc[:, 'Y'] *= 1e3 / h
df.loc[:, 'Z'] *= 1e3 / h
else:
raise Exception('This unit can not be convertet for Rockstar')
elif hfname == 'Subfind':
s = read_hdf5.snapshot(snapnum, hfdir)
s.group_catalog([
"SubhaloIDMostbound", "SubhaloPos", "SubhaloMass",
"SubhaloVelDisp", "GroupFirstSub"
])
indx = s.cat['GroupFirstSub'].astype(int)
df = pd.DataFrame({
'ID': s.cat['SubhaloIDMostbound'][indx],
'Vrms': s.cat['SubhaloVelDisp'][indx],
'X': s.cat['SubhaloPos'][indx, 0],
'Y': s.cat['SubhaloPos'][indx, 1],
'Z': s.cat['SubhaloPos'][indx, 2],
'Mass': s.cat['SubhaloMass'][indx]
})
df = df[df['Mass'] > 5e11]
if exp == 21: #simulation in [kpc]
pass
elif exp == 23: #simulation in [Mpc]
df.loc[:, 'X'] *= 1e-3 * h
df.loc[:, 'Y'] *= 1e-3 * h
df.loc[:, 'Z'] *= 1e-3 * h
else:
raise Exception('This unit can not be convertet for Subfind')
SH = {
'ID': df['ID'].values.astype('float64'), #for MPI.DOUBLE datatype
'Vrms': df['Vrms'].values.astype('float64'),
'X': df['X'].values.astype('float64'),
'Y': df['Y'].values.astype('float64'),
'Z': df['Z'].values.astype('float64')
}
del df
return SH
def lensing_signal():
# Get command line arguments
args = {}
args["snapnum"] = int(sys.argv[1])
args["simdir"] = sys.argv[2]
args["ladir"] = sys.argv[3]
args["hfname"] = sys.argv[4]
args["hfdir"] = sys.argv[5]
args["outbase"] = sys.argv[6]
args["radius"] = sys.argv[7]
args["lenses"] = int(sys.argv[8])
snapfile = args["simdir"] + 'snapdir_%03d/snap_%03d'
label = args["simdir"].split('/')[-2].split('_')[-2]
# Units of Simulation
scale = rf.simulation_units(args["simdir"])
# Cosmological Parameters
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
h = s.header.hubble
# Stellar Data
stars = load.load_stars(args["snapnum"], args["simdir"])
dm = load.load_dm(args["snapnum"], args["simdir"])
gas = load.load_gas(args["snapnum"], args["simdir"])
indxdrop = [] # collect indices of subhalos falling through criterias
if args["lenses"] == 1:
lafile = glob.glob(args["ladir"] + "*" + "_lens_" + "*" +
"409.pickle")[0]
lenses = load.load_subhalos(args["snapnum"],
args["simdir"],
lafile,
strong_lensing=1)
# Run through lenses
for ll in range(len(lenses.index.values)):
print('Lenses: %f' % (ll / len(lenses.index.values)))
lens = lenses.iloc[ll]
if isinstance(lens, (pd.core.series.Series)):
indx = load.select_particles(stars['Pos'], lens['Pos'],
lens['Rstellarhalfmass'] * 1.5,
'sphere')
halo_stars = {
'Pos': stars['Pos'][indx, :],
'Vel': stars['Vel'][indx, :],
'Mass': stars['Mass'][indx]
}
halo_stars['Pos'] -= lens['Pos']
indx = load.select_particles(dm['Pos'], lens['Pos'],
lens['Rein'], 'sphere')
halo_dm = {'Pos': dm['Pos'][indx, :], 'Mass': dm['Mass'][indx]}
halo_dm['Pos'] -= lens['Pos']
indx = load.select_particles(gas['Pos'], lens['Pos'],
lens['Rein'], 'sphere')
halo_gas = {
'Pos': gas['Pos'][indx, :],
'Mass': gas['Mass'][indx]
}
halo_gas['Pos'] -= lens['Pos']
lenses, indxdrop = load.add_properties(halo_stars, halo_dm,
halo_gas, lens, lenses,
cosmo, s, indxdrop, ll,
args["lenses"])
else:
print('!!!!!!! SOS !!!!!!!!!')
lenses = lenses.drop(indxdrop)
print('Saving %d lenses to .hdf5' % (len(lenses.index.values)))
zllabel = str(lens['ZL']).replace('.', '')[:3].zfill(3)
zslabel = '{:<03d}'.format(
int(str(lenses['ZS'].values[0]).replace('.', '')))
fname = (args["outbase"]+'LPPBox_%s_%s_zl%szs%s.h5' % \
(label, 'lens', zllabel, zslabel))
lenses.to_hdf(fname, key='lenses', mode='w')
if args["lenses"] == 0:
print(args["ladir"] + "*" + "_nonlens_" + "*" + "409.h5")
print(glob.glob(args["ladir"] + "*" + "_nonlens_" + "*" + "409.h5"))
lafile = glob.glob(args["ladir"] + "*" + "_nonlens_" + "*" +
"409.h5")[0]
subhalos = load.load_subhalos(args["snapnum"],
args["simdir"],
lafile,
strong_lensing=0)
# Run through subhalos
for ll in range(len(subhalos.index.values)):
print('Non-Lenses: %f' % (ll / len(subhalos.index.values)))
subhalo = subhalos.iloc[ll]
if isinstance(subhalo, (pd.core.series.Series)):
indx = load.select_particles(stars['Pos'], subhalo['Pos'],
subhalo['Rstellarhalfmass'] * 1.5,
'sphere')
halo_stars = {
'Pos': stars['Pos'][indx, :],
'Vel': stars['Vel'][indx, :],
'Mass': stars['Mass'][indx]
}
halo_stars['Pos'] -= subhalo['Pos']
#indx = load.select_particles(
# dm['Pos'], subhalo['Pos'],
# subhalo['Rstellarhalfmass']*1.5,
# 'sphere')
#halo_dm = {'Pos' : dm['Pos'][indx, :],
# 'Vel' : dm['Vel'][indx, :],
# 'Mass' : dm['Mass'][indx]}
#halo_dm['Pos'] -= subhalo['Pos']
subhalos, indxdrop = load.add_properties(
halo_stars, subhalo, subhalos, cosmo, s, indxdrop, ll,
args["lenses"])
else:
print('!!!!!!! SOS !!!!!!!!!')
subhalos = subhalos.drop(indxdrop)
print('Saving %d Subhalos to .hdf5' % (len(subhalos.index.values)))
zllabel = str(zl).replace('.', '')[:3].zfill(3)
zslabel = '{:<03d}'.format(
int(str(subhalos['ZS'].values[0]).replace('.', '')))
fname = (args["outbase"]+'LPPBox_%s_%s_zl%szs%s.h5' % \
(label, 'nonlens', zllabel, zslabel))
subhalos.to_hdf(fname, key='subhalos', mode='w')
def lensing_signal():
# Get command line arguments
args = {}
#args["snapnum"] = int(sys.argv[1])
args["simdir"] = sys.argv[1]
args["ladir"] = sys.argv[2]
args["rksdir"] = sys.argv[3]
args["outbase"] = sys.argv[4]
args["radius"] = sys.argv[5]
snapfile = args["simdir"] + 'snapdir_%03d/snap_%03d'
# Units of Simulation
scale = rf.simulation_units(args["simdir"])
# Cosmological Parameters
s = read_hdf5.snapshot(45, args["simdir"])
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
h = s.header.hubble
Lens = {
"HF_ID": [],
"LC_ID": [],
"SrcID": [],
"n_imgs": [],
"M200": [],
"zl": [],
"zs": [],
"Mdyn_rks": [],
"Mdyn_stellar": [],
"Mlens": [],
"Vrms_stellar": [],
"Vrms_rks": [],
"Rein": []
}
label = args["simdir"].split('/')[-2].split('_')[-2]
# Run through LensingMap output files
for lm_file in glob.glob(args["ladir"] + 'LM_' + label + ".pickle"):
# Load LensingMap Contents
LM = pickle.load(open(lm_file, 'rb'))
print('Processing the following file: \n %s' % (lm_file))
print('which contains %d lenses' % len(LM['HF_ID'][:]))
print('with redshifts from %f to %f' % \
(np.min(LM['zl'][:]), np.max(LM['zl'][:])))
if False not in (np.diff(LM['snapnum'][:]) <= 0):
pass
else:
order = np.asarray(np.argsort(LM['snapnum'][:]))
LM['HF_ID'] = [LM['HF_ID'][oo] for oo in order]
LM['zl'] = [LM['zl'][oo] for oo in order]
LM['Sources']['Src_ID'] = [
LM['Sources']['Src_ID'][oo] for oo in order
]
LM['Sources']['zs'] = [LM['Sources']['zs'][oo] for oo in order]
LM['Sources']['mu'] = [LM['Sources']['mu'][oo] for oo in order]
LM['Sources']['Rein'] = [LM['Sources']['Rein'][oo] for oo in order]
LM['snapnum'] = [LM['snapnum'][oo] for oo in order]
assert False not in (np.diff(LM['snapnum'][:]) >= 0)
#TODO: sanity check remove after it works
#lcsndir = '/cosma5/data/dp004/dc-beck3/StrongLensing/LightCone/full_physics/Rockstar/LC_SN_L62_N512_GR_kpc_1.h5'
#lcsnf = h5py.File(lcsndir, 'r')
#lcsndf1 = pd.DataFrame({'HF_ID' : lcsnf['Halo_Rockstar_ID'],
# 'LC_ID' : lcsnf['Halo_ID'],
# 'snapnum' : lcsnf['snapnum'],
# 'zl' : lcsnf['Halo_z'],
# 'Rvir' : lcsnf['Rvir']})
#lcsndir = '/cosma5/data/dp004/dc-beck3/StrongLensing/LightCone/full_physics/Rockstar/LC_SN_L62_N512_GR_kpc_2.h5'
#lcsnf = h5py.File(lcsndir, 'r')
#lcsndf2 = pd.DataFrame({'HF_ID' : lcsnf['Halo_Rockstar_ID'],
# 'LC_ID' : lcsnf['Halo_ID'],
# 'snapnum' : lcsnf['snapnum'],
# 'zl' : lcsnf['Halo_z'],
# 'Rvir' : lcsnf['Rvir']})
#lcsndf = pd.concat([lcsndf1, lcsndf2])
previous_snapnum = -1
# Run through lenses
for ll in range(len(LM['HF_ID'])):
# Load Lens properties
HFID = int(LM['HF_ID'][ll]) #int(LM['Rockstar_ID'][ll])
snapnum = int(LM['snapnum'][ll])
zl = LM['zl'][ll]
# Only load new particle data if lens is at another snapshot
if (previous_snapnum != snapnum):
print('::::: Load snapshot: %s' % \
(args["rksdir"]+'halos_%d.dat' % snapnum))
hdata = pd.read_csv(args["rksdir"] + 'halos_%d.dat' % snapnum,
sep='\s+',
skiprows=np.arange(1, 16))
# Load Particle Properties
snap = snapfile % (snapnum, snapnum)
s = read_hdf5.snapshot(snapnum, args["simdir"])
s.read([
"Coordinates", "Masses", "Velocities",
"GFM_StellarFormationTime"
],
parttype=[4])
age = (s.data['GFM_StellarFormationTime']['stars']
).astype('float64')
star_pos = s.data['Coordinates']['stars'][age >= 0, :] * scale
star_mass = s.data['Masses']['stars'][age >= 0]
star_vel = s.data['Velocities']['stars'][age >= 0, :]
previous_snapnum = snapnum
# Load Halo Properties
try:
subhalo = hdata.loc[hdata['#ID'] == HFID]
except:
continue
HPos = subhalo[['X', 'Y', 'Z']].values[0]
Vrms = subhalo['Vrms'].values[0] #[km/s]
M200 = subhalo['Mvir'].values[0] #[km/s]
hvel = subhalo[['VX', 'VY', 'VZ']].values[0]
epva = subhalo[['A[x]', 'A[y]', 'A[z]']].values[0]
epvb = subhalo[['B[x]', 'B[y]', 'B[z]']].values[0]
epvc = subhalo[['C[x]', 'C[y]', 'C[z]']].values[0]
####----> Add keys <----####
if args["radius"] == 'Rshm':
#Rhalfmass = hdata['Halfmass_Radius'][indx]*u.kpc
# Stellar Half Mass Radius
Rad_dyn = cf.call_stellar_halfmass(
star_pos[:, 0], star_pos[:, 1], star_pos[:, 2], HPos[0],
HPos[1], HPos[2], star_mass, Rvir.to_value('Mpc')) * u.Mpc
if Rshm == 0.0:
continue
## Stellar Half Light Radius
### https://arxiv.org/pdf/1804.04492.pdf $3.3
else:
Rad_dyn = subhalo['Rvir'].values[0] * u.kpc
## Dynamical Mass
star_indx = lppf.check_in_sphere(HPos, star_pos,
Rad_dyn.to_value('kpc'))
if len(star_indx[0]) > 100:
slices = np.vstack(
(epva / np.linalg.norm(epva), epvb / np.linalg.norm(epvb),
epvc / np.linalg.norm(epvc)))
mdyn_s, mdyn_r, vrms_s = lppf.mass_dynamical(
Rad_dyn, star_vel[star_indx], HPos, hvel, slices, Vrms)
else:
print('!!! Not enough particles for Mdyn')
continue
if np.isnan(mdyn_s):
print('!!! Mdyn = NaN')
continue
## Lensing Mass
# Run through sources
for ss in range(len(LM['Sources']['Src_ID'][ll])):
n_imgs = len(LM['Sources']['mu'][ll][ss])
if n_imgs == 1:
# print('!!! numer of lensing images = 1, ', n_imgs)
continue
zs = LM['Sources']['zs'][ll][ss]
Rein_arc = LM['Sources']['Rein'][ll][ss] * u.arcsec
Rein = Rein_arc.to_value('rad') * \
cosmo.angular_diameter_distance(zl).to('kpc')
Lens['n_imgs'].append(n_imgs)
Lens['M200'].append(M200)
Lens['Mlens'].append(lppf.mass_lensing(Rein, zl, zs, cosmo))
Lens['Mdyn_rks'].append(mdyn_r)
Lens['Mdyn_stellar'].append(mdyn_s)
Lens["Vrms_stellar"].append(vrms_s.to_value('km/s'))
Lens["Vrms_rks"].append(Vrms)
Lens['Rein'].append(LM['Sources']['Rein'][ll][ss])
Lens['HF_ID'].append(HFID)
Lens['LC_ID'].append(LM['LC_ID'][ll])
Lens['SrcID'].append(LM['Sources']['Src_ID'][ll][ss])
Lens['zl'].append(zl)
Lens['zs'].append(zs)
print('Saved data of lens %d' % (ll))
df = pd.DataFrame.from_dict(Lens)
print('Saving %d lenses to .hdf5' % (len(df.index)))
label = args["simdir"].split('/')[-2].split('_')[-2]
fname = (args["outbase"] + 'LPP_%s_2.h5' % label)
df.to_hdf(fname, key='df', mode='w')
def create_density_maps():
time_start = time.time()
# Get command line arguments
args = {}
if comm_rank == 0:
args["simdir"] = sys.argv[1]
args["hfdir"] = sys.argv[2]
args["lcdir"] = sys.argv[3]
args["ncells"] = int(sys.argv[4])
args["walltime"] = int(sys.argv[5])
args["outbase"] = sys.argv[6]
args = comm.bcast(args, root=0)
label = args["simdir"].split('/')[-2].split('_')[2]
hflabel = whichhalofinder(args["lcdir"])
# Load LightCone Contents
if comm_rank == 0:
lchdf = h5py.File(args["lcdir"], 'r')
dfhalo = pd.DataFrame({
'HF_ID': lchdf['Halo_Rockstar_ID'].value,
'ID': lchdf['Halo_ID'].value,
'Halo_z': lchdf['Halo_z'].value,
'snapnum': lchdf['snapnum'].value,
'Vrms': lchdf['VelDisp'].value,
'fov_Mpc': lchdf['FOV'][:][1],
('HaloPosBox', 'X'): lchdf['HaloPosBox'][:, 0],
('HaloPosBox', 'Y'): lchdf['HaloPosBox'][:, 1],
('HaloPosBox', 'Z'): lchdf['HaloPosBox'][:, 2]
})
nhalo_per_snapshot = dfhalo.groupby('snapnum').count()['HF_ID']
snapshots = dfhalo.groupby('snapnum').count().index.values
dfhalo = dfhalo.sort_values(by=['snapnum'])
else:
nhalo_per_snapshot = None
nhalo_per_snapshot = comm.bcast(nhalo_per_snapshot, root=0)
sigma_tot = []
out_hfid = []
out_lcid = []
out_redshift = []
out_snapshot = []
out_vrms = []
out_fov = []
## Run over Snapshots
for ss in range(len(nhalo_per_snapshot))[-2:]:
print('Snapshot %d of %d' % (ss, len(nhalo_per_snapshot)))
if comm_rank == 0:
dfhalosnap = dfhalo.loc[dfhalo['snapnum'] == snapshots[ss]]
# Load simulation
s = read_hdf5.snapshot(snapshots[ss], args["simdir"])
s.read(["Coordinates", "Masses", "GFM_StellarFormationTime"],
parttype=[0, 1, 4, 5])
scale = 1e-3 * s.header.hubble
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
print(': Redshift: %f' % s.header.redshift)
sh_hfid = dfhalosnap['HF_ID'].values
sh_id = dfhalosnap['ID'].values
sh_red = dfhalosnap['Halo_z'].values
sh_snap = dfhalosnap['snapnum'].values
sh_vrms = dfhalosnap['Vrms'].values
sh_fov = dfhalosnap['fov_Mpc'].values
sh_x = dfhalosnap[('HaloPosBox', 'X')].values
sh_y = dfhalosnap[('HaloPosBox', 'Y')].values
sh_z = dfhalosnap[('HaloPosBox', 'Z')].values
hist_edges = procdiv.histedges_equalN(sh_x, comm_size)
SH = procdiv.cluster_subhalos_lc(sh_hfid, sh_id, sh_red, sh_snap,
sh_vrms, sh_fov, sh_x, sh_y, sh_z,
hist_edges, comm_size)
## Dark Matter
DM = {
'Mass': (s.data['Masses']['dm']).astype('float64'),
'Pos': (s.data['Coordinates']['dm'] * scale).astype('float64')
}
## Gas
Gas = {
'Mass': (s.data['Masses']['gas']).astype('float64'),
'Pos': (s.data['Coordinates']['gas'] * scale).astype('float64')
}
## Stars
age = (
s.data['GFM_StellarFormationTime']['stars']).astype('float64')
Star = {
'Mass':
(s.data['Masses']['stars'][age >= 0]).astype('float64'),
'Pos': (s.data['Coordinates']['stars'][age >= 0, :] *
scale).astype('float64')
}
## BH
BH = {
'Mass': (s.data['Masses']['bh']).astype('float64'),
'Pos': (s.data['Coordinates']['bh'] * scale).astype('float64')
}
# Calculate overlap for particle cuboids
c = (const.c).to_value('km/s')
fov_rad = 4 * np.pi * (np.percentile(SH['Vrms'], 90) / c)**2
sh_dist = (cosmo.comoving_distance(
s.header.redshift)).to_value('Mpc')
alpha = 6 # multiplied by 4 because of Oguri&Marshall
overlap = 0.5 * alpha * fov_rad * sh_dist #[Mpc] half of field-of-view
print('Cuboids overlap is: %f [Mpc]' % overlap)
DM = procdiv.cluster_particles(DM, hist_edges, comm_size)
Gas = procdiv.cluster_particles(Gas, hist_edges, comm_size)
Star = procdiv.cluster_particles(Star, hist_edges, comm_size)
BH = procdiv.cluster_particles(BH, hist_edges, comm_size)
else:
overlap = None
hist_edges = None
SH = {
'HF_ID': None,
'ID': None,
'redshift': None,
'snapshot': None,
'Vrms': None,
'fov_Mpc': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
DM = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
Gas = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
Star = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
BH = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
# Broadcast variables over all processors
overlap = comm.bcast(overlap, root=0)
hist_edges = comm.bcast(hist_edges, root=0)
sh_split_size_1d = comm.bcast(SH['split_size_1d'], root=0)
dm_split_size_1d = comm.bcast(DM['split_size_1d'], root=0)
gas_split_size_1d = comm.bcast(Gas['split_size_1d'], root=0)
star_split_size_1d = comm.bcast(Star['split_size_1d'], root=0)
bh_split_size_1d = comm.bcast(BH['split_size_1d'], root=0)
SH = procdiv.scatter_subhalos_lc(SH,
sh_split_size_1d,
comm_rank,
comm,
root_proc=0)
DM = procdiv.scatter_particles(DM,
dm_split_size_1d,
comm_rank,
comm,
root_proc=0)
Gas = procdiv.scatter_particles(Gas,
gas_split_size_1d,
comm_rank,
comm,
root_proc=0)
Star = procdiv.scatter_particles(Star,
star_split_size_1d,
comm_rank,
comm,
root_proc=0)
BH = procdiv.scatter_particles(BH,
bh_split_size_1d,
comm_rank,
comm,
root_proc=0)
print(
': Proc. %d got: \n\t %d Sub-&Halos \n\t %d dark matter \n\t %d gas \n\t %d stars \n'
% (comm_rank, int(
sh_split_size_1d[comm_rank]), int(dm_split_size_1d[comm_rank]),
int(gas_split_size_1d[comm_rank]),
int(star_split_size_1d[comm_rank])))
## Run over Sub-&Halos
for ll in range(len(SH['ID'])):
print('Lens %d' % (ll))
#TODO: for z=0 sh_dist=0!!!
smlpixel = 20 # maximum smoothing pixel length
## BH
pos, indx = dmaps.select_particles(
BH['Pos'],
SH['Pos'][ll], #*a/h,
SH['fov_Mpc'][ll],
'box')
bh_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
BH['Mass'][indx],
SH['fov_Mpc'][ll],
args["ncells"],
hmax=smlpixel)
## Star
pos, indx = dmaps.select_particles(
Star['Pos'],
SH['Pos'][ll], #*a/h,
SH['fov_Mpc'][ll],
'box')
star_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
Star['Mass'][indx],
SH['fov_Mpc'][ll],
args["ncells"],
hmax=smlpixel)
## Gas
pos, indx = dmaps.select_particles(
Gas['Pos'],
SH['Pos'][ll], #*a/h
SH['fov_Mpc'][ll],
'box')
gas_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
Gas['Mass'][indx],
SH['fov_Mpc'][ll],
args["ncells"],
hmax=smlpixel)
## DM
pos, indx = dmaps.select_particles(
DM['Pos'],
SH['Pos'][ll], #*a/h
SH['fov_Mpc'][ll],
'box')
dm_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
DM['Mass'][indx],
SH['fov_Mpc'][ll], #[Mpc]
args["ncells"],
hmax=smlpixel)
sigmatotal = dm_sigma + gas_sigma + star_sigma + bh_sigma
# Make sure that density-map if filled
while 0.0 in sigmatotal:
smlpixel += 5
dm_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
DM['Mass'][indx],
SH['fov_Mpc'][ll], #[Mpc]
args["ncells"],
hmax=smlpixel)
sigmatotal = dm_sigma + gas_sigma + star_sigma + bh_sigma
#tmap.plotting(sigmatotal, args["ncells"],
# SH['fov_Mpc'][ll], SH['redshift'][ll])
sigma_tot.append(sigmatotal)
out_hfid.append(SH['HF_ID'][ll])
out_lcid.append(SH['ID'][ll])
out_redshift.append(SH['redshift'][ll])
out_snapshot.append(SH['snapshot'][ll])
out_vrms.append(SH['Vrms'][ll])
out_fov.append(SH['fov_Mpc'][ll])
if args["walltime"] - (time_start - time.time()) / (60 *
60) < 0.25:
fname = args["outbase"] + 'DM_' + label + '_lc.h5'
hf = h5py.File(fname, 'w')
hf.create_dataset('density_map', data=sigma_tot)
hf.create_dataset('HF_ID', data=np.asarray(out_hfid))
hf.create_dataset('LC_ID', data=np.asarray(out_lcid))
hf.create_dataset('redshift', data=np.asarray(out_redshift))
hf.create_dataset('snapshot', data=np.asarray(out_snapshot))
hf.create_dataset('Vrms', data=np.asarray(out_vrms))
hf.create_dataset('fov_Mpc', data=np.asarray(out_fov))
hf.close()
# Gather the Results
#comm.Barrier()
#comm.Gather(out_hfid, [rootout_hfid,split_sizes,displacements,MPI.DOUBLE], root=0)
fname = args["outbase"] + 'DM_' + label + '_lc.h5'
hf = h5py.File(fname, 'w')
hf.create_dataset('density_map', data=sigma_tot)
hf.create_dataset('HF_ID', data=np.asarray(out_hfid))
hf.create_dataset('LC_ID', data=np.asarray(out_lcid))
hf.create_dataset('redshift', data=np.asarray(out_redshift))
hf.create_dataset('snapshot', data=np.asarray(out_snapshot))
hf.create_dataset('Vrms', data=np.asarray(out_vrms))
hf.create_dataset('fov_Mpc', data=np.asarray(out_fov))
#RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88
hf.close()
def __init__(self, hfdir, snapdir, snapnum, halo_finder):
"""
Load Subhalo properties of snapshots into Dictionary
Use:
box = Lightcone(snapshot_file_name)
Input:
hfdir: halo-finder directory
snap_dir: snapshot directory
snapnum: snapshot number
halo_finder: Subfind, Rockstar or AHF
Output:
prop_box: dictionary with subhalo properties
boxlength: side length of simulated box in units used in simulation
(e.g. Mpc/h or kpc/h)
"""
if halo_finder == 'Subfind':
blockprint()
s = read_hdf5.snapshot(snapnum, hfdir)
s.group_catalog(["SubhaloIDMostbound", "SubhaloPos", "SubhaloVel",
"SubhaloMass", "SubhaloVmax", "SubhaloVelDisp",
"SubhaloVmaxRad", "SubhaloHalfmassRad"])
self.unitlength = s.header.unitlength
self.boxsize = s.header.boxsize
enableprint()
indx = np.where(s.cat["SubhaloMass"] > 10**11)[0]
#sub_id = self.subhalo_selection(pos, data['Mvir'], data['Vrms'], 0, 0)
prop_box = {'snapnum' : np.ones(len(s.cat['SubhaloIDMostbound'][indx])) * \
snapnum,
'ID' : s.cat['SubhaloIDMostbound'][indx],
'pos' : s.cat['SubhaloPos'][indx, :],
'pos_b' : s.cat['SubhaloPos'][indx, :],
'vel_b' : s.cat['SubhaloVel'][indx, :],
'Mvir_b' : s.cat['SubhaloMass'][indx],
'velmax_b' : s.cat['SubhaloVmax'][indx],
'veldisp_b' : s.cat['SubhaloVelDisp'][indx],
'rvmax_b' : s.cat['SubhaloVmaxRad'][indx],
'rhalfmass_b' : s.cat['SubhaloHalfmassRad'][indx]}
self.prop = prop_box
elif halo_finder == 'Rockstar':
hf_dir = hfdir + 'halos_%d.dat' % snapnum
data = pd.read_csv(hf_dir, sep='\s+', skiprows=np.arange(1, 16))
#if LengthUnit == 'kpc':
# pos = pd.concat([data['X']*1e-3, data['Y']*1e-3, data['Z']*1e-3], axis=1)
#else:
# pos = pd.concat([data['X'], data['Y'], data['Z']], axis=1)
self.boxsize = 62 #[Mpc]
vel = pd.concat([data['VX'], data['VY'], data['VZ']], axis=1)
sub_id = self.subhalo_selection(pos, data['Mvir'], data['Vrms'], 0, 0)
prop_box = {'snapnum' : snapnum*np.ones(len(sub_id[0])),
'ID' : data['#ID'].values[sub_id][0],
'pos' : pos.values[sub_id][0],
'pos_b' : pos.values[sub_id][0],
'vel_b' : vel.values[sub_id][0],
'Mvir_b' : data['Mvir'].values[sub_id][0],
'M200b_b' : data['M200b'].values[sub_id][0],
'velmax_b' : data['Vmax'].values[sub_id][0],
'veldisp_b' : data['Vrms'].values[sub_id][0],
'rvir_b' : data['Rvir'].values[sub_id][0],
'rs_b' : data['Rs'].values[sub_id][0],
'rvmax_b' : data['Rvmax'].values[sub_id][0],
'Halfmass_Radius' : data['Halfmass_Radius'].values[sub_id][0]}
self.prop= prop_box
elif halo_finder == 'AHF':
pass
def create_density_maps():
time_start = time.time()
# Get command line arguments
args = {}
args["simdir"] = sys.argv[1]
args["lcdir"] = sys.argv[2]
args["ncells"] = int(sys.argv[3])
args["sml"] = int(sys.argv[4])
args["walltime"] = int(sys.argv[5])
args["outbase"] = sys.argv[6]
label = args["simdir"].split('/')[-2].split('_')[2]
lclabel = args["lcdir"].split('/')[-1][-4]
# Characteristics
hflabel = whichhalofinder(args["lcdir"])
# Load LightCone Contents
lchdf = h5py.File(args["lcdir"], 'r')
dfhalo = pd.DataFrame({
'HF_ID': lchdf['HF_ID'].value,
'LC_ID': lchdf['LC_ID'].value,
'Halo_z': lchdf['Halo_z'].value,
'snapnum': lchdf['snapnum'].value,
'Vrms': lchdf['VelDisp'].value,
'fov_Mpc': lchdf['FOV'][:][1],
('HaloPosBox', 'X'): lchdf['HaloPosBox'][:, 0],
('HaloPosBox', 'Y'): lchdf['HaloPosBox'][:, 1],
('HaloPosBox', 'Z'): lchdf['HaloPosBox'][:, 2]
})
if len(dfhalo.index.values) > 2000:
# Limit number of halos, to keep comp. cost down
dfhalo = dfhalo.sample(n=2000)
print('There are %d galaxies in this lightcone' % len(dfhalo.index.values))
nhalo_per_snapshot = dfhalo.groupby('snapnum').count()['HF_ID']
print('devided over lightcone as:')
print(nhalo_per_snapshot)
snapshots = dfhalo.groupby('snapnum').count().index.values
dfhalo = dfhalo.sort_values(by=['snapnum'])
sigma_tot = []
out_hfid = []
out_lcid = []
out_redshift = []
out_snapnum = []
out_vrms = []
out_fov = []
## Run over Snapshots
for ss in range(len(nhalo_per_snapshot)):
print('Snapshot %d of %d' % (ss, len(nhalo_per_snapshot)))
dfhalosnap = dfhalo.loc[dfhalo['snapnum'] == snapshots[ss]]
# Load simulation
s = read_hdf5.snapshot(snapshots[ss], args["simdir"])
s.read(["Coordinates", "Masses", "GFM_StellarFormationTime"],
parttype=[0, 1, 4, 5])
scale = 1e-3 * s.header.hubble
print(': Redshift: %f' % s.header.redshift)
DM, Gas, Star, BH = particle_data(s.data, h, 'kpc')
## Run over Sub-&Halos
for ll in range(len(dfhalosnap.index)):
print('Lens %d of %d' % (ll, len(dfhalosnap.index)))
#TODO: for z=0 sh_dist=0!!!
# Define Cosmology
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
cosmosim = {
'omega_M_0': s.header.omega_m,
'omega_lambda_0': s.header.omega_l,
'omega_k_0': 0.0,
'h': s.header.hubble
}
smlpixel = args["sml"] # maximum smoothing pixel length
shpos = dfhalosnap.filter(regex='HaloPosBox').iloc[ll].values
#time_start = time.time()
## BH
pos, indx = dmaps.select_particles(
BH['Pos'],
shpos, #*a/h,
dfhalosnap['fov_Mpc'].values[ll],
'box')
bh_sigma = dmaps.projected_density_pmesh(
pos, BH['Mass'][indx], dfhalosnap['fov_Mpc'].values[ll],
args["ncells"])
## Star
pos, indx = dmaps.select_particles(
Gas['Pos'],
shpos, #*a/h,
dfhalosnap['fov_Mpc'].values[ll],
'box')
gas_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
Gas['Mass'][indx],
dfhalosnap['fov_Mpc'].values[ll],
args["ncells"],
hmax=smlpixel)
## Gas
pos, indx = dmaps.select_particles(
Star['Pos'],
shpos, #*a/h
dfhalosnap['fov_Mpc'].values[ll],
'box')
star_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
Star['Mass'][indx],
dfhalosnap['fov_Mpc'].values[ll],
args["ncells"],
hmax=smlpixel)
## DM
pos, indx = dmaps.select_particles(
DM['Pos'],
shpos, #*a/h
dfhalosnap['fov_Mpc'].values[ll],
'box')
dm_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
DM['Mass'][indx],
dfhalosnap['fov_Mpc'].values[ll], #[Mpc]
args["ncells"],
hmax=smlpixel)
sigmatotal = dm_sigma + gas_sigma + star_sigma + bh_sigma
# Make sure that density-map if filled
extention = 0
while 0.0 in sigmatotal and (extention < 60):
extention += 5
dm_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
DM['Mass'][indx],
dfhalosnap['fov_Mpc'].values[ll], #[Mpc]
args["ncells"],
hmax=smlpixel + extention)
sigmatotal = dm_sigma + gas_sigma + star_sigma + bh_sigma
sigma_tot.append(sigmatotal)
out_hfid.append(dfhalosnap['HF_ID'].values[ll])
out_lcid.append(dfhalosnap['LC_ID'].values[ll])
out_fov.append(dfhalosnap['fov_Mpc'].values[ll])
if args["walltime"] - (time_start - time.time()) / (60 *
60) < 0.25:
fname = args["outbase"] + 'DM_' + label + '_lc' + str(
lclabel) + '.h5'
hf = h5py.File(fname, 'w')
hf.create_dataset('density_map', data=sigma_tot)
hf.create_dataset('HF_ID', data=np.asarray(out_hfid))
hf.create_dataset('LC_ID', data=np.asarray(out_lcid))
hf.create_dataset('fov_Mpc', data=np.asarray(out_fov))
hf.close()
fname = args["outbase"] + 'DM_' + label + '_lc_' + str(lclabel) + '.h5'
hf = h5py.File(fname, 'w')
hf.create_dataset('density_map', data=sigma_tot)
hf.create_dataset('HF_ID', data=np.asarray(out_hfid))
hf.create_dataset('LC_ID', data=out_lcid)
hf.create_dataset('fov_Mpc', data=np.asarray(out_fov))
#RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88
hf.close()
args = {}
args["simdir"] = sys.argv[1]
args["outdir"] = sys.argv[2]
args["simtype"] = sys.argv[3]
args["nsnap"] = sys.argv[4].split(" ")
args["num_child_voxel"] = int(sys.argv[5])
args["Lbox"] = float(sys.argv[6])
memory_cutoff = 1e8
# Run through snapshots
for ii in range(len(args["nsnap"])):
args["nsnap"][ii] = int(args["nsnap"][ii])
s = read_hdf5.snapshot(
args["nsnap"][ii], args["simdir"], check_total_particle_number=True
)
bname = args["outdir"] + "%s_s%d_v%d" % (
args["simtype"],
args["nsnap"][ii],
args["num_child_voxel"],
)
args["Lbox"] = args["Lbox"] * 1e3 / s.header.hubble
# Read subhalos
#s.group_catalog(["SubhaloPos"])
#pos = dif.voxeling(s.cat["SubhaloPos"], args)
#pos = pd.DataFrame(pos, dtype=np.int32)
#pos.columns = ["x", "y", "z"]
#pos = dif.counting(pos)
#arr = dif.structuring(pos, args)
def __init__(self, simulation, snapnum):
'''
Class to read halo catalogs from simulation
simulation: name of the simulation
snapnum: snapshot number to read
'''
# Read snapshot
self.simulation = simulation
#h5_dir = '/cosma6/data/dp004/dc-arno1/SZ_project/full_physics/L62_N512_%s_kpc/'%self.simulation
h5_dir = '/cosma5/data/dp004/dc-cues1/TNG300-1/'
self.snapnum = snapnum
self.snapshot = read_hdf5.snapshot(snapnum, h5_dir)
self.boxsize = self.snapshot.header.boxsize #kpc
# Useful definitions
self.dm = 1
self.stars = 4
self.dm_particle_mass = self.snapshot.header.massarr[self.dm] * 1.e10
'''
param_file = '/cosma6/data/dp004/dc-arno1/SZ_project/full_physics/L62_N512_GR_kpc/parameters-usedvalues'
with open(param_file) as search:
for line in search:
line = line.rstrip() # remove '\n' at end of line
if line.split()[0] == 'OmegaBaryon':
omega_b = float(line.split()[-1])
self.mean_density = (self.snapshot.header.omega_m - omega_b) * self.snapshot.const.rho_crit
'''
self.stellar_mass_thresh = 1.e9
#self.halo_mass_thresh = 6.e9
self.halo_mass_thresh = self.dm_particle_mass * 100. # at least 100 particles
print('Minimum stellar mass : %.2E' % self.stellar_mass_thresh)
print('Minimum DM halo mass : %.2E' % self.halo_mass_thresh)
# Load fields that will be used
useful_properties = ['GroupMass', 'Group_M_Crit200', 'Group_R_Crit200',\
'GroupMassType', 'GroupNsubs', 'GroupLenType', 'GroupPos', 'GroupCM','SubhaloCM',\
'SubhaloMassType','SubhaloMass', 'SubhaloVelDisp', 'SubhaloVmax','GroupFirstSub',\
'SubhaloHalfmassRadType','GroupPos', 'SubhaloVmaxRad', 'SubhaloSpin', 'SubhaloMassType']
self.snapshot.group_catalog(useful_properties)
# Get only resolved halos
self.halo_mass_cut = self.snapshot.cat[
'Group_M_Crit200'][:] > self.halo_mass_thresh
self.N_subhalos = (self.snapshot.cat['GroupNsubs']).astype(np.int64)
self.N_particles = (self.snapshot.cat['GroupLenType'][:,
self.dm]).astype(
np.int64)
self.group_offset = (np.cumsum(self.N_particles) -
self.N_particles).astype(np.int64)
self.group_offset = self.group_offset[self.halo_mass_cut]
self.subhalo_offset = (np.cumsum(self.N_subhalos) -
self.N_subhalos).astype(np.int64)
self.subhalo_offset = self.subhalo_offset[self.halo_mass_cut]
self.N_subhalos = self.N_subhalos[self.halo_mass_cut]
self.N_particles = self.N_particles[self.halo_mass_cut]
self.N_halos = self.N_subhalos.shape[0]
self.N_gals, self.M_stars = self.Number_of_galaxies()
self.logM_stars = np.log10(self.M_stars)
self.load_inmidiate_features()
print('%d resolved halos found.' % self.N_halos)
'''
def create_density_maps():
# Get command line arguments
args = {}
if comm_rank == 0:
print(':Registered %d processes' % comm_size)
args["simdir"] = sys.argv[1]
args["hfdir"] = sys.argv[2]
args["snapnum"] = int(sys.argv[3])
args["zs"] = float(sys.argv[4]) / 10
args = comm.bcast(args)
label = args["simdir"].split('/')[-2].split('_')[2]
# Organize devision of Sub-&Halos over Processes on Proc. 0
if comm_rank == 0:
# Load simulation
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
s.read(["Coordinates", "Masses", "GFM_StellarFormationTime"],
parttype=[0, 1, 4]) #[0,1,4]
scale = 1e-3 * s.header.hubble
# Define Cosmology
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
cosmosim = {
'omega_M_0': s.header.omega_m,
'omega_lambda_0': s.header.omega_l,
'omega_k_0': 0.0,
'h': s.header.hubble
}
redshift = s.header.redshift
print(': Redshift: %f' % redshift)
# Sort Sub-&Halos over Processes
df = pd.read_csv(args["hfdir"] + 'halos_%d.dat' % args["snapnum"],
sep='\s+',
skiprows=16,
usecols=[0, 2, 4, 9, 10, 11],
names=['ID', 'Mvir', 'Vrms', 'X', 'Y', 'Z'])
df = df[df['Mvir'] > 5e11]
sh_id = df['ID'].values.astype('float64')
sh_vrms = df['Vrms'].values.astype('float64')
sh_x = df['X'].values.astype('float64')
sh_y = df['Y'].values.astype('float64')
sh_z = df['Z'].values.astype('float64')
del df
hist_edges = procdiv.histedges_equalN(sh_x, comm_size)
SH = procdiv.cluster_subhalos(sh_id, sh_vrms, sh_x, sh_y, sh_z,
hist_edges, comm_size)
# Calculate overlap for particle cuboids
c = (const.c).to_value('km/s')
fov_rad = 4 * np.pi * (np.percentile(SH['Vrms'], 90) / c)**2
sh_dist = (cosmo.comoving_distance(redshift)).to_value('Mpc')
alpha = 6 # multiplied by 4 because of Oguri&Marshall
overlap = 0.5 * alpha * fov_rad * sh_dist #[Mpc] half of field-of-view
print('Cuboids overlap is: %f [Mpc]' % overlap)
# Sort Particles over Processes
## Dark Matter
DM = {
'Mass': (s.data['Masses']['dm']).astype('float64'),
'Pos': (s.data['Coordinates']['dm'] * scale).astype('float64')
}
DM = procdiv.cluster_particles(DM, hist_edges, comm_size)
## Gas
Gas = {
'Mass': (s.data['Masses']['gas']).astype('float64'),
'Pos': (s.data['Coordinates']['gas'] * scale).astype('float64')
}
Gas = procdiv.cluster_particles(Gas, hist_edges, comm_size)
## Stars
age = (s.data['GFM_StellarFormationTime']['stars']).astype('float64')
Star = {
'Mass': (s.data['Masses']['stars'][age >= 0]).astype('float64'),
'Pos': (s.data['Coordinates']['stars'][age >= 0, :] *
scale).astype('float64')
}
del age
Star = procdiv.cluster_particles(Star, hist_edges, comm_size)
else:
c = None
alpha = None
overlap = None
cosmosim = None
cosmo = None
redshift = None
hist_edges = None
SH = {
'ID': None,
'Vrms': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
DM = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
Gas = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
Star = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
# Broadcast variables over all processors
sh_split_size_1d = comm.bcast(SH['split_size_1d'], root=0)
dm_split_size_1d = comm.bcast(DM['split_size_1d'], root=0)
gas_split_size_1d = comm.bcast(Gas['split_size_1d'], root=0)
star_split_size_1d = comm.bcast(Star['split_size_1d'], root=0)
c = comm.bcast(c, root=0)
alpha = comm.bcast(alpha, root=0)
overlap = comm.bcast(overlap, root=0)
cosmo = comm.bcast(cosmo, root=0)
redshift = comm.bcast(redshift, root=0)
hist_edges = comm.bcast(hist_edges, root=0)
SH = procdiv.scatter_subhalos(SH,
sh_split_size_1d,
comm_rank,
comm,
root_proc=0)
DM = procdiv.scatter_particles(DM,
dm_split_size_1d,
comm_rank,
comm,
root_proc=0)
Gas = procdiv.scatter_particles(Gas,
gas_split_size_1d,
comm_rank,
comm,
root_proc=0)
Star = procdiv.scatter_particles(Star,
star_split_size_1d,
comm_rank,
comm,
root_proc=0)
print(
': Proc. %d got: \n\t %d Sub-&Halos \n\t %d dark matter \n\t %d gas \n\t %d stars \n'
% (comm_rank, int(sh_split_size_1d[comm_rank]),
int(dm_split_size_1d[comm_rank]), int(gas_split_size_1d[comm_rank]),
int(star_split_size_1d[comm_rank])))
## Run over Sub-&Halos
zl = redshift
zs = args["zs"]
ncells = [512, 256, 128]
nparts = [1, 2, 4, 8]
M200 = np.ones(len(SH['ID']))
ID = np.ones(len(SH['ID']))
Rein = np.ones((len(SH['ID']), len(ncells), len(nparts)))
for ll in range(len(SH['ID'])):
# Define field-of-view
fov_rad = 4 * np.pi * (SH['Vrms'][ll] / c)**2
sh_dist = (cosmo.comoving_distance(redshift)).to_value('Mpc')
fov_Mpc = alpha * fov_rad * sh_dist #[Mpc] is it the diameter?
fov_arc = (fov_Mpc / cf.Da(zl, cosmo) * u.rad).to_value('arcsec')
sigma_cr = sigma_crit(zl, zs, cosmo).to_value('Msun Mpc-2')
# Check cuboid boundary condition,
# that all surface densities are filled with particles
if ((SH['Pos'][ll,0]-hist_edges[comm_rank] < overlap) or
(hist_edges[comm_rank+1]-overlap < \
SH['Pos'][ll,0]-hist_edges[comm_rank])):
if fov_Mpc * 0.45 > overlap:
print("FOV is bigger than cuboids overlap: %f > %f" % \
(fov_Mpc*0.45, overlap))
continue
## Run over different Ncells
for cc in range(len(ncells)):
dsx_arc = fov_arc / ncells[cc] #[arcsec] pixel size
## Run over particle reductions
for mm in range(len(nparts)):
smlpixel = 20 # maximum smoothing pixel length
pos, indx = dmap.select_particles(
Gas['Pos'],
SH['Pos'][ll], #*a/h,
fov_Mpc,
'box')
gas_sigma = dmap.projected_density_pmesh_adaptive(
pos[::nparts[mm], :],
Gas['Mass'][indx][::nparts[mm]],
fov_Mpc,
ncells[cc],
hmax=smlpixel)
pos, indx = dmap.select_particles(
Star['Pos'],
SH['Pos'][ll], #*a/h,
fov_Mpc,
'box')
star_sigma = dmap.projected_density_pmesh_adaptive(
pos[::nparts[mm], :],
Star['Mass'][indx][::nparts[mm]],
fov_Mpc,
ncells[cc],
hmax=smlpixel)
pos, indx = dmap.select_particles(
DM['Pos'],
SH['Pos'][ll], #*a/h,
fov_Mpc,
'box')
dm_sigma = dmap.projected_density_pmesh_adaptive(
pos[::nparts[mm], :],
DM['Mass'][indx][::nparts[mm]],
fov_Mpc, #[Mpc]
ncells[cc],
hmax=smlpixel)
tot_sigma = dm_sigma + gas_sigma + star_sigma
# Make sure that density-map is filled
while 0.0 in tot_sigma:
smlpixel += 5
dm_sigma = dmap.projected_density_pmesh_adaptive(
pos[::nparts[mm], :],
DM['Mass'][indx][::nparts[mm]],
fov_Mpc, #[Mpc]
ncells[cc],
hmax=smlpixel)
tot_sigma = dm_sigma + gas_sigma + star_sigma
#tmap.plotting(tot_sigma, ncells[cc], fov_Mpc, zl)
# initialize the coordinates of grids (light rays on lens plan)
lpv = np.linspace(-(fov_arc - dsx_arc) / 2,
(fov_arc - dsx_arc) / 2, ncells[cc])
lp1, lp2 = np.meshgrid(lpv, lpv) #[arcsec]
fig = plt.figure()
ax = fig.add_subplot(111)
# Calculate convergence map
kappa = tot_sigma / sigma_cr
# Calculate Deflection Maps
alpha1, alpha2, mu_map, phi, detA, lambda_t = cal_lensing_signals(
kappa, fov_arc, ncells[cc])
# Calculate Einstein Radii
Rein[ll, cc, mm] = einstein_radii(lp1, lp2, detA, lambda_t, zl,
cosmo, ax, 'med', ll)
#print('Rein = %f' % Rein[ll, cc, mm])
ID[ll] = SH['ID'][ll]
#plt.close(fig)
output = {}
for cc in range(len(ncells)):
for mm in range(len(nparts)):
output[(str(ncells[cc]), str(nparts[mm]))] = Rein[:, cc, mm]
df = pd.DataFrame.from_dict(output)
df['ID'] = ID
#self.df = pd.concat([self.df, dfp], axis=1)
fname = 'DMConvTest_' + label + '_' + str(comm_rank) + '_zs150.h5'
df.to_hdf(fname, key='Rein', mode='w')
plt.close(fig)
def create_density_maps():
# Get command line arguments
args = {}
if comm_rank == 0:
print(':Registered %d processes' % comm_size)
args["simdir"] = sys.argv[1]
args["hfname"] = sys.argv[2]
args["hfdir"] = sys.argv[3]
args["snapnum"] = int(sys.argv[4])
args["ncells"] = int(sys.argv[5])
args["smlpixel"] = int(sys.argv[6])
args["outbase"] = sys.argv[7]
args = comm.bcast(args)
label = args["simdir"].split('/')[-2].split('_')[2]
# Organize devision of Sub-&Halos over Processes on Proc. 0
if comm_rank == 0:
# Load simulation
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
s.read(["Coordinates", "Masses", "GFM_StellarFormationTime"],
parttype=[0, 1, 4, 5])
unitlength = dmaps.define_unit(s.header.unitlength)
# Define Cosmology
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
redshift = s.header.redshift
print(': Redshift: %f' % redshift)
# Sort Sub-&Halos over Processes
SH = subhalo_data(args["hfdir"], args["hfname"], args["snapnum"],
s.header.hubble, s.header.unitlength)
hist_edges = procdiv.histedges_equalN(SH['X'], comm_size)
SH = procdiv.cluster_subhalos_box(SH, hist_edges, comm_size)
# Calculate overlap for particle cuboids
c = (const.c).to_value('km/s')
fov_rad = 4 * np.pi * (np.percentile(SH['Vrms'], 90) / c)**2
sh_dist = (cosmo.comoving_distance(redshift)).to_value(unitlength)
alpha = 2 # multiplied by 4 because of Oguri&Marshall
overlap = 0.5 * alpha * fov_rad * sh_dist # half of field-of-view
print('Cuboids overlap is: %f [%s]' % (overlap, unitlength))
# Sort Particles over Processes
DM, Gas, Star, BH = particle_data(s.data, s.header.hubble, unitlength)
DM = procdiv.cluster_particles(DM, hist_edges, comm_size)
Gas = procdiv.cluster_particles(Gas, hist_edges, comm_size)
Star = procdiv.cluster_particles(Star, hist_edges, comm_size)
BH = procdiv.cluster_particles(BH, hist_edges, comm_size)
else:
c = None
alpha = None
overlap = None
unitlength = None
cosmo = None
redshift = None
hist_edges = None
SH = {
'ID': None,
'Vrms': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
DM = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
Gas = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
Star = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
BH = {
'Mass': None,
'X': None,
'Y': None,
'Z': None,
'split_size_1d': None,
'split_disp_1d': None
}
# Broadcast variables over all processors
sh_split_size_1d = comm.bcast(SH['split_size_1d'], root=0)
sh_split_disp_1d = comm.bcast(SH['split_disp_1d'], root=0)
dm_split_size_1d = comm.bcast(DM['split_size_1d'], root=0)
dm_split_disp_1d = comm.bcast(DM['split_disp_1d'], root=0)
gas_split_size_1d = comm.bcast(Gas['split_size_1d'], root=0)
gas_split_disp_1d = comm.bcast(Gas['split_disp_1d'], root=0)
star_split_size_1d = comm.bcast(Star['split_size_1d'], root=0)
star_split_disp_1d = comm.bcast(Star['split_disp_1d'], root=0)
bh_split_size_1d = comm.bcast(BH['split_size_1d'], root=0)
bh_split_disp_1d = comm.bcast(BH['split_disp_1d'], root=0)
c = comm.bcast(c, root=0)
unitlength = comm.bcast(unitlength, root=0)
alpha = comm.bcast(alpha, root=0)
overlap = comm.bcast(overlap, root=0)
cosmo = comm.bcast(cosmo, root=0)
redshift = comm.bcast(redshift, root=0)
hist_edges = comm.bcast(hist_edges, root=0)
SH = procdiv.scatter_subhalos(SH,
sh_split_size_1d,
comm_rank,
comm,
root_proc=0)
DM = procdiv.scatter_particles(DM,
dm_split_size_1d,
comm_rank,
comm,
root_proc=0)
Gas = procdiv.scatter_particles(Gas,
gas_split_size_1d,
comm_rank,
comm,
root_proc=0)
Star = procdiv.scatter_particles(Star,
star_split_size_1d,
comm_rank,
comm,
root_proc=0)
BH = procdiv.scatter_particles(BH,
star_split_size_1d,
comm_rank,
comm,
root_proc=0)
print(
': Proc. %d got: \n\t %d Sub-&Halos \n\t %d dark matter \n\t %d gas \n\t %d stars \n'
% (comm_rank, int(sh_split_size_1d[comm_rank]),
int(dm_split_size_1d[comm_rank]), int(gas_split_size_1d[comm_rank]),
int(star_split_size_1d[comm_rank])))
sigma_tot = []
subhalo_id = []
FOV = []
## Run over Sub-&Halos
for ll in range(len(SH['ID'])):
# Define field-of-view edge-length
fov_rad = 4 * np.pi * (SH['Vrms'][ll] / c)**2
#TODO: for z=0 sh_dist=0!!!
sh_dist = (cosmo.comoving_distance(redshift)).to_value(unitlength)
alpha = 1.4
fov = alpha * fov_rad * sh_dist #[kpc] edge-length of box
# Check cuboid boundary condition,
# that all surface densities are filled with particles
if ((SH['Pos'][ll][0]-hist_edges[comm_rank] < overlap) or
(hist_edges[comm_rank+1]-overlap < \
SH['Pos'][ll][0]-hist_edges[comm_rank])):
if fov * 0.45 > overlap:
print("FOV is bigger than cuboids overlap: %f > %f" % \
(fov*0.45, overlap))
continue
## BH
pos, indx = dmaps.select_particles(
BH['Pos'],
SH['Pos'][ll], #*a/h,
fov,
'box')
bh_sigma = dmaps.projected_density_pmesh(pos, BH['Mass'][indx], fov,
args["ncells"])
## Gas
pos, indx = dmaps.select_particles(
Gas['Pos'],
SH['Pos'][ll], #*a/h,
fov,
'box')
gas_sigma = dmaps.projected_density_pmesh_adaptive(
pos, Gas['Mass'][indx], fov, args["ncells"], hmax=args["smlpixel"])
## Star
pos, indx = dmaps.select_particles(
Star['Pos'],
SH['Pos'][ll], #*a/h,
fov,
'box')
star_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
Star['Mass'][indx],
fov,
args["ncells"],
hmax=args["smlpixel"])
## DM
pos, indx = dmaps.select_particles(
DM['Pos'],
SH['Pos'][ll], #*a/h,
fov,
'box')
dm_sigma = dmaps.projected_density_pmesh_adaptive(
pos, DM['Mass'][indx], fov, args["ncells"], hmax=args["smlpixel"])
sigmatotal = dm_sigma + gas_sigma + star_sigma
# Make sure that density-map if filled
extention = 0
while (0.0 in sigmatotal) and (extention < 60):
extention += 5
dm_sigma = dmaps.projected_density_pmesh_adaptive(
pos,
DM['Mass'][indx],
fov,
args["ncells"],
hmax=args["smlpixel"] + extention)
sigmatotal = dm_sigma + gas_sigma + star_sigma
#tmap.plotting(sigmatotal, args["ncells"], fov, 0.57)
sigma_tot.append(sigmatotal)
subhalo_id.append(int(SH['ID'][ll]))
FOV.append(fov)
fname = args["outbase"] + 'z_' + str(
args["snapnum"]) + '/' + 'DM_' + label + '_' + str(comm_rank) + '.h5'
hf = h5py.File(fname, 'w')
hf.create_dataset('DMAP',
data=sigma_tot) # density map in unit of simulation
hf.create_dataset('HFID',
data=np.asarray(subhalo_id)) # Rockstar sub-&halo id
hf.create_dataset(
'FOV', data=np.asarray(FOV)) # field-of-view in units #[kpc, Mpc]
#RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88
hf.close()
def __init__(self, snapnum=99):
'''
Class to read halo catalogs from simulation
snapnum: snapshot number to read
'''
# Read snapshot
h5_dir = '/cosma7/data/TNG/TNG300-1/'
self.snapnum = snapnum
self.snapshot = read_hdf5.snapshot(snapnum, h5_dir)
self.boxsize = self.snapshot.header.boxsize #kpc
# Useful definitions
self.dm = 1
self.stars = 4
self.dm_particle_mass = self.snapshot.header.massarr[self.dm] * 1.e10
self.stellar_mass_thresh = 1.e9
#self.halo_mass_thresh = self.dm_particle_mass * 100. # at least 100 particles
self.halo_mass_thresh = 1.e11
print('Minimum stellar mass : %.2E' % self.stellar_mass_thresh)
print('Minimum DM halo mass : %.2E' % self.halo_mass_thresh)
# Load fields that will be used
useful_properties = [
'GroupFirstSub', 'Group_M_Crit200', 'GroupNsubs', 'GroupPos',
'GroupVel', 'Group_R_Crit200', 'SubhaloMassType', 'GroupMassType',
'SubhaloCM', 'GroupCM', 'SubhaloMass', 'SubhaloMassInHalfRad',
'SubhaloSpin', 'SubhaloVelDisp', 'SubhaloVmax'
]
self.snapshot.group_catalog(useful_properties)
self.N_subhalos = (self.snapshot.cat['GroupNsubs']).astype(np.int64)
# Get only resolved halos
self.halo_mass_cut = self.snapshot.cat[
'Group_M_Crit200'][:] > self.halo_mass_thresh
#self.group_offset = (np.cumsum(self.N_particles) - self.N_particles).astype(np.int64)
#self.group_offset = self.group_offset[self.halo_mass_cut]
self.subhalo_offset = (np.cumsum(self.N_subhalos) -
self.N_subhalos).astype(np.int64)
self.subhalo_offset = self.subhalo_offset[self.halo_mass_cut]
self.N_subhalos = self.N_subhalos[self.halo_mass_cut]
self.N_halos = self.N_subhalos.shape[0]
print('%d resolved halos found.' % self.N_halos)
self.N_gals, self.M_stars = self.Number_of_galaxies()
print('%d resolved galaxies found.' % np.sum(self.N_gals))
self.logM_stars = np.log10(self.M_stars)
self.load_inmidiate_features()
self.compute_fsub_unbound()
self.compute_x_offset()
def lensing_signal():
# Get command line arguments
args = {}
args["simdir"] = sys.argv[1]
args["dmdir"] = sys.argv[2]
args["lcdir"] = sys.argv[3]
args["outbase"] = sys.argv[4]
args["ncells"] = int(sys.argv[5])
#args["simdir"] = '/cosma6/data/dp004/dc-arno1/SZ_project/full_physics/L62_N512_F5_kpc/'
#args["dmdir"] = '/cosma5/data/dp004/dc-beck3/StrongLensing/DensityMap/full_physics/L62_N512_F5_kpc/Lightcone/'
#args["lcdir"] = '/cosma5/data/dp004/dc-beck3/StrongLensing/LightCone/full_physics/Rockstar/LC_SN_L62_N512_F5_kpc'
#args["outbase"] = '/cosma5/data/dp004/dc-beck3/StrongLensing/LensingMap/full_physics/Rockstar/L62_N512_F5_kpc/Lightcone/'
#args["ncells"] = 512
# Names of all available Density maps
dmfile = glob.glob(args["dmdir"]+'*.h5')
dmfile.sort(key = lambda x: x[-4])
# Names of all available Lightcones
lcfile = glob.glob(args["lcdir"]+'*.h5')
lcfile.sort(key = lambda x: x[-4])
lenslistinit(); srclistinit()
# Run through files
for ff in range(len(dmfile)):
print('\n')
print('------------- \n Reading Files: \n%s\n%s' % \
(dmfile[ff].split('/')[-2:], lcfile[ff].split('/')[-2:]))
# Load density maps
dmf = h5py.File(dmfile[ff], 'r')
dmdf = pd.DataFrame({'HF_ID' : dmf['HF_ID'],
'LC_ID' : dmf['LC_ID'],
'fov_Mpc' : dmf['fov_Mpc']})
s1 = pd.Series(dict(list(enumerate(dmf['density_map']))), index=dmdf.index)
dmdf['density_map'] = s1
dmdf = dmdf.set_index('LC_ID')
# Load Lightcones
lcf = h5py.File(lcfile[ff], 'r')
lcdf = pd.DataFrame({'HF_ID' : lcf['HF_ID'].value,
'LC_ID' : lcf['LC_ID'].value,
'zl' : lcf['Halo_z'].value,
'vrms' : lcf['VelDisp'].value,
'snapnum' : lcf['snapnum'].value,
'fov_Mpc' : lcf['FOV'][:][1]})
lcdf = lcdf.set_index('LC_ID')
srcdf = {'Src_ID' : lcf['Src_ID'].value,
'zs' : lcf['Src_z'].value,
'SrcPosSky' : lcf['SrcPosSky'].value,
'SrcAbsMag' : lcf['SrcAbsMag'].value}
print('The minimum Vrms is %f' % (np.min(lcdf['vrms'].values)))
dmdf = dmdf.sort_values(by=['LC_ID'])
lcdf = lcdf.sort_values(by=['LC_ID'])
# sanity check
assert len(lcdf.index.intersection(dmdf.index)) == len(dmdf.index.values)
lcdf['density_map'] = dmdf['density_map']
#lcdf = lcdf.sort_values(by=['snapnum'])
s = read_hdf5.snapshot(45, args["simdir"])
# Cosmological Parameters
cosmo = LambdaCDM(H0=s.header.hubble*100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
# Run through lenses
print('There are %d lenses in file' % (len(lcdf.index.values)))
for ll in range(len(lcdf.index.values)):
lens = lcdf.iloc[ll]
#print('working on lens %d' % lens['HF_ID'])
# convert. box size and pixels size from ang. diam. dist. to arcsec
FOV_arc = (lens['fov_Mpc']/cf.Da(lens['zl'], cosmo)*u.rad).to_value('arcsec')
dsx_arc = FOV_arc/args["ncells"] #[arcsec] pixel size
# initialize the coordinates of grids (light rays on lens plan)
lpv = np.linspace(-(FOV_arc-dsx_arc)/2, (FOV_arc-dsx_arc)/2, args["ncells"])
lp1, lp2 = np.meshgrid(lpv, lpv) #[arcsec]
zs, Src_ID, SrcPosSky = lt.source_selection(
srcdf['Src_ID'], srcdf['zs'], srcdf['SrcPosSky'],
lcdf.index.values[ll])
# Run through sources
check_for_sources = 0
fig = plt.figure()
ax = fig.add_subplot(111)
for ss in range(len(Src_ID)):
# Calculate critical surface density
sigma_cr = lt.sigma_crit(lens['zl'],
zs[ss],
cosmo).to_value('Msun Mpc-2')
# convert source position from Mpc to arcsec
beta = lt.mpc2arc(SrcPosSky[ss])
beta = [bb*1e-3 for bb in beta]
# Calculate convergence map
kappa = lens['density_map']/sigma_cr
#fig = plt.figure()
#ax = fig.add_subplot(111)
# Calculate Deflection Maps
alpha1, alpha2, mu_map, phi, detA, lambda_t = lt.cal_lensing_signals(
kappa, FOV_arc, args["ncells"])
# Calculate Einstein Radii in [arcsec]
Ncrit, curve_crit, curve_crit_tan, Rein = lt.einstein_radii(
lp1, lp2, detA, lambda_t, lens['zl'], cosmo, ax, 'med')
#if Rein == 0. or math.isnan(Rein):
# print('!!! Rein is 0. or NaN')
# continue
# Calculate Time-Delay and Magnification
n_imgs, delta_t, mu, theta = lt.timedelay_magnification(
mu_map, phi, dsx_arc, args["ncells"],
lp1, lp2, alpha1, alpha2, beta,
zs[ss], lens['zl'], cosmo)
if n_imgs > 1:
# Tree Branch 2
s_srcID.append(Src_ID[ss])
s_zs.append(zs[ss])
s_beta.append(beta)
#s_lensplane.append([lp1, lp2])
s_detA.append(detA)
s_tancritcurves.append(curve_crit_tan)
s_einsteinradius.append(Rein) #[arcsec]
# Tree Branch 3
s_theta.append(theta)
s_deltat.append(delta_t)
s_mu.append(mu)
check_for_sources = 1
#print(' -> %d multiple lensed images' % (n_imgs))
if check_for_sources == 1:
# Tree Branch 1
l_HFID.append(int(lens['HF_ID']))
l_haloID.append(int(lcdf.index.values[ll]))
l_snapnum.append(int(lens['snapnum']))
l_zl.append(lens['zl'])
#l_haloposbox.append(HaloPosBox[ll])
# Tree Branch 2
l_srcID.append(s_srcID)
l_zs.append(s_zs)
l_srcbeta.append(s_beta)
#l_lensplane.append(s_lensplane)
l_detA.append(s_detA)
l_tancritcurves.append(s_tancritcurves)
l_einsteinradius.append(s_einsteinradius)
# Tree Branch 3
l_srctheta.append(s_theta)
l_deltat.append(s_deltat)
l_mu.append(s_mu)
srclistinit()
check_for_sources = 0
print('Save data of lens %d' % ll)
########## Save to File ########
tree = plant_Tree()
## Tree Branches of Node 1 : Lenses
#tree['HF_ID'] = l_HFID
#tree['snapnum'] = args["snapnum"]
#tree['zl'] = redshift
#tree['zs'] = zs
## Tree Branches of Node 1 : Sources
#tree['Sources']['beta'] = l_srcbeta
#tree['Sources']['TCC'] = l_tancritcurves
#tree['Sources']['Rein'] = l_einsteinradius
#for imgs in range(len(l_mu)):
# # Tree Branches of Node 2 : Multiple Images
# tree['Sources']['theta'][imgs] = l_srctheta[imgs]
# tree['Sources']['delta_t'][imgs] = l_deltat[imgs]
# tree['Sources']['mu'][imgs] = l_mu[imgs]
# Tree Branches of Node 1 : Lenses
tree['LC_ID'] = l_haloID
tree['HF_ID'] = l_HFID
tree['snapnum'] = l_snapnum
tree['zl'] = l_zl
#tree['HaloPosBox'] = l_haloposbox
for sid in range(len(l_haloID)):
# Tree Branches of Node 2 : Sources
tree['Sources']['Src_ID'][sid] = l_srcID[sid]
tree['Sources']['zs'][sid] = l_zs[sid]
tree['Sources']['beta'][sid] = l_srcbeta[sid]
#tree['Sources']['LP'][sid] = l_lensplane[sid]
tree['Sources']['detA'][sid] = l_detA[sid]
tree['Sources']['TCC'][sid] = l_tancritcurves[sid]
tree['Sources']['Rein'][sid] = l_einsteinradius[sid]
for imgs in range(len(l_srcID[sid])):
# Tree Branches of Node 3 : Multiple Images
tree['Sources']['theta'][sid][imgs] = l_srctheta[sid][imgs]
tree['Sources']['delta_t'][sid][imgs] = l_deltat[sid][imgs]
tree['Sources']['mu'][sid][imgs] = l_mu[sid][imgs]
label = args["simdir"].split('/')[-2].split('_')[2]
filename = args["outbase"]+'LM_%s.pickle' % (label)
filed = open(filename, 'wb')
pickle.dump(tree, filed)
filed.close()
plt.close(fig)
def dyn_vs_lensing_mass(CPUs, sim_dir, sim_phy, sim_name, hfname, lc_dir,
HQ_dir):
# protect the 'entry point' for Windows OS
# if __name__ == '__main__':
# after importing numpy, reset the CPU affinity of the parent process so
# that it will use all cores
os.system("taskset -p 0xff %d" % os.getpid())
# Run through simulations
for sim in range(len(sim_dir)):
# File for lens & source properties
lc_file = lc_dir[sim] + hfname + '/LC_SN_' + sim_name[
sim] + '_rndseed1.h5'
# File for lensing-maps
lm_dir = HQ_dir + '/LensingMap/' + sim_phy[
sim] + hfname + '/' + sim_name[sim] + '/'
# Simulation Snapshots
snapfile = sim_dir[sim]
# Units of Simulation
scale = rf.simulation_units(sim_dir[sim])
# Cosmological Parameters
s = read_hdf5.snapshot(45, snapfile)
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
h = s.header.hubble
a = 1 / (1 + s.header.redshift)
# Load LightCone Contents
LC = rf.LightCone_with_SN_lens(lc_file, hfname)
# Sort Lenses according to Snapshot Number (snapnum)
indx = np.argsort(LC['snapnum'])
Halo_ID = LC['Halo_ID'][indx]
# Prepatre Processes to be run in parallel
jobs = []
manager = multiprocessing.Manager()
results_per_cpu = manager.dict()
snapfile = sim_dir[sim] + 'snapdir_%03d/snap_%03d'
for cpu in range(CPUs):
# Load LensingMaps Contents
lm_file = lm_dir + 'LM_Proc_' + str(cpu) + '_0.pickle'
p = Process(target=la.dyn_vs_lensing_mass,
name='Proc_%d' % cpu,
args=(cpu, LC, lm_file, snapfile, h, scale, HQ_dir,
sim, sim_phy, sim_name, hfname, cosmo,
results_per_cpu))
p.start()
jobs.append(p)
# Run Processes in parallel
# Wait until every job is completed
for p in jobs:
p.join()
# Save Data
Halo_ID = []
Src_ID = []
Mdyn = []
Mlens = []
for cpu in range(CPUs):
results = results_per_cpu.values()[cpu]
for src in range(len(results)):
Halo_ID.append(results[src][0])
Src_ID.append(results[src][1])
Mdyn.append(results[src][2])
Mlens.append(results[src][3])
la_dir = HQ_dir + '/LensingAnalysis/' + sim_phy[sim]
print('save data', la_dir, sim_name[sim])
sim_label = la.define_sim_label(sim_name[sim], sim_dir[sim])
hf = h5py.File(la_dir + 'DLMass_pa_shmr_svrms' + sim_label + '.h5',
'w')
hf.create_dataset('Halo_ID', data=Halo_ID)
hf.create_dataset('Src_ID', data=Src_ID)
hf.create_dataset('Mdyn', data=Mdyn)
hf.create_dataset('Mlens', data=Mlens)
hf.close()
def create_density_maps():
# Get command line arguments
args = {}
if comm_rank == 0:
args["simdir"] = sys.argv[1]
args["hfdir"] = sys.argv[2]
args["snapnum"] = int(sys.argv[3])
args["ncells"] = int(sys.argv[4])
args["outbase"] = sys.argv[5]
args["nfileout"] = sys.argv[6]
args = comm.bcast(args)
label = args["simdir"].split('/')[-2].split('_')[2]
# Organize devision of Sub-&Halos over Processes on Proc. 0
if comm_rank == 0:
# Sort Sub-&Halos over Processes
df = pd.read_csv(args["hfdir"] + 'halos_%d.dat' % args["snapnum"],
sep='\s+',
skiprows=16,
usecols=[0, 2, 4, 9, 10, 11],
names=['ID', 'Mvir', 'Vrms', 'X', 'Y', 'Z'])
df = df[df['Mvir'] > 5e11]
sh_id = df['ID'].values.astype('float64')
sh_vrms = df['Vrms'].values.astype('float64')
sh_x = df['X'].values.astype('float64')
sh_y = df['Y'].values.astype('float64')
sh_z = df['Z'].values.astype('float64')
del df
hist_edges = histedges_equalN(sh_x, comm_size)
sh_id, sh_vrms, sh_x, sh_y, sh_z, sh_split_size_1d, sh_split_disp_1d = cluster_subhalos(
sh_id, sh_vrms, sh_x, sh_y, sh_z, hist_edges, comm_size)
# Sort Particles over Processes
s = read_hdf5.snapshot(args["snapnum"], args["simdir"])
s.read(["Coordinates", "Masses", "GFM_StellarFormationTime"],
parttype=[0, 1, 4])
scale = 1e-3 * s.header.hubble
## Dark Matter
dm_mass = (s.data['Masses']['dm']).astype('float64')
dm_x = (s.data['Coordinates']['dm'][:, 0] * scale).astype('float64')
dm_y = (s.data['Coordinates']['dm'][:, 1] * scale).astype('float64')
dm_z = (s.data['Coordinates']['dm'][:, 2] * scale).astype('float64')
dm_mass, dm_x, dm_y, dm_z, dm_split_size_1d, dm_split_disp_1d = cluster_particles(
dm_mass, dm_x, dm_y, dm_z, hist_edges, comm_size)
## Gas
gas_mass = (s.data['Masses']['gas']).astype('float64')
gas_x = (s.data['Coordinates']['gas'][:, 0] * scale).astype('float64')
gas_y = (s.data['Coordinates']['gas'][:, 1] * scale).astype('float64')
gas_z = (s.data['Coordinates']['gas'][:, 2] * scale).astype('float64')
gas_mass, gas_x, gas_y, gas_z, gas_split_size_1d, gas_split_disp_1d = cluster_particles(
gas_mass, gas_x, gas_y, gas_z, hist_edges, comm_size)
## Stars
star_mass = (s.data['Masses']['stars']).astype('float64')
star_x = (s.data['Coordinates']['stars'][:, 0] *
scale).astype('float64')
star_y = (s.data['Coordinates']['stars'][:, 1] *
scale).astype('float64')
star_z = (s.data['Coordinates']['stars'][:, 2] *
scale).astype('float64')
star_age = s.data['GFM_StellarFormationTime']['stars']
star_x = star_x[star_age >= 0] #[Mpc]
star_y = star_y[star_age >= 0] #[Mpc]
star_z = star_z[star_age >= 0] #[Mpc]
star_mass = star_mass[star_age >= 0]
del star_age
star_mass, star_x, star_y, star_z, star_split_size_1d, star_split_disp_1d = cluster_particles(
star_mass, star_x, star_y, star_z, hist_edges, comm_size)
# Define Cosmology
cosmo = LambdaCDM(H0=s.header.hubble * 100,
Om0=s.header.omega_m,
Ode0=s.header.omega_l)
cosmosim = {
'omega_M_0': s.header.omega_m,
'omega_lambda_0': s.header.omega_l,
'omega_k_0': 0.0,
'h': s.header.hubble
}
redshift = s.header.redshift
print(': Redshift: %f' % redshift)
else:
sh_id = None
sh_vrms = None
sh_x = None
sh_y = None
sh_z = None
sh_split_size_1d = None
sh_split_disp_1d = None
dm_mass = None
dm_x = None
dm_y = None
dm_z = None
dm_split_size_1d = None
dm_split_disp_1d = None
gas_mass = None
gas_x = None
gas_y = None
gas_z = None
gas_split_size_1d = None
gas_split_disp_1d = None
star_mass = None
star_x = None
star_y = None
star_z = None
star_split_size_1d = None
star_split_disp_1d = None
cosmosim = None
cosmo = None
redshift = None
# Broadcast variables over all processors
sh_split_size_1d = comm.bcast(sh_split_size_1d, root=0)
sh_split_disp_1d = comm.bcast(sh_split_disp_1d, root=0)
dm_split_size_1d = comm.bcast(dm_split_size_1d, root=0)
dm_split_disp_1d = comm.bcast(dm_split_disp_1d, root=0)
gas_split_size_1d = comm.bcast(gas_split_size_1d, root=0)
gas_split_disp_1d = comm.bcast(gas_split_disp_1d, root=0)
star_split_size_1d = comm.bcast(star_split_size_1d, root=0)
star_split_disp_1d = comm.bcast(star_split_disp_1d, root=0)
cosmo = comm.bcast(cosmo, root=0)
redshift = comm.bcast(redshift, root=0)
# Initiliaze variables for each processor
sh_id_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_vrms_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_x_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_y_local = np.zeros((int(sh_split_size_1d[comm_rank])))
sh_z_local = np.zeros((int(sh_split_size_1d[comm_rank])))
dm_mass_local = np.zeros((int(dm_split_size_1d[comm_rank])))
dm_x_local = np.zeros((int(dm_split_size_1d[comm_rank])))
dm_y_local = np.zeros((int(dm_split_size_1d[comm_rank])))
dm_z_local = np.zeros((int(dm_split_size_1d[comm_rank])))
gas_mass_local = np.zeros((int(gas_split_size_1d[comm_rank])))
gas_x_local = np.zeros((int(gas_split_size_1d[comm_rank])))
gas_y_local = np.zeros((int(gas_split_size_1d[comm_rank])))
gas_z_local = np.zeros((int(gas_split_size_1d[comm_rank])))
star_mass_local = np.zeros((int(star_split_size_1d[comm_rank])))
star_x_local = np.zeros((int(star_split_size_1d[comm_rank])))
star_y_local = np.zeros((int(star_split_size_1d[comm_rank])))
star_z_local = np.zeros((int(star_split_size_1d[comm_rank])))
# Devide Data over Processes
comm.Scatterv([sh_id, sh_split_size_1d, sh_split_disp_1d, MPI.DOUBLE],
sh_id_local,
root=0)
comm.Scatterv([sh_vrms, sh_split_size_1d, sh_split_disp_1d, MPI.DOUBLE],
sh_vrms_local,
root=0)
comm.Scatterv([sh_x, sh_split_size_1d, sh_split_disp_1d, MPI.DOUBLE],
sh_x_local,
root=0)
comm.Scatterv([sh_y, sh_split_size_1d, sh_split_disp_1d, MPI.DOUBLE],
sh_y_local,
root=0)
comm.Scatterv([sh_z, sh_split_size_1d, sh_split_disp_1d, MPI.DOUBLE],
sh_z_local,
root=0)
comm.Scatterv([dm_x, dm_split_size_1d, dm_split_disp_1d, MPI.DOUBLE],
dm_x_local,
root=0)
comm.Scatterv([dm_y, dm_split_size_1d, dm_split_disp_1d, MPI.DOUBLE],
dm_y_local,
root=0)
comm.Scatterv([dm_z, dm_split_size_1d, dm_split_disp_1d, MPI.DOUBLE],
dm_z_local,
root=0)
comm.Scatterv([dm_mass, dm_split_size_1d, dm_split_disp_1d, MPI.DOUBLE],
dm_mass_local,
root=0)
comm.Scatterv([gas_x, gas_split_size_1d, gas_split_disp_1d, MPI.DOUBLE],
gas_x_local,
root=0)
comm.Scatterv([gas_y, gas_split_size_1d, gas_split_disp_1d, MPI.DOUBLE],
gas_y_local,
root=0)
comm.Scatterv([gas_z, gas_split_size_1d, gas_split_disp_1d, MPI.DOUBLE],
gas_z_local,
root=0)
comm.Scatterv([gas_mass, gas_split_size_1d, gas_split_disp_1d, MPI.DOUBLE],
gas_mass_local,
root=0)
comm.Scatterv([star_x, star_split_size_1d, star_split_disp_1d, MPI.DOUBLE],
star_x_local,
root=0)
comm.Scatterv([star_y, star_split_size_1d, star_split_disp_1d, MPI.DOUBLE],
star_y_local,
root=0)
comm.Scatterv([star_z, star_split_size_1d, star_split_disp_1d, MPI.DOUBLE],
star_z_local,
root=0)
comm.Scatterv(
[star_mass, star_split_size_1d, star_split_disp_1d, MPI.DOUBLE],
star_mass_local,
root=0)
print(
': Proc. %d got: \n\t %d Sub-&Halos \n\t %d dark matter \n\t %d gas \n\t %d stars \n'
% (comm_rank, int(sh_split_size_1d[comm_rank]),
int(dm_split_size_1d[comm_rank]), int(gas_split_size_1d[comm_rank]),
int(star_split_size_1d[comm_rank])))
comm.Barrier()
SH = {
"ID": sh_id_local,
"Vrms": sh_vrms_local,
"Pos": np.transpose([sh_x_local, sh_y_local, sh_z_local])
}
DM = {
"Mass": np.unique(dm_mass_local),
"Pos": np.transpose([dm_x_local, dm_y_local, dm_z_local])
}
Gas = {
"Mass": gas_mass_local,
"Pos": np.transpose([gas_x_local, gas_y_local, gas_z_local])
}
Star = {
"Mass": star_mass_local,
"Pos": np.transpose([star_x_local, star_y_local, star_z_local])
}
sigma_tot = []
subhalo_id = []
FOV = []
## Run over Sub-&Halos
for ll in range(len(SH['ID'])):
# Define field-of-view
c = (const.c).to_value('km/s')
fov_rad = 4 * np.pi * (SH['Vrms'][ll] / c)**2
#TODO: for z=0 sh_dist=0!!!
sh_dist = (cosmo.comoving_distance(redshift)).to_value('Mpc')
alpha = 6 # multiplied by 4 because of Oguri&Marshall
fov_Mpc = alpha * fov_rad * sh_dist # is it the diameter?
dm_sigma, h = DMf.projected_surface_density_smooth(
DM['Pos'], #[Mpc]
SH['Pos'][ll],
fov_Mpc, #[Mpc]
args["ncells"])
dm_sigma *= DM['Mass']
gas_sigma = projected_surface_density(
Gas['Pos'], #*a/h,
Gas['Mass'],
SH['Pos'][ll], #*a/h,
fov_Mpc,
args["ncells"])
gas_sigma = gaussian_filter(gas_sigma, sigma=h)
star_sigma = projected_surface_density(
Star['Pos'], #*a/h,
Star['Mass'],
SH['Pos'][ll], #*a/h,
fov_Mpc,
args["ncells"])
star_sigma = gaussian_filter(star_sigma, sigma=h)
# Check if all density maps are empty
if ((np.count_nonzero(dm_sigma) == args["ncells"]**2)
and (np.count_nonzero(gas_sigma) == (args["ncells"])**2)
and (np.count_nonzero(star_sigma) == (args["ncells"])**2)):
continue
sigmatotal = dm_sigma + gas_sigma + star_sigma
sigma_tot.append(sigmatotal)
subhalo_id.append(int(SH['ID'][ll]))
FOV.append(fov_Mpc)
fname = args["outbase"] + 'z_' + str(
args["snapnum"]) + '/' + 'DM_' + label + '_' + str(comm_rank) + '.h5'
hf = h5py.File(fname, 'w')
hf.create_dataset('density_map', data=sigma_tot)
hf.create_dataset('subhalo_id', data=np.asarray(subhalo_id))
hf.create_dataset('fov_width', data=np.asarray(FOV))
#RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88
hf.close()
