def __init__(self,
initial_parameters=None,
density_contrasts=None,
num_filtering_scales=50,
path=None,
window_function="top hat"):
"""
Instantiates :class:`DensityPeaks` given the
Args:
"""
if initial_parameters is None:
initial_parameters = parameters.InitialConditionsParameters(
path=path)
self.initial_parameters = initial_parameters
self.delta_class = density.DensityContrasts(
initial_parameters=initial_parameters,
num_filtering_scales=num_filtering_scales,
window_function=window_function)
if density_contrasts is None:
density_contrasts = self.delta_class.density_contrasts
self.density_contrasts = density_contrasts
assert self.density_contrasts.shape == (num_filtering_scales,
initial_parameters.shape**3)
def __init__(self,
initial_parameters=None,
density_contrasts=None,
num_filtering_scales=50,
path=None,
window_function="top hat",
number_of_processors=10):
"""
Instantiates :class:`Inertia` given the
Args:
"""
if initial_parameters is None:
initial_parameters = parameters.InitialConditionsParameters(
path=path)
self.initial_parameters = initial_parameters
self.delta_class = density.DensityContrasts(
initial_parameters=initial_parameters,
num_filtering_scales=num_filtering_scales,
window_function=window_function)
self.shear_class = shear.Shear(
initial_parameters=initial_parameters,
num_filtering_scales=num_filtering_scales,
number_of_processors=number_of_processors)
DensityPeaks.__init__(self,
initial_parameters=initial_parameters,
density_contrasts=density_contrasts,
num_filtering_scales=num_filtering_scales,
path=path,
window_function=window_function)
def __init__(self,
ids_particles,
initial_parameters=None,
num_filtering_scales=50,
path=None):
"""
Instantiates :class:`Inertia` given the
Args:
"""
if initial_parameters is None:
initial_parameters = parameters.InitialConditionsParameters(
path=path)
self.initial_parameters = initial_parameters
self.filter_parameters = window.WindowParameters(
initial_parameters=initial_parameters,
num_filtering_scales=num_filtering_scales)
# self.delta_class = density.DensityContrasts(initial_parameters=initial_parameters,
# num_filtering_scales=num_filtering_scales,
# window_function=window_function)
# self.shear_class = shear.Shear(initial_parameters=initial_parameters,
# num_filtering_scales=num_filtering_scales,
# number_of_processors=number_of_processors)
#
# Inertia.__init__(self, initial_parameters=initial_parameters, density_contrasts=density_contrasts,
#
# num_filtering_scales=num_filtering_scales, path=path, window_function=window_function)
self.filt_scales = np.arange(50)
self.ids_particles = ids_particles
def test_mena_density_effect():
initial_parameters = parameters.InitialConditionsParameters(path=path)
mean_density_box = initial_parameters.mean_density
mean_rho_pynbody = pynbody.analysis.cosmology.rho_M(initial_parameters.initial_conditions, unit="Msol Mpc**-3")
ratio = mean_rho_pynbody/mean_density_box
traj = np.load("/share/data1/lls/trajectories_sharp_k/ALL_traj_1500_even_log_m.npy")
traj_pynbody_mean = traj/ratio
m_bins = 10 ** np.arange(10, 15, 0.0033).view(pynbody.array.SimArray)
m_bins.units = "Msol h^-1"
pred_mass_PS_pynbody = mp.get_predicted_analytic_mass(m_bins, initial_parameters, barrier="spherical",
cosmology="WMAP5", trajectories=traj_pynbody_mean)
np.save("/Users/lls/Documents/CODE/stored_files/hmf/pynbody_rho_bar/ALL_PS_predicted_masses_1500_even_log_m_spaced"
".npy",
pred_mass_PS_pynbody)
del pred_mass_PS_pynbody
pred_mass_ST_pynbody = mp.get_predicted_analytic_mass(m_bins, initial_parameters, barrier="ST", cosmology="WMAP5",
trajectories=traj_pynbody_mean)
np.save("/Users/lls/Documents/CODE/stored_files/hmf/pynbody_rho_bar/ALL_ST_predicted_masses_1500_even_log_m_spaced.npy",
pred_mass_ST_pynbody)
def importances_plot(imp,
initial_parameters=None,
save=False,
yerr=None,
label=None,
subplots=1,
figsize=(7.5, 6)):
if initial_parameters is None:
initial_parameters = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/CODE", load_final=True)
w = window.WindowParameters(initial_parameters=initial_parameters)
mass = w.smoothing_masses
plot.plot_importances_vs_mass_scale(imp,
mass,
save=save,
yerr=yerr,
label=label,
path=".",
title=None,
width=0.5,
log=False,
subplots=subplots,
figsize=figsize,
frameon=False,
legend_fontsize=None,
ecolor="k")
def test_number_halos_true_sim():
initial_parameters = parameters.InitialConditionsParameters(path=path)
log_bins = np.arange(10, 15, 0.1)
m, n = hmf_sim.get_true_number_halos_per_mass_bins(initial_parameters, log_bins)
m1, n1 = hmf_sim.get_simulation_number_of_halos_from_particles_halo_mass(initial_parameters, log_m_bins=log_bins)
np.testing.assert_allclose(n, n1, rtol=1e-1)
np.testing.assert_allclose(m, m1, rtol=1e-1)
print("Passed test")
def test_power_spectrum():
initial_parameters = parameters.InitialConditionsParameters(path=path)
k_vector = np.linspace(0.1, 1000, 100000)
pwspectrum = scripts.ellipsoidal.power_spectrum.get_power_spectrum(
"WMAP5", initial_parameters, z=99)
pk = pwspectrum(k_vector) / pwspectrum._lingrowth
pk_0 = scripts.ellipsoidal.power_spectrum.get_power_spectrum(
"WMAP5", initial_parameters, z=0)
np.testing.assert_allclose(pk_0(k_vector), pk)
def test_mass_assignment_sharp_k():
r = pynbody.array.SimArray([20])
r.units = "Mpc a h^-1"
ic = parameters.InitialConditionsParameters(path=path)
w_sk = window.WindowParameters(initial_parameters=ic, volume="sharp-k")
mass_sk = w_sk.get_mass_from_radius(ic, r, ic.mean_density)
w_th = window.WindowParameters(initial_parameters=ic, volume="sphere")
mass_th = w_th.get_mass_from_radius(ic, r, ic.mean_density)
assert mass_sk == (9 * np.pi /2) * mass_th
def test_radius_assignment_sharp_k():
m = pynbody.array.SimArray([1e13])
m.units = "Msol h^-1"
ic = parameters.InitialConditionsParameters(path=path)
w_sk = window.WindowParameters(initial_parameters=ic, volume="sharp-k")
r_sk = w_sk.get_smoothing_radius_corresponding_to_filtering_mass(ic, m)
w_th = window.WindowParameters(initial_parameters=ic, volume="sphere")
r_th = w_th.get_smoothing_radius_corresponding_to_filtering_mass(ic, m)
r_sk_test = (2 / (9 * np.pi))**(1/3) * r_th
assert np.allclose(r_sk, r_sk_test), "Th sharp k radius is" + str(r_sk) + "and the testing one is " + str(r_sk_test)
def get_in_range_indices_of_trajectories(mass_range="in", initial_parameters=None):
if initial_parameters is None:
initial_parameters = parameters.InitialConditionsParameters(path="/Users/lls/Documents/CODE")
w = window.WindowParameters(initial_parameters=initial_parameters, num_filtering_scales=50)
if mass_range == "in":
range_mass_IN = np.intersect1d(np.where(w.smoothing_masses >
initial_parameters.halo[initial_parameters.max_halo_number]['mass'].sum()),
np.where(w.smoothing_masses <
initial_parameters.halo[initial_parameters.min_halo_number]['mass'].sum()))
return range_mass_IN
else:
NameError("Enter a valid mass range of trajectories")
def test_nearest_peak_id_different_centering():
""" This passed on 1st May 2018 """
ic = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/CODE", load_final=True)
DP = inertia.DensityPeaks(initial_parameters=ic, num_filtering_scales=5)
d = DP.density_contrasts
particle_ids_max = DP.get_particle_ids_local_maxima_density_contrast(d[:,
2])
pos_max = DP.get_positions_local_maxima_density_contrast(d[:, 2])
nearest_peaks = DP.get_nearest_peak(particle_ids_max,
pos_max,
output="id+position")
for i in range(3):
p_centering = np.random.choice(np.arange(256**3), 1)
print("Centering on particle ID " + str(p_centering))
tr = pynbody.analysis.halo.center(
ic.initial_conditions[p_centering[0]], vel=False, mode="hyb")
ic = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/CODE", load_final=True)
DP = inertia.DensityPeaks(initial_parameters=ic,
num_filtering_scales=5)
d = DP.density_contrasts
pos_max_i = DP.get_positions_local_maxima_density_contrast(d[:, 2])
p_ids_i = DP.get_particle_ids_local_maxima_density_contrast(d[:, 2])
nearest_peaks_i = DP.get_nearest_peak(p_ids_i,
pos_max_i,
output="id+position")
np.testing.assert_allclose(nearest_peaks_i[:, 0], nearest_peaks[:, 0])
np.testing.assert_allclose(p_ids_i, particle_ids_max)
tr.revert()
def test_knn_against_ckdtree():
ic = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/CODE", load_final=True)
DP = inertia.DensityPeaks(initial_parameters=ic, num_filtering_scales=2)
d = DP.density_contrasts
position_peaks = DP.get_positions_local_maxima_density_contrast(d[:, 2])
pos_ids = ic.initial_conditions["pos"]
t = cKDTree(position_peaks)
queries = t.query(pos_ids, k=1)
nearest_peaks = DP.find_kNearestNeighbour_ml(pos_ids,
position_peaks,
return_distance=True)
np.testing.assert_allclose(queries, nearest_peaks)
def trajectories_test():
p = parameters.InitialConditionsParameters(
initial_snapshot=
"/Users/lls/Documents/CODE/Nina-Simulations/double/ICs_z99_256_L50_gadget3.dat",
final_snapshot=
"/Users/lls/Documents/CODE/Nina-Simulations/double/snapshot_104",
min_halo_number=0,
max_halo_number=400,
ids_type='all',
num_particles=None)
trajectory_test = trajectories.Trajectories(
init_parameters=p,
particles=[12599035, 2642532],
num_of_filters=20,
num_particles=1)
trajectory_in = trajectory_test.delta_in
trajectory_out = trajectory_test.delta_out
return trajectory_in, trajectory_out
def test_correct_units():
initial_parameters = parameters.InitialConditionsParameters(path=path)
snapshot = initial_parameters.initial_conditions
smoothing_radii = np.linspace(0.0057291, 0.20, 1500)
r_a_h = smoothing_radii/snapshot.properties['a'] * snapshot.properties['h']
r_a_h = r_a_h.view(pynbody.array.SimArray)
r_a_h.units = "Mpc a h^-1"
th = pynbody.analysis.hmf.TophatFilter(snapshot)
m = th.R_to_M(r_a_h)
m.units = "Msol h^-1"
rho_M = pynbody.analysis.cosmology.rho_M(snapshot, unit="Msol Mpc**-3")
w = window.WindowParameters(initial_parameters=initial_parameters, volume="sphere")
filtering_masses = w.get_mass_from_radius(initial_parameters, smoothing_radii, rho_M)
filtering_masses_with_h = filtering_masses * snapshot.properties['h']
filtering_masses_with_h.units = "Msol h^-1"
np.testing.assert_allclose(filtering_masses_with_h, m)
def get_simulations_halo_masses_each_particle(path_simulation, saving_path):
initial_params = parameters.InitialConditionsParameters(
initial_snapshot=path_simulation + "IC.gadget3",
final_snapshot=path_simulation + "snapshot_099",
load_final=True,
min_halo_number=0,
max_halo_number=400,
min_mass_scale=3e10,
max_mass_scale=1e15)
# Get halo mass for each particle
halo_id_particles = initial_params.final_snapshot['grp']
halo_num = np.unique(halo_id_particles)[1:]
halo_mass_particles = np.zeros(len(halo_id_particles))
for i in halo_num:
halo_mass_particles[np.where(
halo_id_particles == i)[0]] = initial_params.halo[i]["mass"].sum()
halo_mass_particles = pynbody.array.SimArray(halo_mass_particles)
halo_mass_particles.units = initial_params.halo[0]["mass"].units
np.save(saving_path + "halo_mass_particles.npy", halo_mass_particles)
return halo_mass_particles
def test_radius_from_coordinates():
""" This passed on 1st May 2018 """
ic = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/CODE", load_final=True)
DP = inertia.DensityPeaks(initial_parameters=ic, num_filtering_scales=5)
d = DP.density_contrasts
In = inertia.Inertia(initial_parameters=ic,
density_contrasts=d,
num_filtering_scales=5)
# Find peaks -- particles ids and positions
pos_max = DP.get_positions_local_maxima_density_contrast(d[:, 2])
particle_ids_max = DP.get_particle_ids_local_maxima_density_contrast(d[:,
2])
# Embed box in a bigger box to account for periodicity
# Find peaks -- particles ids and positions
nearest_peaks = DP.get_nearest_peak(particle_ids_max,
pos_max,
output="id+position")
# get dx,dy,dz from nearest peak
position_particles = ic.initial_conditions["pos"]
dx, dy, dz = In.get_difference_coordinates(position_particles,
nearest_peaks[:, 1:])
r = np.sqrt((dx**2) + (dy**2) + (dz**2))
# check that resulting distance is the same as the one returned by scikit-learn
extended_peaks = DP.extended_peaks_with_periodic_boundary_conditions(
particle_ids_max, pos_max, ic.initial_conditions)
dist, ids = DP.find_kNearestNeighbour_ml(position_particles,
extended_peaks[:, 1:],
return_distance=True)
np.testing.assert_allclose(dist, r)
The feature importances of the training set are also store in the `all_out` folder.
"""
import sys
sys.path.append('/Users/lls/Documents/mlhalos_code/scripts')
from mlhalos import machinelearning as ml
from mlhalos import features
from mlhalos import parameters
from mlhalos import plot
import numpy as np
# Select 50,000 particles to use as training set
ic_all = parameters.InitialConditionsParameters()
min_halo = 0
max_halo = 400
min_mass = ic_all.halo[max_halo]['mass'].sum()
max_mass = ic_all.halo[min_halo]['mass'].sum()
ic = parameters.InitialConditionsParameters(min_halo_number=min_halo,
max_halo_number=max_halo,
min_mass_scale=min_mass,
max_mass_scale=max_mass)
feat_w_EPS = features.extract_labeled_features(initial_parameters=ic,
add_EPS_label=True,
n_samples=50000)
# Train the algorithm
f = plot.roc_plot(
fpr,
tpr,
auc,
labels=["$z=99$ densities", "$z=99$ + $z=0$ densities", "$z=0$ only"],
title=' %.2f' % (bins[i]) + l + ' %.2f' % (bins[i + 1]))
f.subplots_adjust(top=0.9)
plt.savefig(
"/Users/lls/Documents/mlhalos_files/multiclass/z0_only/roc_class_" +
str(i) + ".png")
del f
# importances
ic = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/mlhalos_files", load_final=True)
w = window.WindowParameters(initial_parameters=ic)
# f_imp_z0 = np.load("/Users/lls/Documents/mlhalos_files/multiclass/z0_only/f_imp.npy")
# f_imp_z0_ics = np.load("/Users/lls/Documents/mlhalos_files/multiclass/ics_z0_density/f_imp.npy")
f_imp = np.load(
"/Users/lls/Documents/mlhalos_files/multiclass/ics_only/f_imp.npy")
for i in range(50):
# f = plot.plot_importances_vs_mass_scale(f_imp_z0[i], w.smoothing_masses, save=False, yerr=None,
# label="$z=0$ density", path=".",
# title=' %.2f' % (bins[i]) + l + ' %.2f' % (bins[i+1]), width=0.5, log=False,
# subplots=1, figsize=(6.9, 5.2), frameon=False, legend_fontsize=None, ecolor="k")
# plt.savefig("/Users/lls/Documents/mlhalos_files/multiclass/z0_only/imp_" + str(i) + ".png")
# del f
# plt.clf()
# f = plot.plot_importances_vs_mass_scale(f_imp_z0_ics[i], w.smoothing_masses, save=False, yerr=None,
import sys
sys.path.append('/home/lls/mlhalos_code')
import numpy as np
from mlhalos import parameters
from mlhalos import density
from mlhalos import shear
############### FEATURE EXTRACTION ###############
if __name__ == "__main__":
path = "/home/lls"
initial_params = parameters.InitialConditionsParameters(
initial_snapshot="/home/app/reseed/IC.gadget3",
load_final=False,
min_halo_number=0,
max_halo_number=400,
min_mass_scale=3e10,
max_mass_scale=1e15)
sp = shear.ShearProperties(initial_parameters=initial_params,
num_filtering_scales=50,
shear_scale="all",
number_of_processors=60,
path=path)
ell = sp.density_subtracted_ellipticity
prol = sp.density_subtracted_prolateness
np.save(
"/share/data1/lls/reseed50/features/density_subtracted_ellipticity.npy",
import sys
sys.path.append("/home/lls/mlhalos_code")
#sys.path.append("/Users/lls/Documents/mlhalos_code")
import numpy as np
from mlhalos import parameters
ics = "/share/data1/lls/sim200/simulation/standard200.gadget3"
f = "/share/data1/lls/sim200/simulation/snapshot_011"
ic = parameters.InitialConditionsParameters(initial_snapshot=ics,
final_snapshot=f)
final_snap = ic.final_snapshot
h = ic.halo
halo_mass = np.zeros((len(ic.final_snapshot), ))
halo_ids = np.arange(len(ic.halo))
for halo_id in range(len(halo_ids)):
mass_halo = ic.halo[halo_id]['mass'].sum()
halo_mass[ic.halo[halo_id]['iord']] = mass_halo
np.save("/share/data1/lls/sim200/halo_mass_particles.npy", halo_mass)
(4) I compare the algorithm's predictions to the predictions from EPS theory.
"""
import sys
sys.path.append('/Users/lls/Documents/mlhalos_code/scripts')
import numpy as np
from mlhalos import parameters
from mlhalos import features
from mlhalos import machinelearning as ml
#### FEATURE EXTRACTION #####
initial_parameters = parameters.InitialConditionsParameters(
min_mass_scale=1e10,
max_mass_scale=1e15,
ids_type='all',
num_particles=None,
n_particles_per_cat=None)
features_all = features.extract_labeled_features(
features_type="EPS trajectories",
initial_parameters=initial_parameters,
num_filtering_scales=50,
rescale=None)
np.save('/home/lls/stored_files/non_rescaled/features_all_particles.npy',
features_all)
#### TRAINING #####
# Select 50,000 particles to use as training set
index_training = np.random.choice(len(features_all), size=50000, replace=False)
log_den_true[ids_nonvir_tested],
bins_plotting,
label_0="den+inertia",
compare="density",
# color="grey",
path=path_inertia + "inertia_plus_den/",
saving_name="nonvir_particles_vs_density.pdf")
plt.clf()
#### improvement as a function of radius
sorted_ids_in_halo = np.sort(ids_in_halo)
sorted_fraction = fraction[np.argsort(ids_in_halo)]
fr_tested_ids = sorted_fraction[np.in1d(sorted_ids_in_halo, testing_ids)]
ic = parameters.InitialConditionsParameters(
path="/Users/lls/Documents/CODE", load_final=True)
def frac_diff_predictions_vs_radial_fraction(array_0,
array_1,
radial_fraction,
bins=10,
log=True):
#log_r = np.array([np.inf if x is np.inf else 0 if x == 0 else np.log10(x) for x in radial_fraction])
# n, b = np.histogram(log_r[~np.isinf(log_r)], bins=bins)
print(type(bins))
if type(bins) == "int":
if log is True:
b = np.zeros(bins)
n_s = np.logspace(np.log10(np.unique(radial_fraction)[1]),
np.log10(np.unique(radial_fraction)[-2]),
"""
This is the script where I calculate the shear features for the initial conditions
with the periodicity implementation of pynbody version 0.45 to calculate
the density smoothing including periodicity of the box.
"""
import sys
sys.path.append("/home/lls/mlhalos_code")
from mlhalos import shear
from mlhalos import parameters
import numpy as np
saving_path = "/share/data2/lls/features_w_periodicity_fix/"
ic = parameters.InitialConditionsParameters(load_final=True,
path="/home/lls/stored_files")
s = shear.ShearProperties(initial_parameters=ic,
num_filtering_scales=50,
snapshot=None,
shear_scale=range(50),
number_of_processors=60,
path="/home/lls")
subtracted_eigenvalues = s.density_subtracted_eigenvalues
np.save(saving_path + "density_subtracted_eigenvalues.npy",
subtracted_eigenvalues)
ell = s.density_subtracted_ellipticity
np.save(saving_path + "density_subtracted_ellipticity.npy", ell)
import numpy as np
from mlhalos import features
from mlhalos import parameters
path = "/home/lls/stored_files"
number_of_cores = 60
# if path == "hypatia":
# path = "/home/lls/stored_files"
# elif path == "macpro":
# sys.path.append("/Users/lls/Documents/mlhalos_code/scripts")
# path = "/Users/lls/Documents/CODE"
ic = parameters.InitialConditionsParameters(
initial_snapshot=path +
"/Nina-Simulations/double/ICs_z99_256_L50_gadget3.dat",
final_snapshot=path + "/Nina-Simulations/double/snapshot_104")
density_shear_features = features.extract_labeled_features(
features_type=["EPS trajectories", "shear"],
initial_parameters=ic,
num_filtering_scales=50,
rescale=None,
shear_scale=range(50),
density_subtracted_shear=False,
path=path,
cores=number_of_cores)
np.save(
"/home/lls/stored_files/shear_and_density/full_eigenvalues/not_rescaled/density_full_shear_features.npy",
density_shear_features)
import sys
sys.path.append("/home/lls/mlhalos_code")
import numpy as np
from mlhalos import machinelearning as ml
from mlhalos import parameters
import pynbody
# Get training set
saving_path = "/share/data1/lls/reseed50/"
path_simulation = "/home/app/reseed/"
initial_params = parameters.InitialConditionsParameters(
initial_snapshot=path_simulation + "IC.gadget3",
final_snapshot=path_simulation + "snapshot_099",
load_final=True,
min_halo_number=0,
max_halo_number=400,
min_mass_scale=3e10,
max_mass_scale=1e15)
# Get halo mass for each particle
halo_id_particles = initial_params.final_snapshot['grp']
halo_num = np.unique(halo_id_particles)[1:]
halo_mass_particles = np.zeros(len(halo_id_particles))
for i in halo_num:
halo_mass_particles[np.where(
halo_id_particles == i)[0]] = initial_params.halo[i]["mass"].sum()
halo_mass_particles = pynbody.array.SimArray(halo_mass_particles)
halo_mass_particles.units = initial_params.halo[0]["mass"].units
import sys
sys.path.append("/home/lls/mlhalos_code/")
import numpy as np
from mlhalos import parameters
from mlhalos import window
from mlhalos import density
import pynbody
from regression.adaboost import gbm_04_only as gbm_fun
import matplotlib.pyplot as plt
from sklearn.externals import joblib
# path="/Users/lls/Documents/mlhalos_files/"
saving_path_traj = "/share/data2/lls/regression/gradboost/randomly_sampled_training/ic_traj_smoothed_above_1e15Msol/"
ic = parameters.InitialConditionsParameters()
w = window.WindowParameters(initial_parameters=ic)
d = density.DensityContrasts(initial_parameters=ic)
m = np.linspace(np.log10(3e10), np.log10(1e15), 50)
width = np.append(np.diff(m), np.diff(m)[-1])
m_all_p = ic.initial_conditions["mass"].sum()
m1 = np.arange(np.log10(1e15), np.log10(m_all_p*5000), step=width[-1])[1:]
M = pynbody.array.SimArray(10**m1)
M.units = "Msol"
r_smoothing = w.get_smoothing_radius_corresponding_to_filtering_mass(ic, M)
den = d.get_smooth_density_for_radii_list(ic, r_smoothing)
traj_high_smoothing = den/ic.mean_density
np.save(saving_path_traj + "density_contrasts_smoothed_above_1e15Msol.npy", traj_high_smoothing)
output[np.where((id_to_h >= initial_parameters.min_halo_number)
& (id_to_h <= initial_parameters.max_halo_number))] = 1
output = output.astype("int")
return output
############### ROC CURVES ###############
if __name__ == "__main__":
# ic_training = parameters.InitialConditionsParameters(path="/Users/lls/Documents/CODE")
# mass_threshold_in_out = ic_training.halo[400]['mass'].sum()
ic = parameters.InitialConditionsParameters(
initial_snapshot="/Users/lls/Documents/CODE/reseed50/IC.gadget3",
final_snapshot="/Users/lls/Documents/CODE/reseed50/snapshot_099",
load_final=True,
min_halo_number=0,
max_halo_number=400,
min_mass_scale=3e10,
max_mass_scale=1e15)
# Change ic.ids_IN and ic.ids_OUT to be IN or OUT depending on whether they are in halos of mass larger than the
# mass of halo 400 in ic_training and not that of halo 400 in ic. Change ids_IN, ids_OUT, and ic.max_halo_number.
# We have that halo 409 in ic has the same mass as halo 400 in ic_training - hard code this for now.
ic.max_halo_number = 409
# Load or calculate true labels
try:
true_labels = np.load(
"/Users/lls/Documents/CODE/reseed50/predictions/true_labels.npy")
path = "/share/data2/lls/regression/local_inertia/tensor/"
ran_5k = np.load("/share/data2/lls/regression/local_inertia/tensor/ran_5k.npy")
def pool_local_inertia(particle_id):
li, eigi = In.get_local_inertia_single_id(particle_id, snapshot,
r_smoothing, rho)
np.save(
path + "random/inertia_tensor_particle_" + str(particle_id) + ".npy",
li)
np.save(path + "random/eigenvalues_particle_" + str(particle_id) + ".npy",
eigi)
# print("Done and saved particle " + str(particle_id))
return li
ic = parameters.InitialConditionsParameters(load_final=True)
In = inertia.LocalInertia(ran_5k, initial_parameters=ic)
snapshot = ic.initial_conditions
rho = snapshot["rho"]
filtering_scales = In.filt_scales
r_smoothing = In.filter_parameters.smoothing_radii.in_units(
snapshot["pos"].units)[filtering_scales]
pool = Pool(processes=40)
li_particles = pool.map(pool_local_inertia, ran_5k)
pool.close()
pool.join()
"""
import numpy as np
from mlhalos import parameters
from mlhalos import window
from mlhalos import density
import pynbody
from sklearn.externals import joblib
############### FEATURE EXTRACTION ###############
if __name__ == "__main__":
path = "/home/lls"
initial_params = parameters.InitialConditionsParameters(
initial_snapshot="/home/app/reseed/IC.gadget3",
load_final=True,
final_snapshot="/home/app/reseed/snapshot_099")
w = window.WindowParameters(initial_parameters=initial_params)
d = density.DensityContrasts(initial_parameters=initial_params)
m = np.linspace(np.log10(3e10), np.log10(1e15), 50)
width = np.append(np.diff(m), np.diff(m)[-1])
m_all_p = initial_params.initial_conditions["mass"].sum()
m1 = np.arange(np.log10(1e15), np.log10(m_all_p * 5000),
step=width[-1])[1:]
m_all = 10**np.concatenate((m, m1))
M = pynbody.array.SimArray(m_all)
M.units = "Msol"
