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
import os, sys
from pixell import enmap
import time, os

d = so_dict.so_dict()
d.read_from_file(sys.argv[1])

spectraDir = 'spectra'
try:
    os.makedirs(spectraDir)
except:
    pass

spectra = ['TT', 'TE', 'TB', 'ET', 'BT', 'EE', 'EB', 'BE', 'BB']

arrays = d['arrays']
niter = d['niter']
lmax = d['lmax']
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'])
Exemple #2
0
def get_cl_array(cosmo_parameters, fg_parameters, ell_max, freq_list,
                 noise_list_matrix):

    d = so_dict.so_dict()
    d.read_from_file("global_healpix_example.dict")
    fg_norm = d["fg_norm"]
    components = {"tt": d["fg_components"], "ee": [], "te": []}
    fg_model = {"normalisation": fg_norm, "components": components}
    fg_params = {
        'a_tSZ': fg_parameters[0],
        'a_kSZ': fg_parameters[1],
        'a_p': fg_parameters[2],
        'beta_p': fg_parameters[3],
        'a_c': fg_parameters[4],
        'beta_c': fg_parameters[5],
        'n_CIBC': 1.2,
        'a_s': fg_parameters[6],
        'T_d': 9.6
    }

    pars = camb.CAMBparams()
    pars.set_cosmology(H0=cosmo_parameters[0],
                       ombh2=cosmo_parameters[1],
                       omch2=cosmo_parameters[2],
                       mnu=0.06,
                       omk=0,
                       tau=cosmo_parameters[5])
    pars.InitPower.set_params(As=1e-10 * np.exp(cosmo_parameters[3]),
                              ns=cosmo_parameters[4],
                              r=0)
    pars.set_for_lmax(ell_max - 1, lens_potential_accuracy=0)
    results = camb.get_results(pars)
    powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
    totCL = powers['total']

    TT = totCL[:, 0][2:]
    ell_list = np.arange(len(TT) + 2)[2:]

    power_spectrum_matrix = []

    noise_list_matrix = [
        element[:len(freq_list), :len(freq_list)]
        for element in noise_list_matrix
    ]

    fg_dict = mfl.get_foreground_model(fg_params, fg_model, freq_list,
                                       ell_list)

    n_ell = len(ell_list)
    n_freqs = len(freq_list)

    for ell in range(n_ell):
        c_matrix = np.ones((n_freqs, n_freqs)) * TT[ell]
        for i in range(n_freqs):
            for j in range(n_freqs):
                c_matrix[i, j] = c_matrix[i, j] + noise_list_matrix[ell][
                    i, j] + fg_dict['tt', 'all', freq_list[i],
                                    freq_list[j]][ell]
        power_spectrum_matrix.append(c_matrix)

    return (np.array(power_spectrum_matrix))