def test_index():
#Decide the statistical descriptors to measure, and build an index
idx = Indexer.stack([
PowerSpectrum(l_edges),
Peaks(thresholds_pk, norm=True),
MinkowskiAll(thresholds_mf, norm=True),
PDF(thresholds_mf, norm=True),
Moments(connected=True)
])
l = idx[0].l
v = idx[1].midpoints
v_mf = idx[2].midpoints
#Initiate the statistical ensemble
ens = Ensemble.fromfilelist(map_list)
#Load measurements into the ensemble (this is the expensive part!!!)
ens.load(callback_loader=convergence_measure_all, pool=None, index=idx)
#Split the ensemble in power_spectrum,peaks, and the second and third minkowski functional
mink_idx = idx[2].separate()
subset_idx = Indexer([idx[0], idx[1], idx[3], mink_idx[2], idx[-1]])
ens_pow, ens_pk, ens_pdf, ens_mink2, ens_mom = ens.split(subset_idx)
#####################################################################
#Plot to check
fig, ax = plt.subplots(2, 2, figsize=(16, 16))
for i in range(ens.num_realizations):
ax[0, 0].plot(l, l * (l + 1) * ens_pow.data[i] / (2.0 * np.pi))
ax[0, 1].plot(v, ens_pk.data[i])
ax[1, 0].plot(v_mf, ens_pdf.data[i])
ax[1, 1].plot(v_mf, ens_mink2.data[i])
ax[0, 0].set_xscale("log")
ax[0, 0].set_yscale("log")
ax[0, 0].set_xlabel(r"$l$")
ax[0, 0].set_ylabel(r"$l(l+1)P_l/2\pi$")
ax[0, 1].set_xlabel(r"$\nu$")
ax[0, 1].set_ylabel(r"$dN/d\nu$")
ax[1, 0].set_xlabel(r"$\nu$")
ax[1, 0].set_ylabel(r"$P(\nu)$")
ax[1, 1].set_xlabel(r"$\nu$")
ax[1, 1].set_ylabel(r"$V_2(\nu)$")
fig.tight_layout()
plt.savefig("conv_all.png")
plt.clf()
#Save moments to check
np.savetxt("moments.txt", ens_mom.mean())
def test_index():
#Decide the statistical descriptors to measure, and build an index
idx = Indexer.stack([PowerSpectrum(l_edges),Peaks(thresholds_pk,norm=True),MinkowskiAll(thresholds_mf,norm=True),PDF(thresholds_mf,norm=True),Moments(connected=True)])
l = idx[0].l
v = idx[1].midpoints
v_mf = idx[2].midpoints
#Initiate the statistical ensemble
ens = Ensemble.fromfilelist(map_list)
#Load measurements into the ensemble (this is the expensive part!!!)
ens.load(callback_loader=convergence_measure_all,pool=None,index=idx)
#Split the ensemble in power_spectrum,peaks, and the second and third minkowski functional
mink_idx = idx[2].separate()
subset_idx = Indexer([idx[0],idx[1],idx[3],mink_idx[2],idx[-1]])
ens_pow,ens_pk,ens_pdf,ens_mink2,ens_mom = ens.split(subset_idx)
#####################################################################
#Plot to check
fig,ax = plt.subplots(2,2,figsize=(16,16))
for i in range(ens.num_realizations):
ax[0,0].plot(l,l*(l+1)*ens_pow.data[i]/(2.0*np.pi))
ax[0,1].plot(v,ens_pk.data[i])
ax[1,0].plot(v_mf,ens_pdf.data[i])
ax[1,1].plot(v_mf,ens_mink2.data[i])
ax[0,0].set_xscale("log")
ax[0,0].set_yscale("log")
ax[0,0].set_xlabel(r"$l$")
ax[0,0].set_ylabel(r"$l(l+1)P_l/2\pi$")
ax[0,1].set_xlabel(r"$\nu$")
ax[0,1].set_ylabel(r"$dN/d\nu$")
ax[1,0].set_xlabel(r"$\nu$")
ax[1,0].set_ylabel(r"$P(\nu)$")
ax[1,1].set_xlabel(r"$\nu$")
ax[1,1].set_ylabel(r"$V_2(\nu)$")
fig.tight_layout()
plt.savefig("conv_all.png")
plt.clf()
#Save moments to check
np.savetxt("moments.txt",ens_mom.mean())
def test_differentiate():
thresholds = np.arange(-0.04, 0.12, 0.001)
midpoints = 0.5 * (thresholds[:-1] + thresholds[1:])
index = Indexer.stack([MinkowskiAll(thresholds)])
index_separate = Indexer(MinkowskiAll(thresholds).separate())
diff_ensemble = Ensemble.fromfilelist(map_list)
diff_ensemble.load(callback_loader=convergence_measure_all, index=index)
ensemble_0 = diff_ensemble.split(index_separate)[0]
ensemble_pdf = ensemble_0.differentiate(step=thresholds[0] - thresholds[1])
fig, ax = plt.subplots()
for i in range(ensemble_0.num_realizations):
ax.plot(0.5 * (midpoints[:-1] + midpoints[1:]), ensemble_pdf[i])
ax.set_xlabel(r"$\kappa$")
ax.set_ylabel(r"$P(\kappa)$")
fig.savefig("ensemble_differentiate.png")
def measure_all_histograms(models,options,pool):
#Look at a sample map
sample_map = ConvergenceMap.fromfilename(models[0].getNames(z=1.0,realizations=[1])[0],loader=load_fits_default_convergence)
#Initialize Gaussian shape noise generator for the sample map shape and angle
generator = GaussianNoiseGenerator.forMap(sample_map)
#Parsed from options
num_realizations = options.getint("analysis","num_realizations")
smoothing_scales = [float(scale) for scale in options.get("analysis","smoothing_scales").split(",")]
bin_edges = np.ogrid[options.getfloat("analysis","bin_edge_low"):options.getfloat("analysis","bin_edge_high"):(options.getint("analysis","num_bins") - 2)*1j]
bin_edges = np.hstack((-10.0,bin_edges,10.0))
z = options.getfloat("analysis","redshift")
bin_midpoints = 0.5*(bin_edges[1:] + bin_edges[:-1])
#Create smoothing scale index for the histograms
idx = Indexer.stack([PDF(bin_edges) for scale in smoothing_scales])
#Build the data type of the structure array in output
data_type = [(model.name,Ensemble) for model in models]
#Append info about the smoothing scale
data_type = [("Smooth",np.float),] + data_type
#Create output struct array
ensemble_array = np.zeros(len(smoothing_scales),dtype=data_type)
#Write smoothing scale information
ensemble_array["Smooth"] = np.array(smoothing_scales)
#The for loop runs the distributed computations
for model in models:
#Build Ensemble instance with the maps to analyze
map_ensemble = Ensemble.fromfilelist(range(1,num_realizations+1))
#Measure the histograms and load the data in the ensemble
map_ensemble.load(callback_loader=compute_map_histograms,pool=pool,simulation_set=model,smoothing_scales=smoothing_scales,index=idx,generator=generator,bin_edges=bin_edges,redshift=z)
#Split the ensemble between different smoothing scales
map_ensemble_list = map_ensemble.split(idx)
#Add to output struct array
ensemble_array[model.name] = np.array(map_ensemble_list)
return ensemble_array
def test_differentiate():
thresholds = np.arange(-0.04,0.12,0.001)
midpoints = 0.5*(thresholds[:-1] + thresholds[1:])
index = Indexer.stack([MinkowskiAll(thresholds)])
index_separate = Indexer(MinkowskiAll(thresholds).separate())
diff_ensemble = Ensemble.fromfilelist(map_list)
diff_ensemble.load(callback_loader=convergence_measure_all,index=index)
ensemble_0 = diff_ensemble.split(index_separate)[0]
ensemble_pdf = ensemble_0.differentiate(step=thresholds[0]-thresholds[1])
fig,ax = plt.subplots()
for i in range(ensemble_0.num_realizations):
ax.plot(0.5*(midpoints[:-1]+midpoints[1:]),ensemble_pdf[i])
ax.set_xlabel(r"$\kappa$")
ax.set_ylabel(r"$P(\kappa)$")
fig.savefig("ensemble_differentiate.png")
feature_list.append(PowerSpectrum(l_edges))
if options.has_section("moments"):
feature_list.append(Moments())
if options.has_section("peaks"):
th_peaks = np.ogrid[options.getfloat("peaks","th_min"):options.getfloat("peaks","th_max"):(options.getint("peaks","num_bins")+1)*1j]
np.save(os.path.join(save_path,"th_peaks.npy"),0.5*(th_peaks[1:]+th_peaks[:-1]))
feature_list.append(Peaks(th_peaks))
if options.has_section("minkowski_functionals"):
th_minkowski = np.ogrid[options.getfloat("minkowski_functionals","th_min"):options.getfloat("minkowski_functionals","th_max"):(options.getint("minkowski_functionals","num_bins")+1)*1j]
np.save(os.path.join(save_path,"th_minkowski.npy"),0.5*(th_minkowski[1:]+th_minkowski[:-1]))
feature_list.append(MinkowskiAll(th_minkowski))
idx = Indexer.stack(feature_list)
#Write an info file with all the analysis information
with open(os.path.join(save_path,"INFO.txt"),"w") as infofile:
infofile.write(write_info(options))
#Build the progress bar
pbar = progressbar.ProgressBar(widgets=widgets,maxval=len(models)*len(subfields)*len(smoothing_scales)).start()
i = 0
#Cycle through the models and perform the measurements of the selected features (create the appropriate directories to save the outputs)
for model in models:
if type(model)==CFHTemu1:
dir_to_make = os.path.join(save_path,model._cosmo_id_string)
elif type(model)==CFHTcov:
if (pool is not None) and not (pool.is_master()):
pool.wait()
sys.exit(0)
#Root path of IGS1 maps
root_path = cmd_args.path
num_realizations = cmd_args.num_realizations
#Smoothing scales in arcmin
smoothing_scales = [theta * arcmin for theta in [0.1, 0.5, 1.0, 2.0]]
bin_edges = np.ogrid[-0.15:0.15:128j]
bin_midpoints = 0.5 * (bin_edges[1:] + bin_edges[:-1])
#Create smoothing scale index for the histogram
idx = Indexer.stack([PDF(bin_edges) for scale in smoothing_scales])
#Create IGS1 simulation set object to look for the right simulations
simulation_set = IGS1(root_path=root_path)
#Look at a sample map
sample_map = ConvergenceMap.load(
simulation_set.getNames(z=1.0, realizations=[1])[0])
#Initialize Gaussian shape noise generator
generator = GaussianNoiseGenerator.forMap(sample_map)
#Build Ensemble instance with the maps to analyze
map_ensemble = Ensemble.fromfilelist(range(1, num_realizations + 1))
#Measure the histograms and load the data in the ensemble
if (pool is not None) and not (pool.is_master()):
pool.wait()
sys.exit(0)
# Root path of IGS1 maps
root_path = cmd_args.path
num_realizations = cmd_args.num_realizations
# Smoothing scales in arcmin
smoothing_scales = [theta * arcmin for theta in [0.1, 0.5, 1.0, 2.0]]
bin_edges = np.ogrid[-0.15:0.15:128j]
bin_midpoints = 0.5 * (bin_edges[1:] + bin_edges[:-1])
# Create smoothing scale index for the histogram
idx = Indexer.stack([PDF(bin_edges) for scale in smoothing_scales])
# Create IGS1 simulation set object to look for the right simulations
simulation_set = IGS1(root_path=root_path)
# Look at a sample map
sample_map = ConvergenceMap.load(simulation_set.getNames(z=1.0, realizations=[1])[0])
# Initialize Gaussian shape noise generator
generator = GaussianNoiseGenerator.forMap(sample_map)
# Build Ensemble instance with the maps to analyze
map_ensemble = Ensemble.fromfilelist(range(1, num_realizations + 1))
# Measure the histograms and load the data in the ensemble
map_ensemble.load(
