import numpy as np
import sys, os
import re
import pickle
from cobaya.run import run
from getdist.mcsamples import loadMCSamples
import matplotlib.pyplot as plt
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
spec_dir = "spectra_actxplanck_newbin/"
cov_dir = "covariances_actxplanck_newbin/"
output_dir = "output_calib/"
pspy_utils.create_directory(output_dir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
modes = ["TT", "TE", "ET", "EE"]
# Multipoole range to use
lmin = {
"dr6_pa4_f150": 900,
"dr6_pa4_f220": 1500,
"dr6_pa5_f090": 600,
"dr6_pa5_f150": 900,
"dr6_pa6_f090": 600,
"dr6_pa6_f150": 900
}
lmax = 2000
include_fg = d["include_fg"]
fg_dir = d["fg_dir"]
fg_components = d["fg_components"]
fg_components["tt"].remove("tSZ_and_CIB")
for comp in ["tSZ", "cibc", "tSZxCIB"]:
fg_components["tt"].append(comp)
window_dir = "windows"
mcm_dir = "mcms"
noise_data_dir = "sim_data/noise_ps"
specDir = "spectra"
lmax_simu = lmax
pspy_utils.create_directory(specDir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
spin_pairs = ["spin0xspin0", "spin0xspin2", "spin2xspin0", "spin2xspin2"]
all_freqs = [freq for exp in experiments for freq in d["freqs_%s" % exp]]
ncomp = 3
ps_cmb = powspec.read_spectrum(d["clfile"])[:ncomp, :ncomp]
if include_fg == True:
l, ps_fg = maps_to_params_utils.get_foreground_matrix(
fg_dir, fg_components, all_freqs, lmax_simu + 1)
so_mpi.init(True)
subtasks = so_mpi.taskrange(imin=d["iStart"], imax=d["iStop"])
"""
This script computes the mode coupling matrices and the binning matrices Bbl
for the different surveys and arrays.
"""
from pspy import so_map, so_mcm, pspy_utils, so_dict, so_mpi
import sys
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
mcm_dir = "mcms"
pspy_utils.create_directory(mcm_dir)
surveys = d["surveys"]
lmax = d["lmax"]
if d["use_toeplitz"] == True:
print("we will use the toeplitz approximation")
l_exact, l_band, l_toep = 800, 2000, 2750
else:
l_exact, l_band, l_toep = None, None, None
sv1_list, ar1_list, sv2_list, ar2_list = [], [], [], []
n_mcms = 0
for id_sv1, sv1 in enumerate(surveys):
arrays_1 = d["arrays_%s" % sv1]
for id_ar1, ar1 in enumerate(arrays_1):
for id_sv2, sv2 in enumerate(surveys):
arrays_2 = d["arrays_%s" % sv2]
for id_ar2, ar2 in enumerate(arrays_2):
import sys
import numpy as np
import pylab as plt
from pspy import pspy_utils, so_dict
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
surveys = d["surveys"]
fg_array = np.loadtxt(d["fgfile"])
bestfit_dir = "best_fits"
plot_dir = "plots/best_fits/"
pspy_utils.create_directory(bestfit_dir)
pspy_utils.create_directory(plot_dir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
clth = {}
lth, clth["TT"], clth["EE"], clth["BB"], clth["TE"] = np.loadtxt(
d["theoryfile"], unpack=True)
# fmt: off
combin = [
"TT_90x90", "TT_90x150", "TT_150x150", "TE_90x90", "TE_90x150",
"TE_150x150", "EE_90x90", "EE_90x150", "EE_150x150"
]
fg_dict = {}
from pixell import enmap
import time
import scipy.interpolate
import planck_utils
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
auxMapDir='window'
mcmDir='mcm'
spectraDir='spectra'
ps_model_dir='model'
plot_dir='plot'
pspy_utils.create_directory(ps_model_dir)
pspy_utils.create_directory(plot_dir)
spectra=['TT','TE','TB','ET','BT','EE','EB','BE','BB']
type=d['type']
freqs=d['freqs']
binning_file=d['binning_file']
lmax=d['lmax']
splits=['hm1','hm2']
size=d['noise_binning_size']
experiment='Planck'
lth = np.arange(2, lmax+2)
bl={}
for freq in freqs:
type = d["type"]
binning_file = d["binning_file"]
sim_alm_dtype = d["sim_alm_dtype"]
if sim_alm_dtype == "complex64":
sim_alm_dtype = np.complex64
elif sim_alm_dtype == "complex128":
sim_alm_dtype = np.complex128
window_dir = "windows"
mcm_dir = "mcms"
tf_dir = "sim_spectra_for_tf"
bestfit_dir = "best_fits"
ps_model_dir = "noise_model"
pspy_utils.create_directory(tf_dir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
spin_pairs = ["spin0xspin0", "spin0xspin2", "spin2xspin0", "spin2xspin2"]
# let's list the different frequencies used in the code
freq_list = []
for sv in surveys:
arrays = d["arrays_%s" % sv]
for ar in arrays:
freq_list += [d["nu_eff_%s_%s" % (sv, ar)]]
freq_list = list(dict.fromkeys(freq_list)) # this bit removes doublons
id_freq = {}
# create a list assigning an integer index to each freq (used later in the code to generate fg simulations)
for count, freq in enumerate(freq_list):
"""
This script compute all alms squared windows, it's a necessary step of covariance computation.
"""
from pspy import so_dict, so_map, sph_tools, so_spectra, pspy_utils, so_mpi
import numpy as np
import sys
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
surveys = d["surveys"]
lmax = d["lmax"]
niter = d["niter"]
sq_win_alms_dir = "sq_win_alms"
pspy_utils.create_directory(sq_win_alms_dir)
sv1_list, ar1_list, sv2_list, ar2_list = [], [], [], []
n_alms = 0
for id_sv1, sv1 in enumerate(surveys):
arrays_1 = d["arrays_%s" % sv1]
for id_ar1, ar1 in enumerate(arrays_1):
for id_sv2, sv2 in enumerate(surveys):
arrays_2 = d["arrays_%s" % sv2]
for id_ar2, ar2 in enumerate(arrays_2):
# This ensures that we do not repeat redundant computations
if (id_sv1 == id_sv2) & (id_ar1 > id_ar2): continue
if (id_sv1 > id_sv2): continue
sv1_list += [sv1]
ar1_list += [ar1]
sv2_list += [sv2]
import pylab as plt, numpy as np
from pspy import pspy_utils, so_dict, so_map
import ps_tools
import sys
import pickle
import time
import spectra_plot_utils
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
run_name = d["run_name"]
spectra_dir = "spectra_%s" % run_name
plot_dir = "plot_%s" % run_name
pspy_utils.create_directory(spectra_dir)
pspy_utils.create_directory(plot_dir)
lmax = d["lmax"]
type = d["type"]
clfile = d["clfile"]
l_exact_array = d["l_exact_array"]
l_band_array = d["l_band_array"]
l_toep_array = d["l_toep_array"]
compute_T_only = d["compute_T_only"]
l_lo, l_hi, lb, delta_l = pspy_utils.read_binning_file("data/binning.dat",
lmax)
id_sim = d["id_sim"]
result_ps = {}
result_cov = {}
import numpy as np, healpy as hp, pylab as plt
from pspy import pspy_utils, so_dict
import os, sys
import wget
import tarfile
import astropy.io.fits as fits
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
# You have to spefify the data directory in which the products will be downloaded
data_dir = d['data_dir']
freqs = d['freqs']
pspy_utils.create_directory(data_dir)
# Choose what you want to download, if this is your first try, all of this should be set to True
download_maps = True
download_likelihood_mask = True
download_beams = True
if download_maps == True:
print('Download Planck data maps')
maps_dir = data_dir + '/maps'
pspy_utils.create_directory(maps_dir)
# Planck keep inconsistent notation for the halfmission, sometimes 'halfmission-1' sometimes 'hm1'
splits = ['halfmission-1', 'halfmission-2']
for hm in splits:
for f in freqs:
url = 'http://pla.esac.esa.int/pla/aio/product-action?MAP.MAP_ID=HFI_SkyMap_%s_2048_R3.01_%s.fits' % (
To run it:
python get_planck_mcm_Bbl.py global.dict
'''
import numpy as np,healpy as hp,pylab as plt
from pspy import so_dict, so_map,so_mcm,sph_tools,so_spectra,pspy_utils, so_map_preprocessing
import os,sys
from pixell import enmap
import time
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
auxMapDir='window'
mcmDir='mcm'
pspy_utils.create_directory(auxMapDir)
pspy_utils.create_directory(mcmDir)
freqs=d['freqs']
niter=d['niter']
lmax=d['lmax']
type=d['type']
binning_file=d['binning_file']
pixWin=d['pixWin']
splits=d['splits']
experiment='Planck'
print ('Compute Planck 2018 mode coupling matrices')
for c1,freq1 in enumerate(freqs):
experiments = d["experiments"]
binning_file = d["binning_file"]
lmax = d["lmax"]
type = d["type"]
isims = np.arange(100)
bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file(
binning_file, lmax)
n_bins = len(bin_hi)
like_dir = "like_products"
mcm_dir = "mcms"
cov_dir = "covariances"
pspy_utils.create_directory(like_dir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
spin_pairs = ["spin0xspin0", "spin0xspin2", "spin2xspin0", "spin2xspin2"]
g = open("%s/spectra_list.txt" % like_dir, mode="w")
for id_exp1, exp1 in enumerate(experiments):
freqs1 = d["freqs_%s" % exp1]
for id_f1, f1 in enumerate(freqs1):
for id_exp2, exp2 in enumerate(experiments):
freqs2 = d["freqs_%s" % exp2]
for id_f2, f2 in enumerate(freqs2):
if (id_exp1 == id_exp2) & (id_f1 > id_f2): continue
for different frequency channels of different CMB experiments and write them to disk.
"""
from pspy import so_map, so_window, so_mcm, pspy_utils, so_dict
import healpy as hp
import numpy as np
import pylab as plt
import sys
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
window_dir = "windows"
mcm_dir = "mcms"
plot_dir = "plots/windows/"
pspy_utils.create_directory(window_dir)
pspy_utils.create_directory(mcm_dir)
pspy_utils.create_directory(plot_dir)
experiments = d["experiments"]
lmax = d["lmax"]
lmax_mcm = d["lmax_mcm"]
# The first step of this code is to generate the window functions for the different frequency channels
# of the different experiments.
print("Geneating window functions")
for exp in experiments:
freqs = d["freqs_%s" % exp]
surveys = d["surveys"]
# Here enter the folder where the actual run is
run_dir = ""
bestfit_dir = "%s/best_fits" % run_dir
ps_model_dir = "%s/noise_model" % run_dir
dummy_data_dir = "dummy_data"
lmax = 2000
ra0, ra1, dec0, dec1 = -10, 10, -10, 10
res = 3
pspy_utils.create_directory(dummy_data_dir)
# let's list the different frequencies used in the code
freq_list = []
for sv in surveys:
arrays = d["arrays_%s" % sv]
for ar in arrays:
freq_list += [d["nu_eff_%s_%s" % (sv, ar)]]
freq_list = list(dict.fromkeys(freq_list)) # this bit removes doublons
id_freq = {}
# create a list assigning an integer index to each freq (used later in the code to generate fg simulations)
for count, freq in enumerate(freq_list):
id_freq[freq] = count
# we read cmb and fg best fit power spectrum
type = d['type']
binning_file = d['binning_file']
remove_mono_dipo_T = d['remove_mono_dipo_T']
remove_mono_dipo_pol = d['remove_mono_dipo_pol']
experiment = 'Planck'
splits = d['splits']
include_sys = d['include_systematics']
include_foregrounds = d['include_foregrounds']
use_noise_th = d['use_noise_th']
if include_sys == True:
simSpectraDir = 'sim_spectra_syst'
else:
simSpectraDir = 'sim_spectra'
pspy_utils.create_directory(simSpectraDir)
nside = 2048
ncomp = 3
template = so_map.healpix_template(ncomp, nside)
if include_foregrounds == True:
ps_th = np.load('%s/signal_fg_matrix.npy' % theoryFgDir)
else:
ps_th = powspec.read_spectrum(d['theoryfile'])[:ncomp, :ncomp]
nSplits = len(splits)
l, Nl_T, Nl_P = planck_utils.get_noise_matrix_spin0and2(
ps_model_dir,
from itertools import combinations
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
surveys = d["surveys"]
n_surveys = len(surveys)
arrays = [d["arrays_%s" % survey] for survey in surveys]
spec_dir = "../../spectra/"
cov_dir = "../../covariances/"
output_dir = "../outputs/"
output_plot_dir = os.path.join(output_dir, "plots/")
output_data_dir = os.path.join(output_dir, "data/")
pspy_utils.create_directory(output_plot_dir)
pspy_utils.create_directory(output_data_dir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
modes = ["TT", "TE", "ET", "EE"]
#### SEASON NULL TESTS ####
if n_surveys < 2:
sys.exit("Cannot make season null tests with only 1 season.")
spectra_names = [[m for m in cwr(arrays[i], 2)] for i in range(n_surveys)]
survey_differences = [m for m in combinations(surveys, 2)]
index_differences = [m for m in combinations(np.arange(n_surveys), 2)]
chi2_array = {}
chi2_dict = {}
import sys
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
n_sims = d["n_sims"]
beamed_clfile = d["beamed_clfile"]
res_arcmin = d["res_arcmin"]
name_split = d["name_split"]
n_splits = d["n_splits"]
rms_uKarcmin_T = d["rms_uKarcmin_T"] * np.sqrt(n_splits)
ra0, ra1, dec0, dec1 = d["ra0"], d["ra1"], d["dec0"], d["dec1"]
run_name = d["run_name"]
sim_dir = "sims_%s" % run_name
pspy_utils.create_directory(sim_dir)
eps = 1
template_car = so_map.car_template(3, ra0 - eps, ra1 + eps, dec0 - eps,
dec1 + eps, res_arcmin)
for iii in range(n_sims):
print("generate sim %03d" % iii)
cmb = template_car.synfast(beamed_clfile)
for i in range(n_splits):
name = "sim_%03d_%s%d" % (iii, name_split, i)
split = cmb.copy()
noise = so_map.white_noise(split, rms_uKarcmin_T=rms_uKarcmin_T)
split.data += noise.data
split.write_map("%s/%s.fits" % (sim_dir, name))
split.plot(file_name="%s/%s" % (sim_dir, name))
import numpy as np
import pylab as plt
from pspy import so_dict, so_spectra, pspy_utils
import os, sys
import planck_utils
import matplotlib as mpl
label_size = 14
mpl.rcParams['xtick.labelsize'] = label_size
mpl.rcParams['ytick.labelsize'] = label_size
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
figure_dir = 'figures'
pspy_utils.create_directory(figure_dir)
spectraDir = 'spectra'
if d['use_ffp10'] == True:
mc_dir = 'monteCarlo_ffp10'
plot_name = 'all_cross_ffp10'
else:
mc_dir = 'monteCarlo'
plot_name = 'all_cross'
spectra = ['TT', 'TE', 'TB', 'ET', 'BT', 'EE', 'EB', 'BE', 'BB']
binning_file = d['binning_file']
freqs = d['freqs']
lthmax = 1500
import numpy as np
from pspy import pspy_utils, so_dict
import sys
import wget
import tarfile
import astropy.io.fits as fits
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
# You have to spefify the data directory in which the products will be downloaded
data_dir = d["data_dir"]
freqs = d["freqs"]
pspy_utils.create_directory(data_dir)
EB_mask_dir = data_dir + "/EB_masks"
pspy_utils.create_directory(EB_mask_dir)
# Planck keep inconsistent notation for the halfmission, sometimes 'halfmission-1' sometimes 'hm1'
for f in freqs:
if f == "143": continue
url = "http://pla.esac.esa.int/pla/aio/product-action?MAP.MAP_ID=HFI_BiasMap_%s-CO-noiseRatio_2048_R3.00_full.fits" % (
f)
print(url)
wget.download(
url, "%s/HFI_BiasMap_%s-CO-noiseRatio_2048_R3.00_full.fits" %
(EB_mask_dir, f))
url = "http://pla.esac.esa.int/pla/aio/product-action?MAP.MAP_ID=HFI_Mask_PointSrc_2048_R2.00.fits"
print(url)
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
# the apodisation lenght of the point source mask in degree
apod_pts_source_degree = d["apod_pts_source_degree"]
# the apodisation lenght of the survey x gal x cross linking mask
apod_survey_degree = d["apod_survey_degree"]
# we will skip the edges of the survey where the noise is very difficult to model
skip_from_edges_degree = d["skip_from_edges_degree"]
# the threshold on the amount of cross linking to keep the data in
cross_link_threshold = d["cross_link_threshold"]
window_dir = "windows"
surveys = d["surveys"]
pspy_utils.create_directory(window_dir)
ps_mask = so_map.read_map(d["ps_mask"])
gal_mask = so_map.read_map(d["gal_mask"])
patch = None
if "patch" in d:
patch = so_map.read_map(d["patch"])
# here we list the different windows that need to be computed, we will then do a MPI loops over this list
sv_list, ar_list = [], []
n_wins = 0
for sv in surveys:
arrays = d["arrays_%s" % sv]
for ar in arrays:
sv_list += [sv]
from pspy import so_dict, pspy_utils, so_spectra, so_cov
from itertools import combinations_with_replacement as cwr
from itertools import product
import data_analysis_utils
import numpy as np
import pylab as plt
import sys, os
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
cov_dir = "covariances"
spec_dir = "spectra"
like_product_dir = "like_product"
pspy_utils.create_directory(like_product_dir)
surveys = d["surveys"]
type = d["type"]
lmax = d["lmax"]
binning_file = d["binning_file"]
bin_lo, bin_hi, lb, bin_size = pspy_utils.read_binning_file(binning_file, lmax)
n_bins = len(bin_hi)
# we will need the covariance matrix and the projection matrix
cov_mat = np.load("%s/truncated_analytic_cov.npy" % cov_dir)
P_mat = np.load("%s/projection_matrix.npy" % cov_dir)
# let's get a list of all frequencies we plan to study
freq_list = []
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
experiments = d["experiments"]
type = d["type"]
iStart = d["iStart"]
iStop = d["iStop"] + 1
mcm_dir = "mcms"
cov_dir = "covariances"
spec_dir = "spectra"
sacc_dir = "like_products_sacc"
pspy_utils.create_directory(sacc_dir)
pols = ["T", "E", "B"]
map_types = {"T": "0", "E": "e", "B": "b"}
def get_x_iterator():
for id_ea, ea in enumerate(experiments):
freqs_a = d["freqs_%s" % ea]
for id_fa, fa in enumerate(freqs_a):
for id_eb, eb in enumerate(experiments):
freqs_b = d["freqs_%s" % eb]
for id_fb, fb in enumerate(freqs_b):
if (id_ea == id_eb) & (id_fa > id_fb): continue
if (id_ea > id_eb): continue
for ipa, pa in enumerate(pols):
import matplotlib
matplotlib.use('Agg')
import numpy as np, healpy as hp, pylab as plt
from pspy import so_dict, so_map, so_mcm, sph_tools, so_spectra, pspy_utils, so_map_preprocessing
import os, sys
from pixell import enmap, powspec
import time
import planck_utils
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
theoryFgDir = 'theory_and_fg'
pspy_utils.create_directory(theoryFgDir)
freqs = d['freqs']
spectra = ['TT', 'TE', 'TB', 'ET', 'BT', 'EE', 'EB', 'BE', 'BB']
freq_pairs = []
for c1, freq1 in enumerate(freqs):
for c2, freq2 in enumerate(freqs):
if c1 > c2: continue
freq_pairs += [[freq1, freq2]]
clth = {}
fg = {}
lth, cl_TT, cl_EE, cl_BB, cl_TE = np.loadtxt(
'theory_file/cosmo2017_10K_acc3_lensedCls.dat', unpack=True)
clth['TT'] = cl_TT
clth['TE'] = cl_TE
import time
# We start by reading the info in the dictionnary
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
experiment=d['experiment']
content=d['content']
name=d['combinaison_name']
plot_dir='maps_plot'
combined_map_dir='combined_maps'
survey_mask_dir='survey_masks'
# Create three folders, one for the plot of the simulations, one for storing the combined maps and one for the survey masks
pspy_utils.create_directory(plot_dir)
pspy_utils.create_directory(combined_map_dir)
pspy_utils.create_directory(survey_mask_dir)
# We loop on all the different experiments that we want to consider
for exp in experiment:
# Each experiment could have its associated nside and frequency list
nside=d['nside_%s'%exp]
freqs=d['freq_%s'%exp]
for count,freq in enumerate(freqs):
#We create a template for each frequency and add all composents present in 'content'
map_all=so_map.healpix_template(ncomp=3,nside=nside)
for cont in content:
maps_list= d['%s_maps'%cont]
map=maps_list[count]
The inputs for the script are the Planck beam and likelihood masks.
To run it:
python get_planck_mcm_Bbl.py global.dict
'''
import numpy as np
import healpy as hp
from pspy import so_dict, so_map, so_mcm, pspy_utils, so_mpi
import sys
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
windows_dir = "windows"
mcm_dir = "mcms"
pspy_utils.create_directory(windows_dir)
pspy_utils.create_directory(mcm_dir)
freqs = d["freqs"]
niter = d["niter"]
lmax = d["lmax"]
type = d["type"]
binning_file = d["binning_file"]
pixwin = d["pixwin"]
splits = d["splits"]
experiment = "Planck"
print("Compute Planck 2018 mode coupling matrices")
freq1_list, hm1_list, freq2_list, hm2_list = [], [], [], []
n_mcms = 0
from pspy import pspy_utils, so_dict, so_spectra
import numpy as np
import sys
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
type = d["type"]
surveys = d["surveys"]
iStart = d["iStart"]
iStop = d["iStop"]
spec_dir = "sim_spectra"
cov_dir = "covariances"
pspy_utils.create_directory(cov_dir)
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
spec_list = []
for id_sv1, sv1 in enumerate(surveys):
arrays_1 = d["arrays_%s" % sv1]
for id_ar1, ar1 in enumerate(arrays_1):
for id_sv2, sv2 in enumerate(surveys):
arrays_2 = d["arrays_%s" % sv2]
for id_ar2, ar2 in enumerate(arrays_2):
if (id_sv1 == id_sv2) & (id_ar1 > id_ar2): continue
if (id_sv1 > id_sv2): continue
spec_list += ["%s_%sx%s_%s" % (sv1, ar1, sv2, ar2)]
for sid1, spec1 in enumerate(spec_list):
"""
This script generates fake beams and transfer function.
to run it:
python systematic_model.py
"""
import numpy as np, pylab as plt, matplotlib as mpl
from pspy import pspy_utils
syst_dir = 'systematics'
pspy_utils.create_directory(syst_dir)
FWHM = 7.30
FWHM_syst = 0.95 * FWHM
beam_FWHM_rad = np.deg2rad(FWHM_syst) / 60
beam = beam_FWHM_rad / np.sqrt(8 * np.log(2))
l = np.arange(2, 5000)
bl = np.exp(-l * (l + 1) * beam**2 / 2.)
np.savetxt('%s/beam.dat' % (syst_dir), np.transpose([l, bl]))
lmax_array = [400, 200]
min_TF_array = [0.7, 0.8]
cal = 1.
pol_eff = 1.
cal_array = [cal, cal * pol_eff]
name_array = ['T', 'pol']
for name, lmax, min_TF, cal in zip(name_array, lmax_array, min_TF_array,
freqs = d["freqs"]
lmax = d["lmax"]
lrange = d["lrange"]
bestfit_dir = "best_fits"
plot_dir = "plots/sim_analysis/"
if d["use_ffp10"] == True:
sim_spectra_dir = "sim_spectra_ffp10"
mc_dir = "montecarlo_ffp10"
else:
sim_spectra_dir = "sim_spectra"
mc_dir = "montecarlo"
pspy_utils.create_directory(mc_dir)
pspy_utils.create_directory(plot_dir)
freq_pairs = []
for cross in cwr(freqs, 2):
freq_pairs += [[cross[0], cross[1]]]
vec_list = []
bin_range = {}
for iii in range(iStart, iStop):
vec = []
bin_start = 0
bin_stop = 0
for spec in ["TT", "EE", "TE"]:
lth, Clth = pspy_utils.ps_lensed_theory_to_dict(clfile,
output_type="Cl",
lmax=lmax,
start_at_zero=False)
Cb_th = {}
lb, Cb_th["EE"] = planck_utils.binning(lth, Clth["EE"], lmax, binning_file)
lb, Cb_th["BB"] = planck_utils.binning(lth, Clth["BB"], lmax, binning_file)
if d["use_ffp10"]:
mc_dir = "montecarlo_ffp10_larger_bin"
else:
mc_dir = "montecarlo"
chain_dir = "chains"
pspy_utils.create_directory(chain_dir)
lmin, lmax = 100, 1500
id = np.where((lb >= lmin) & (lb <= lmax))
lb, Cb_th["EE"], Cb_th["BB"] = lb[id], Cb_th["EE"][id], Cb_th["BB"][id]
nbins = len(lb)
Cb_th_array = np.zeros((2, nbins))
Cb_th_array[0, :] = Cb_th["EE"]
Cb_th_array[1, :] = Cb_th["BB"]
# first we read the data
cov = np.load("%s/mc_covariance_EB.npy" % mc_dir)
size_cov = cov.shape[0]
cov_EB = cov[np.int(2 * size_cov / 3):, np.int(2 * size_cov / 3):]
"""
#import matplotlib
#matplotlib.use("Agg")
from pspy import pspy_utils, so_dict
import numpy as np
import pylab as plt
from itertools import combinations_with_replacement as cwr
import os
import sys
import so_noise_calculator_public_20180822 as noise_calc
from copy import deepcopy
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
pspy_utils.create_directory("sim_data")
plot_dir = "plots/model/"
pspy_utils.create_directory(plot_dir)
linestyle = {}
linestyle["LAT"] = "solid"
linestyle["Planck"] = "dashed"
# We start with SO, we have to specify a sensitivity mode (2: goal, 1: baseline), and f_sky
# both parameters are specified in the dictionnary
sensitivity_mode = d["sensitivity_mode"]
f_sky_LAT = d["f_sky_LAT"]
freqs = {}
freqs["LAT"] = ["27", "39", "93", "145", "225", "280"]
#import matplotlib
#matplotlib.use('Agg')
import numpy as np
import pylab as plt
from pspy import so_dict, so_map, so_mcm, sph_tools, so_spectra, pspy_utils, so_map_preprocessing, so_mpi
import os, sys
from pixell import enmap
import time, os
d = so_dict.so_dict()
d.read_from_file(sys.argv[1])
spectraDir = 'spectra'
mcmDir = 'mcm'
pspy_utils.create_directory(spectraDir)
pspy_utils.create_directory(mcmDir)
spectra = ['TT', 'TE', 'TB', 'ET', 'BT', 'EE', 'EB', 'BE', 'BB']
arrays = d['arrays']
niter = d['niter']
lmax = 3000
type = d['type']
binning_file = d['binning_file']
theoryfile = d['theoryfile']
fsky = {}
fsky['pa1'] = 'fsky0.01081284'
fsky['pa2'] = 'fsky0.01071187'
apo = so_map.read_map(d['apo_path'])
