def main(mask_path: Path, cosmo_path: Path, log_level: int): logging.basicConfig( stream=sys.stdout, level=log_level, datefmt='%Y-%m-%d %H:%M', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') nside = 128 nmc = 30 mask = make_binary_mask(nside) masking = lynx.Masking(mask_path) masking.save_fitting_mask('one', mask) masking.calculate_apodizations(mask) masking.calculate_mode_coupling() cl_theory = read_cl(cosmo_path) ells = np.arange(0, len(cl_theory[0])) for mask_name, wsp, mask, binning, beam in masking.get_powerspectrum_tools( ): print(r""" Mask name: {:s} Fsky: {:.03f} """.format(mask_name, np.mean(mask))) ee_bpw_window = wsp.get_bandpower_windows()[0, :, 0, :] bb_bpw_window = wsp.get_bandpower_windows()[3, :, 3, :] cl_mc = np.zeros((nmc, 4, binning.get_n_bands())) for i in range(nmc): cmb = get_cmb_realization(nside, cosmo_path, np.pi / 180.) cl_mc[i] = compute_nmt_spectra(cmb[1:], cmb[1:], mask, wsp) cl_mean = np.mean(cl_mc, axis=0) cl_covar_ee = (cl_mc[:, 0] - cl_mean[0])[..., None, :] * ( cl_mc[:, 0] - cl_mean[0])[..., None] cl_covar_ee = np.sum(cl_covar_ee, axis=0) / float(nmc - 1) cl_covar_bb = (cl_mc[:, 3] - cl_mean[3])[..., None, :] * ( cl_mc[:, 3] - cl_mean[3])[..., None] cl_covar_bb = np.sum(cl_covar_bb, axis=0) / float(nmc - 1) fig, ax = plt.subplots(1, 1) ax.errorbar(binning.get_effective_ells(), cl_mean[0], yerr=np.sqrt(np.diag(cl_covar_ee))) #ax.plot(binning.get_effective_ells(), cl_mean[0], 'C0-') ax.plot(binning.get_effective_ells(), np.dot(ee_bpw_window, cl_theory[1][:ee_bpw_window.shape[-1]]), 'C0--') #ax.plot(binning.get_effective_ells(), cl_mean[3], 'C1-') ax.plot(binning.get_effective_ells(), np.dot(bb_bpw_window, cl_theory[2][:bb_bpw_window.shape[-1]]), 'C1--') ax.errorbar(binning.get_effective_ells(), cl_mean[3], yerr=np.sqrt(np.diag(cl_covar_bb))) ax.set_xlim(0, 3 * nside) ax.set_yscale('log') plt.show()
def main(data_path: Path, model_path: Path, mask_path: Path, log_level: int): logging.basicConfig( stream=sys.stdout, level=log_level, datefmt='%Y-%m-%d %H:%M', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') with open(data_path) as f: data_cfg = yaml.load(f, Loader=yaml.FullLoader) nside = data_cfg['nside'] npix = hp.nside2npix(nside) nmc = data_cfg['monte_carlo'] amplitude_output_shape = (nmc, 2, npix) parameter_output_shape = (nmc, npix) frequencies = np.array(data_cfg['frequencies']) with h5py.File(data_cfg['hdf5_path'], 'r') as f: data = f['maps/monte_carlo/data'][...] cov = f['maps/monte_carlo/cov'][...] masking = lynx.Masking(mask_path) fitting_masks = list(masking.get_fitting_indices()) tasks = get_tasks(data, cov, nmc, frequencies, fitting_masks, model_path) with MultiPool() as pool: results = pool.map(do_fitting, tasks) with h5py.File(data_cfg['hdf5_path'], 'a') as f: for result in results: save_data(f, amplitude_output_shape, parameter_output_shape, result)
def main(data_path: Path, mask_path: Path, model_path: Path, log_level: int): logging.basicConfig( stream=sys.stdout, level=log_level, datefmt='%Y-%m-%d %H:%M', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') masking = lynx.Masking(mask_path) fitting_masks = list(masking.get_fitting_indices()) model_identifier, lnP = hoover.LogProb.load_model_from_yaml(model_path) with h5py.File(data_path, 'r') as f: sky_config = yaml.load(f.attrs['config'], Loader=yaml.FullLoader) nmc = sky_config['monte_carlo'] frequencies = np.array(sky_config['frequencies']) nside = sky_config['nside'] amplitude_output_shape = (2, hp.nside2npix(nside)) parameter_output_shape = (hp.nside2npix(nside), ) for fitting_name, fitting_parameters in fitting_masks: T_bar = { comp: np.zeros(amplitude_output_shape) for comp in lnP._components } par = { par: np.zeros(parameter_output_shape) for par in lnP.free_parameters } for imc in range(nmc): logging.info(r""" Working on Monte Carlo realization: {:d} """.format(imc)) hdf5_record = str( Path(model_identifier) / fitting_name / 'mc{:04d}'.format(imc)) logging.info(r""" Working on fitting scheme: {:s} """.format(fitting_name)) with h5py.File(data_path, 'a') as f: # Create a group which contains results for this sky # patch, model, and MC realization. opt = f[hdf5_record] # Create a dataset for the whole sky, and log the # results for this patch in the corresponding indices. # Do the same for the spectral parameters. for component in lnP._components: T_bar[component] += opt[component][...] for parameter in lnP.free_parameters: par[parameter] += opt[parameter][...] T_bar = {key: value / float(nmc) for key, value in T_bar.items()} par = {key: value / float(nmc) for key, value in par.items()} hp.mollview(T_bar['cmb'][0]) hp.mollview(par['beta_d']) plt.show()
def main(data_path: Path, model_path: Path, mask_path: Path, estimate_noise: bool, log_level: int): logging.basicConfig( stream=sys.stdout, level=log_level, datefmt='%Y-%m-%d %H:%M', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') with open(data_path) as f: data_cfg = yaml.load(f, Loader=yaml.FullLoader) data_id = data_cfg['identifier'] nmc = data_cfg['monte_carlo'] hdf5_path = data_cfg['hdf5_path'] logging.info(f"Working on data: {data_id}") masking = lynx.Masking(mask_path) fitting_masks = list(masking.get_fitting_indices()) model_identifier, lnP = hoover.LogProb.load_model_from_yaml(model_path) for mask_name, wsp, mask, binning, beam in masking.get_powerspectrum_tools( ): # get the bandpower window function, which will be saved with the # computed spectra for comparison with theory later. bpw_window_function = wsp.get_bandpower_windows() logging.info(f"Working on power spectra for mask: {mask_name}") for fitting_name, _ in fitting_masks: logging.info(f"Working on fitting scheme: {fitting_name}") hdf5_record_amp = Path(model_identifier) / fitting_name hdf5_record_spec = hdf5_record_amp / 'spectra' / mask_name with h5py.File(hdf5_path, 'a') as f: # Create a group which contains results for this sky # patch, model, and MC realization. spec = f.require_group(f"{hdf5_record_spec}") spec.attrs.update({'config': yaml.dump(masking.cfg)}) # save bandpower window function dset = spec.require_dataset('bpw_window_function', shape=bpw_window_function.shape, dtype=bpw_window_function.dtype) dset[...] = bpw_window_function dset = spec.require_dataset('beam', shape=beam.shape, dtype=beam.dtype) dset[...] = beam # Create a dataset for the whole sky, and log the # results for this patch in the corresponding indices. # Do the same for the spectral parameters. for component in lnP._components: logging.info(f"Working on component: {component}") cl_mc = np.zeros((int(nmc / 2), 4, binning.get_n_bands())) for ispec, imc in enumerate(np.arange(nmc)[::2]): jmc = imc + 1 logging.info( f"Working on Monte Carlo realizations: {imc:d}, {jmc:d}" ) T_bar_1 = f[f"{hdf5_record_amp / component}_T_bar"][ imc, ...] T_bar_2 = f[f"{hdf5_record_amp / component}_T_bar"][ jmc, ...] cl_mc[ispec] = compute_nmt_spectra( T_bar_1, T_bar_2, mask, wsp) if component == 'cmb': N_T_1 = f[f"{hdf5_record_amp}"]['cmb_N_T'][...] N_T_2 = f[f"{hdf5_record_amp}"]['cmb_N_T'][...] noise_mc = 30 cl_n = np.zeros((noise_mc, binning.get_n_bands())) logging.info(f"Saving in {spec.name}/{component}") cl_dset = spec.require_dataset(component, dtype=cl_mc.dtype, shape=cl_mc.shape) cl_dset[...] = cl_mc if estimate_noise: for k in range(noise_mc): n1 = get_realization(N_T_1) n2 = get_realization(N_T_2) cl_n[k] = compute_nmt_spectra(n1, n2, mask, wsp)[3] cl_n_mean, cl_n_cov = compute_mean_cov(cl_n) cl_n_dset = spec.require_dataset(f"{component}_cln_mean", dtype=cl_n_mean.dtype, shape=cl_n_mean.shape) cl_n_dset[...] = cl_n_mean cl_n_dset = spec.require_dataset(f"{component}_cln_cov", dtype=cl_n_cov.dtype, shape=cl_n_cov.shape) cl_n_dset[...] = cl_n_cov
def main(data_path: Path, mask_path: Path, model_path: Path, lkl_path: Path, log_level: int): logging.basicConfig( stream=sys.stdout, level=log_level, datefmt='%Y-%m-%d %H:%M', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') with open(data_path) as f: data_cfg = yaml.load(f, Loader=yaml.FullLoader) hdf5_path = data_cfg['hdf5_path'] with open(lkl_path) as f: lkl_cfg = yaml.load(f, Loader=yaml.FullLoader) masking = lynx.Masking(mask_path) fitting_masks = list(masking.get_fitting_indices()) model_identifier, lnP = hoover.LogProb.load_model_from_yaml(model_path) for mask_name, wsp, _, binning, _ in masking.get_powerspectrum_tools(): for fitting_identifier, _ in fitting_masks: results_dir = Path("data/results") / data_cfg[ 'identifier'] / mask_name / fitting_identifier / model_identifier / lkl_cfg[ 'identifier'] results_dir.mkdir(exist_ok=True, parents=True) hdf5_record = Path( model_identifier) / fitting_identifier / 'spectra' / mask_name with h5py.File(hdf5_path, 'r') as f: ee_mean, ee_cov = compute_mean_cov(f[f"{hdf5_record}/cmb"][:, 0]) bb_mean, bb_cov = compute_mean_cov(f[f"{hdf5_record}/cmb"][:, 3]) bb_mean_dust, bb_cov_dust = compute_mean_cov( f[f"{hdf5_record}/dustmbb"][:, 3]) ee_mean_dust, ee_cov_dust = compute_mean_cov( f[f"{hdf5_record}/dustmbb"][:, 0]) bpw_windows = wsp.get_bandpower_windows() ee_bpw_windows = bpw_windows[0, :, 0, :] bb_bpw_windows = bpw_windows[3, :, 3, :] bpws = binning.get_effective_ells() with h5py.File("data/planck_2018_acc.h5", 'r') as f: ee = f['lensed_scalar'][:ee_bpw_windows.shape[-1], 1] bb = f['lensed_scalar'][:bb_bpw_windows.shape[-1], 2] fig, ax = plt.subplots(1, 1) ax.set_title("BB bandpower covariance matrix") ax.imshow(bb_cov, origin='lower', extent=[bpws[0], bpws[-1], bpws[0], bpws[-1]]) ax.set_xlabel(r"$\ell_b$") ax.set_ylabel(r"$\ell_b$") fig.savefig(results_dir / "bb_cov.pdf", bbox_inches='tight') fig, ax = plt.subplots(1, 1) ax.plot(bpws, np.dot(ee_bpw_windows, ee), 'k-', label='Binned theory input') ax.errorbar(bpws, ee_mean, np.sqrt(np.diag(ee_cov)), color='k', fmt='o', label='Cleaned estimate') ax.set_yscale('log') ax.set_xlabel(r"$\ell_b$") ax.set_ylabel(r"$C_{\ell_b}^{\rm EE}~[{\rm \mu K}^2]$") ax.legend() fig.savefig(results_dir / "ee_recovered.pdf", bbox_inches='tight') lnP = lynx.BBLogLike(data=(bb_mean, bb_cov), bpw_window_function=bb_bpw_windows, model_config_path=lkl_path) res = minimize(lnP, lnP.theta_0(), args=(True), method='Nelder-Mead') fig, ax = plt.subplots(1, 1) samples = np.random.multivariate_normal(res.x, lnP.covariance(res.x), 100) samples = np.array([lnP.model(sample) for sample in samples]) for s in samples: ax.plot(bpws, s, 'C1', alpha=0.1) ax.errorbar(bpws, bb_mean_dust, np.sqrt(np.diag(bb_cov_dust)), color='C1', fmt='o', label="Dust at 353 GHz") ax.plot(bpws, np.dot(bb_bpw_windows, bb), 'k-', label='Binned theory input') #ax.plot(bpws, np.sqrt(np.diag(cln_bb_cov)), 'g-', label=r'$\sigma(C_\ell^{\rm BB})$') ax.errorbar(bpws, bb_mean, np.sqrt(np.diag(bb_cov)), color='k', fmt='o', label='Cleaned estimate') ax.set_yscale('log') ax.set_ylim(1e-7, 4e-3) ax.set_xlabel(r"$\ell_b$") ax.set_ylabel(r"$C_{\ell_b}^{\rm BB}~[{\rm \mu K}^2]$") ax.legend() fig.savefig(results_dir / "bb_recovered.pdf", bbox_inches='tight') plot_fisher(res.x, lnP.covariance(res.x), truth=[1., 0.], fpath=results_dir / "ellipses.pdf", xlabel=r"$A_L$", ylabel=r"$r$") print(res.x) print(np.sqrt(np.diag(lnP.covariance(res.x)))) print('Reduced chi2: ', lnP.chi2(res.x)) np.save(results_dir / "parameter_ML.npy", res.x) np.save(results_dir / "parameter_covariance.npy", lnP.covariance(res.x)) results = pd.DataFrame({ 'mean': pd.Series(res.x, index=lnP.free_parameters), '1-sigma': pd.Series(np.sqrt(np.diag(lnP.covariance(res.x))), index=lnP.free_parameters) }) print(results) results.to_csv(results_dir / "results.csv")