def quick_analytic_cov(l, Clth_dict, window, binning_file, lmax): bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file( binning_file, lmax) nbins = len(bin_size) fsky = steve_effective_fsky(window) prefac = 1 / ((2 * bin_c + 1) * fsky * bin_size) cov = {} cov["TT"] = Clth_dict["TaTc"] * Clth_dict["TbTd"] + Clth_dict[ "TaTd"] * Clth_dict["TbTc"] cov["TE"] = Clth_dict["TaTc"] * Clth_dict["EbEd"] + Clth_dict[ "TaEd"] * Clth_dict["EbTc"] cov["ET"] = Clth_dict["EaEc"] * Clth_dict["TbTd"] + Clth_dict[ "EaTd"] * Clth_dict["TbEc"] cov["EE"] = Clth_dict["EaEc"] * Clth_dict["EbEd"] + Clth_dict[ "EaEd"] * Clth_dict["EbEc"] mat_diag = np.zeros((4 * nbins, 4 * nbins)) for count, spec in enumerate(["TT", "TE", "ET", "EE"]): lb, cov[spec] = pspy_utils.naive_binning(l, cov[spec], binning_file, lmax) cov[spec] *= prefac for i in range(nbins): mat_diag[i + count * nbins, i + count * nbins] = cov[spec][i] return fsky, mat_diag
def process_planck_spectra(l, cl, binning_file, lmax, type, spectra=None, mcm_inv=None): bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file( binning_file, lmax) n_bins = len(bin_hi) fac = (l * (l + 1) / (2 * np.pi)) unbin_vec = [] mcm_inv = so_mcm.coupling_dict_to_array(mcm_inv) for f in spectra: unbin_vec = np.append(unbin_vec, cl[f][2:lmax]) cl = so_spectra.vec2spec_dict(lmax - 2, np.dot(mcm_inv, unbin_vec), spectra) l = np.arange(2, lmax) print(l.shape, cl['TT'].shape) vec = [] for f in spectra: binnedPower = np.zeros(len(bin_c)) for ibin in range(n_bins): loc = np.where((l >= bin_lo[ibin]) & (l <= bin_hi[ibin])) binnedPower[ibin] = (cl[f][loc] * fac[loc]).mean() / (fac[loc].mean()) vec = np.append(vec, binnedPower) return l, cl, bin_c, so_spectra.vec2spec_dict(n_bins, vec, spectra)
def binning(l, cl, lmax, binning_file=None, size=None): if binning_file is not None: bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file(binning_file, lmax) else: bin_lo = np.arange(2, lmax, size) bin_hi = bin_lo + size - 1 bin_c = (bin_lo + bin_hi) / 2 fac = (l * (l + 1) / (2 * np.pi)) n_bins = len(bin_hi) binnedPower = np.zeros(len(bin_c)) for ibin in range(n_bins): loc = np.where((l >= bin_lo[ibin]) & (l <= bin_hi[ibin])) binnedPower[ibin] = (cl[loc]*fac[loc]).mean()/(fac[loc].mean()) return bin_c, binnedPower
split.data *= cal if d["remove_mean"] == True: split = data_analysis_utils.remove_mean(split, window_tuple, ncomp) #split.plot(file_name="%s/split_%d_%s_%s" % (plot_dir, k, sv, ar), color_range=[250, 100, 100]) master_alms[sv, ar, k] = sph_tools.get_alms(split, window_tuple, niter, lmax) if d["use_kspace_filter"]: # there is an extra normalisation for the FFT/IFFT bit # note that we apply it here rather than at the FFT level because correcting the alm is faster than correcting the maps master_alms[sv, ar, k] /= (split.data.shape[1]*split.data.shape[2]) print(time.time()- t) ps_dict = {} _, _, lb, _ = pspy_utils.read_binning_file(binning_file, lmax) for id_sv1, sv1 in enumerate(surveys): arrays_1 = d["arrays_%s" % sv1] nsplits_1 = nsplit[sv1] if d["tf_%s" % sv1] is not None: print("will deconvolve tf of %s" %sv1) _, _, tf1, _ = np.loadtxt(d["tf_%s" % sv1], unpack=True) else: tf1 = np.ones(len(lb)) for id_ar1, ar1 in enumerate(arrays_1): for id_sv2, sv2 in enumerate(surveys): arrays_2 = d["arrays_%s" % sv2]
for j in range(nbins): if np.abs(lb[i]-lb[j]) < delta_l: cut_mat[i,j] = mat[i,j] return cut_mat d = so_dict.so_dict() d.read_from_file(sys.argv[1]) cov_dir = "covariances" mc_dir = "montecarlo" exp = "Planck" lmax = d["lmax"] binning_file = d["binning_file"] freqs = d["freqs"] bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file(binning_file, lmax) nbins = len(bin_hi) spec_name = [] for c1,freq1 in enumerate(freqs): for c2,freq2 in enumerate(freqs): if c1>c2: continue spec_name += ["%s_%sx%s_%s" % (exp, freq1, exp, freq2)] # pspy produced TT-TE-ET-EE block covariance matrix, in this step of the code we read them and plug them in # a multifrequency covariance matrix of size 4 (TT-TE-ET-EE) * nbins * nspec (100x100, 100x143, ..., 217x217) # we also create a projection matrix that will be used for combining TE and ET in the futur analytic_dict= {} spectra = ["TT", "TE", "ET", "EE"]
def covariance_element(coupling, id_element, ns, ps_all, nl_all, binning_file, mbb_inv_ab, mbb_inv_cd): na, nb, nc, nd = id_element lmax = coupling["TaTcTbTd"].shape[0] bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file(binning_file, lmax) nbins = len(bin_hi) analytic_cov = np.zeros((4*nbins, 4*nbins)) # TaTbTcTd M_00 = coupling["TaTcTbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TTTT") M_00 += coupling["TaTdTbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TTTT") analytic_cov[0*nbins:1*nbins, 0*nbins:1*nbins] = so_cov.bin_mat(M_00, binning_file, lmax) # TaEbTcEd M_11 = coupling["TaTcPbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TTEE") M_11 += coupling["TaPdPbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TEET") analytic_cov[1*nbins:2*nbins, 1*nbins:2*nbins] = so_cov.bin_mat(M_11, binning_file, lmax) # EaTbEcTd M_22 = coupling["PaPcTbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "EETT") M_22 += coupling["PaTdTbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "ETTE") analytic_cov[2*nbins:3*nbins, 2*nbins:3*nbins] = so_cov.bin_mat(M_22, binning_file, lmax) # EaEbEcEd M_33 = coupling["PaPcPbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "EEEE") M_33 += coupling["PaPdPbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "EEEE") analytic_cov[3*nbins:4*nbins, 3*nbins:4*nbins] = so_cov.bin_mat(M_33, binning_file, lmax) # TaTbTcEd M_01 = coupling["TaTcTbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TTTE") M_01 += coupling["TaPdTbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TETT") analytic_cov[0*nbins:1*nbins, 1*nbins:2*nbins] = so_cov.bin_mat(M_01, binning_file, lmax) # TaTbEcTd M_02 = coupling["TaPcTbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TETT") M_02 += coupling["TaTdTbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TTTE") analytic_cov[0*nbins:1*nbins, 2*nbins:3*nbins] = so_cov.bin_mat(M_02, binning_file, lmax) # TaTbEcEd M_03 = coupling["TaPcTbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TETE") M_03 += coupling["TaPdTbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TETE") analytic_cov[0*nbins:1*nbins, 3*nbins:4*nbins] = so_cov.bin_mat(M_03, binning_file, lmax) # TaEbEcTd M_12 = coupling["TaPcPbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TEET") M_12 += coupling["TaTdPbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TTEE") analytic_cov[1*nbins:2*nbins, 2*nbins:3*nbins] = so_cov.bin_mat(M_12, binning_file, lmax) # TaEbEcEd M_13 = coupling["TaPcPbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TEEE") M_13 += coupling["TaPdPbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TEEE") analytic_cov[1*nbins:2*nbins, 3*nbins:4*nbins] = so_cov.bin_mat(M_13, binning_file, lmax) # EaTbEcEd M_23 = coupling["PaPcTbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "EETE") M_23 += coupling["PaPdTbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "EETE") analytic_cov[2*nbins:3*nbins, 3*nbins:4*nbins] = so_cov.bin_mat(M_23, binning_file, lmax) # TaEbTcTd M_10 = coupling["TaTcPbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "TTET") M_10 += coupling["TaTdPbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "TTET") analytic_cov[1*nbins:2*nbins, 0*nbins:1*nbins] = so_cov.bin_mat(M_10, binning_file, lmax) # EaTbTcTd M_20 = coupling["PaTcTbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "ETTT") M_20 += coupling["PaTdTbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "ETTT") analytic_cov[2*nbins:3*nbins, 0*nbins:1*nbins] = so_cov.bin_mat(M_20, binning_file, lmax) # EaEbTcTd M_30 = coupling["PaTcPbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "ETET") M_30 += coupling["PaTdPbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "ETET") analytic_cov[3*nbins:4*nbins, 0*nbins:1*nbins] = so_cov.bin_mat(M_30, binning_file, lmax) # EaTbTcEd M_21 = coupling["PaTcTbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "ETTE") M_21 += coupling["PaPdTbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "EETT") analytic_cov[2*nbins:3*nbins, 1*nbins:2*nbins] = so_cov.bin_mat(M_21, binning_file, lmax) # EaEbTcEd M_31 = coupling["PaTcPbPd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "ETEE") M_31 += coupling["PaPdPbTc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "EEET") analytic_cov[3*nbins:4*nbins, 1*nbins:2*nbins] = so_cov.bin_mat(M_31, binning_file, lmax) # EaEbEcTd M_32 = coupling["PaPcPbTd"] * chi(na, nc, nb, nd, ns, ps_all, nl_all, "EEET") M_32 += coupling["PaTdPbPc"] * chi(na, nd, nb, nc, ns, ps_all, nl_all, "ETEE") analytic_cov[3*nbins:4*nbins, 2*nbins:3*nbins] = so_cov.bin_mat(M_32, binning_file, lmax) mbb_inv_ab = so_cov.extract_TTTEEE_mbb(mbb_inv_ab) mbb_inv_cd = so_cov.extract_TTTEEE_mbb(mbb_inv_cd) analytic_cov = np.dot(np.dot(mbb_inv_ab, analytic_cov), mbb_inv_cd.T) return analytic_cov
def get_covariance(window, lmax, spec_name_list, ps_dict, binning_file, error_method="master", spectra=None, l_thres=None, l_toep=None, mbb_inv=None, compute_T_only=False): """Compute the covariance matrix of the power spectrum in the patch Parameters ---------- window: so_map the window function of the patch lmax: integer the maximum multipole to consider for the spectra computation spec_name_list: list the list of power spectra For example : [split0xsplit0,split0xsplit1,split1xsplit1] note that for computing the error on PS(split0xsplit1) we need PS(split0xsplit0), PS(split0xsplit1), PS(split1xsplit1) ps_dict: dict a dict containing all power spectra binning_file: text file a binning file with three columns bin low, bin high, bin mean note that either binning_file or bin_size should be provided error_method: string the method for the computation of error can be "master" or "knox" for now approx_coupling: dict mbb_inv: 2d array the inverse mode coupling matrix, not in use for 2dflat compute_T_only: boolean True to compute only T spectra """ bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file( binning_file, lmax) n_bins = len(bin_hi) fsky = enmap.area(window.data.shape, window.data.wcs) / 4. / np.pi fsky *= np.mean(window.data) cov_dict = {} if error_method == "Knox": for name in spec_name_list: m1, m2 = name.split("x") cov_dict[name] = {} for spec in spectra: X, Y = spec prefac = 1 / ((2 * bin_c + 1) * fsky * bin_size) cov_dict[name][X + Y] = np.diag( prefac * (ps_dict["%sx%s" % (m1, m1)][X + X] * ps_dict["%sx%s" % (m2, m2)][Y + Y] + ps_dict["%sx%s" % (m1, m2)][X + Y]**2)) elif error_method == "master": print("compute master error") if mbb_inv is None: raise ValueError("Missing 'mbb_inv' argument") if not compute_T_only: mbb_inv = mbb_inv["spin0xspin0"] coupling_dict = so_cov.cov_coupling_spin0(window, lmax, niter=0, l_thres=l_thres, l_toep=l_toep) coupling = so_cov.bin_mat(coupling_dict["TaTcTbTd"], binning_file, lmax) for name in spec_name_list: m1, m2 = name.split("x") cov_dict[name] = {} for spec in spectra: X, Y = spec cov_dict[name][X + Y] = so_cov.symmetrize( ps_dict["%sx%s" % (m1, m1)][X + X]) * so_cov.symmetrize( ps_dict["%sx%s" % (m2, m2)][Y + Y]) cov_dict[name][X + Y] += so_cov.symmetrize( ps_dict["%sx%s" % (m1, m2)][X + Y]**2) cov_dict[name][X + Y] *= coupling cov_dict[name][X + Y] = np.dot( np.dot(mbb_inv, cov_dict[name][X + Y]), mbb_inv.T) else: cov_dict = None return cov_dict
def compute_mode_coupling(window, type, lmax, binning_file, ps_method="master", beam=None, lmax_pad=None, l_thres=None, l_toep=None, compute_T_only=False): """Compute the mode coupling corresponding the the window function Parameters ---------- window: so_map the window function of the patch type: string the type of binning, either bin Cl or bin Dl lmax : integer the maximum multipole to consider for the spectra computation binning_file: text file a binning file with three columns bin low, bin high, bin mean note that either binning_file or bin_size should be provided ps_method: string the method for the computation of the power spectrum can be "master", "pseudo", or "2dflat" for now beam: text file file describing the beam of the map, expect bl to be the second column and start at l=0 (standard is : l,bl, ...) lmax_pad: integer the maximum multipole to consider for the mcm computation (optional) lmax_pad should always be greater than lmax compute_T_only: boolean True to compute only T spectra """ bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file( binning_file, lmax) n_bins = len(bin_hi) fsky = enmap.area(window.data.shape, window.data.wcs) / 4. / np.pi fsky *= np.mean(window.data) if beam is not None: beam_data = np.loadtxt(beam) if compute_T_only: beam = beam_data[:, 1] else: beam = (beam_data[:, 1], beam_data[:, 1]) if compute_T_only: if ps_method == "master": mbb_inv, Bbl = so_mcm.mcm_and_bbl_spin0(window, binning_file, bl1=beam, lmax=lmax, type=type, niter=0, lmax_pad=lmax_pad, l_thres=l_thres, l_toep=l_toep) elif ps_method == "pseudo": mbb_inv = np.identity(n_bins) mbb_inv *= 1 / fsky else: window = (window, window) if ps_method == "master": print("compute master MCM") mbb_inv, Bbl = so_mcm.mcm_and_bbl_spin0and2(window, binning_file, bl1=beam, lmax=lmax, type=type, niter=0, lmax_pad=lmax_pad, l_thres=l_thres, l_toep=l_toep) elif ps_method == "pseudo": mbb_inv = {} spin_list = ["spin0xspin0", "spin0xspin2", "spin2xspin0"] for spin in spin_list: mbb_inv[spin] = np.identity(n_bins) mbb_inv[spin] *= 1 / fsky mbb_inv["spin2xspin2"] = np.identity(4 * n_bins) mbb_inv["spin2xspin2"] *= 1 / fsky if ps_method == "2dflat": mbb_inv = None return mbb_inv
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 = {} test_names = [] for l_exact, l_band, l_toep in zip(l_exact_array, l_band_array, l_toep_array): if (l_exact == None) & (l_toep == None) & (l_band == None): test = "exact" else: test = "%d_%d_%d" % (l_exact, l_band, l_toep) print(test) t = time.time()
def covariance_element(coupling, id_element, ns, ps_all, nl_all, binning_file, mbb_inv_ab, mbb_inv_cd): """ This routine deserves some explanation We want to compute the covariance between two power spectra C1 = Wa * Xb, C2 = Yc * Zd Here W, X, Y, Z can be either T or E and a,b,c,d will be an index corresponding to the survey and array we consider so for example a = s17_pa5_150 or a = dr6_pa4_090 The formula for the analytic covariance of C1, C2 is given by Cov( Wa * Xb, Yc * Zd) = < Wa Yc> <Xb Zd> + < Wa Zd> <Xb Yc> (this is just from the wick theorem) In practice we need to include the effect of the mask (so we have to introduce the coupling dict D) and we need to take into account that we use only the cross power spectra, that is why we use the chi function Cov( Wa * Xb, Yc * Zd) = D(Wa*Yc,Xb Zd) chi(Wa,Yc,Xb Zd) + D(Wa*Zd,Xb*Yc) chi(Wa,Zd,Xb,Yc) Parameters ---------- coupling : dictionnary a dictionnary that countains the coupling terms arising from the window functions id_element : list a list of the form [a,b,c,d] where a = dr6_pa4_090, etc, this identify which pair of power spectrum we want the covariance of ns: dict this dictionnary contains the number of split we consider for each of the survey ps_all: dict this dict contains the theoretical best power spectra, convolve with the beam for example ps["dr6&pa5_150", "dr6&pa4_150", "TT"] = bl_dr6_pa5_150 * bl_dr6_pa4_150 * (Dl^{CMB}_TT + fg_TT) nl_all: dict this dict contains the estimated noise power spectra, note that it correspond to the noise power spectrum per split e.g nl["dr6&pa5_150", "dr6&pa4_150", "TT"] binning_file: a binning file with three columns bin low, bin high, bin mean mbb_inv_ab and mbb_inv_cd: the inverse mode coupling matrices corresponding to the C1 = Wa * Xb and C2 = Yc * Zd power spectra """ na, nb, nc, nd = id_element lmax = coupling["TaTcTbTd"].shape[0] bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file( binning_file, lmax) nbins = len(bin_hi) speclist = ["TT", "TE", "ET", "EE"] nspec = len(speclist) analytic_cov = np.zeros((nspec * nbins, nspec * nbins)) for i, (W, X) in enumerate(speclist): for j, (Y, Z) in enumerate(speclist): id0 = W + "a" + Y + "c" id1 = X + "b" + Z + "d" id2 = W + "a" + Z + "d" id3 = X + "b" + Y + "c" M = coupling[id0.replace("E", "P") + id1.replace("E", "P")] * chi( na, nc, nb, nd, ns, ps_all, nl_all, W + Y + X + Z) M += coupling[id2.replace("E", "P") + id3.replace("E", "P")] * chi( na, nd, nb, nc, ns, ps_all, nl_all, W + Z + X + Y) analytic_cov[i * nbins:(i + 1) * nbins, j * nbins:(j + 1) * nbins] = so_cov.bin_mat( M, binning_file, lmax) mbb_inv_ab = so_cov.extract_TTTEEE_mbb(mbb_inv_ab) mbb_inv_cd = so_cov.extract_TTTEEE_mbb(mbb_inv_cd) analytic_cov = np.dot(np.dot(mbb_inv_ab, analytic_cov), mbb_inv_cd.T) return analytic_cov
def get_covariance( window, lmax, spec_name_list, ps_dict, binning_file, error_method="master", spectra=None, l_exact=None, l_band=None, l_toep=None, mbb_inv=None, compute_T_only=False, transfer_function=None, ): """Compute the covariance matrix of the power spectrum in the patch Parameters ---------- window: so_map the window function of the patch lmax: integer the maximum multipole to consider for the spectra computation spec_name_list: list the list of power spectra For example : [split0xsplit0,split0xsplit1,split1xsplit1] note that for computing the error on PS(split0xsplit1) we need PS(split0xsplit0), PS(split0xsplit1), PS(split1xsplit1) ps_dict: dict a dict containing all power spectra binning_file: text file a binning file with three columns bin low, bin high, bin mean note that either binning_file or bin_size should be provided error_method: string the method for the computation of error can be "master" or "knox" for now approx_coupling: dict mbb_inv: 2d array the inverse mode coupling matrix, not in use for 2dflat compute_T_only: boolean True to compute only T spectra transfer_function: str the path to the transfer function """ timer.start("Compute {} error...".format(error_method)) bin_lo, bin_hi, bin_c, bin_size = pspy_utils.read_binning_file( binning_file, lmax) fsky = enmap.area(window.data.shape, window.data.wcs) / 4.0 / np.pi fsky *= np.mean(window.data) cov_dict = {} if error_method == "knox": for name in spec_name_list: m1, m2 = name.split("x") cov_dict[name] = {} for spec in spectra: X, Y = spec prefac = 1 / ((2 * bin_c + 1) * fsky * bin_size) # fmt: off cov_dict[name][X + Y] = np.diag( prefac * (ps_dict["%sx%s" % (m1, m1)][X + X] * ps_dict["%sx%s" % (m2, m2)][Y + Y] + ps_dict["%sx%s" % (m1, m2)][X + Y]**2)) # fmt: on elif error_method == "master": if not compute_T_only: mbb_inv = mbb_inv["spin0xspin0"] coupling_dict = so_cov.cov_coupling_spin0(window, lmax, niter=0, l_band=l_band, l_toep=l_toep, l_exact=l_exact) coupling = so_cov.bin_mat(coupling_dict["TaTcTbTd"], binning_file, lmax) for name in spec_name_list: m1, m2 = name.split("x") cov_dict[name] = {} for spec in spectra: X, Y = spec cov_dict[name][X + Y] = so_cov.symmetrize( ps_dict["%sx%s" % (m1, m1)][X + X]) * so_cov.symmetrize( ps_dict["%sx%s" % (m2, m2)][Y + Y]) cov_dict[name][X + Y] += so_cov.symmetrize( ps_dict["%sx%s" % (m1, m2)][X + Y]**2) cov_dict[name][X + Y] *= coupling cov_dict[name][X + Y] = np.dot( np.dot(mbb_inv, cov_dict[name][X + Y]), mbb_inv.T) if transfer_function is not None: _, _, tf, _ = np.loadtxt(transfer_function, unpack=True) tf = tf[:len(bin_c)] cov_dict[name][X + Y] /= np.outer(np.sqrt(tf), np.sqrt(tf)) else: cov_dict = None timer.stop() return cov_dict