def test_oas_cov(self): # mock observable ensemble with identical realizations arr = np.random.rand(1, 32) comm.Bcast(arr, root=0) null_cov = np.zeros((32, 32)) # ensemble with identical realisations local_cov = oas_cov(arr) full_cov = np.vstack(comm.allgather(local_cov)) for i in range(full_cov.shape[0]): for j in range(full_cov.shape[1]): self.assertAlmostEqual(null_cov[i][j], full_cov[i][j])
def testfield(): if mpisize > 1: raise RuntimeError('MPI unsupported in Dynesty') """ :return: log.basicConfig(filename='imagine.log', level=log.INFO) """ """ # step 0, set 'a' and 'b', 'mea_std' TestField in LiSimulator is modeled as field = gaussian_random(mean=a,std=b)_x * cos(x) where x in (0,2pi) for generating mock data we need true values of a and b: true_a, true_b, mea_seed measurement uncertainty: mea_std measurement points, positioned in (0,2pi) evenly, due to TestField modelling """ true_a = 3. true_b = 6. mea_std = 0.1 # std of gaussian measurement error mea_seed = 233 mea_points = 10 # data points in measurements truths = [true_a, true_b] # will be used in visualizing posterior """ # step 1, prepare mock data """ """ # 1.1, generate measurements mea_field = signal_field + noise_field """ x = np.linspace(0, 2. * np.pi, mea_points) np.random.seed(mea_seed) # seed for signal field signal_field = np.multiply( np.cos(x), np.random.normal(loc=true_a, scale=true_b, size=mea_points)) mea_field = np.vstack([ signal_field + np.random.normal(loc=0., scale=mea_std, size=mea_points) ]) """ # 1.2, generate covariances what's the difference between pre-define dan re-estimated? """ # re-estimate according to measurement error repeat = 100 # times of repeated measurements mea_repeat = np.zeros((repeat, mea_points)) for i in range(repeat): mea_repeat[i, :] = signal_field + np.random.normal( loc=0., scale=mea_std, size=mea_points) mea_cov = oas_cov(mea_repeat) print('re-estimated: \n', mea_cov) # pre-defined according to measurement error mea_cov = (mea_std**2) * np.eye(mea_points) print('pre-defined: \n', mea_cov) """ # 1.3 assemble in imagine convention """ mock_data = Measurements() # create empty Measrurements object mock_cov = Covariances() # create empty Covariance object # pick up a measurement mock_data.append(('test', 'nan', str(mea_points), 'nan'), mea_field, True) mock_cov.append(('test', 'nan', str(mea_points), 'nan'), mea_cov, True) """ # 1.4, visualize mock data """ matplotlib.pyplot.plot( x, mock_data[('test', 'nan', str(mea_points), 'nan')].to_global_data()[0]) matplotlib.pyplot.savefig('testfield_mock.pdf') """ # step 2, prepare pipeline and execute analysis """ """ # 2.1, ensemble likelihood """ likelihood = EnsembleLikelihood( mock_data, mock_cov) # initialize likelihood with measured info #likelihood = SimpleLikelihood(mock_data, mock_cov) #likelihood.active_parameters = () """ # 2.2, field factory list """ factory = TestFieldFactory( active_parameters=('a', 'b')) # factory with single active parameter factory.parameter_ranges = { 'a': (0, 10), 'b': (0, 10) } # adjust parameter range for Bayesian analysis factory_list = [factory] # likelihood requires a list/tuple of factories """ # 2.3, flat prior """ prior = FlatPrior() """ # 2.4, simulator """ simer = LiSimulator(mock_data) """ # 2.5, pipeline """ ensemble_size = 10 pipe = DynestyPipeline(simer, factory_list, likelihood, prior, ensemble_size) pipe.random_type = 'controllable' # 'fixed' wont work for Dynesty pipe.seed_tracer = int(23) pipe.sampling_controllers = {'nlive': 400} results = pipe() # run with pymultinest """ # step 3, visualize (with corner package) """ samples = results['samples'] for i in range(len( pipe.active_parameters)): # convert variables into parameters low, high = pipe.active_ranges[pipe.active_parameters[i]] for j in range(samples.shape[0]): samples[j, i] = unity_mapper(samples[j, i], low, high) # corner plot corner.corner(samples[:, :len(pipe.active_parameters)], range=[0.99] * len(pipe.active_parameters), quantiles=[0.02, 0.5, 0.98], labels=pipe.active_parameters, show_titles=True, title_kwargs={"fontsize": 15}, color='steelblue', truths=truths, truth_color='firebrick', plot_contours=True, hist_kwargs={'linewidth': 2}, label_kwargs={'fontsize': 20}) matplotlib.pyplot.savefig('testfield_posterior.pdf')
def mock_errprop(_nside, _freq): """ return masked mock synchrotron Q, U error propagated from theoretical uncertainties """ # hammurabi parameter base file xmlpath = './params.xml' # active parameters true_b0 = 3.0 true_psi0 = 27.0 true_psi1 = 0.9 true_chi0 = 25. true_alpha = 3.0 true_r0 = 5.0 true_z0 = 1.0 true_rms = 6.0 true_rho = 0.8 true_a0 = 1.7 # _npix = 12*_nside**2 # x = np.zeros((1, _npix)) # only for triggering simulator trigger = Measurements() trigger.append(('sync', str(_freq), str(_nside), 'Q'), x) # Q map trigger.append(('sync', str(_freq), str(_nside), 'U'), x) # U map # initialize simulator mocksize = 20 # ensemble of mock data error = 0.1 # theoretical raltive uncertainty for each (active) parameter mocker = Hammurabi(measurements=trigger, xml_path=xmlpath) # prepare theoretical uncertainty b0_var = np.random.normal(true_b0, error*true_b0, mocksize) psi0_var = np.random.normal(true_psi0, error*true_psi0, mocksize) psi1_var = np.random.normal(true_psi1, error*true_psi1, mocksize) chi0_var = np.random.normal(true_chi0, error*true_chi0, mocksize) alpha_var = np.random.normal(true_alpha, error*true_alpha, mocksize) r0_var = np.random.normal(true_r0, error*true_r0, mocksize) z0_var = np.random.normal(true_z0, error*true_z0, mocksize) rms_var = np.random.normal(true_rms, error*true_rms, mocksize) rho_var = np.random.normal(true_rho, error*true_rho, mocksize) a0_var = np.random.normal(true_a0, error*true_a0, mocksize) mock_raw_q = np.zeros((mocksize, _npix)) mock_raw_u = np.zeros((mocksize, _npix)) # start simulation for i in range(mocksize): # get one realization each time # BregLSA field paramlist = {'b0': b0_var[i], 'psi0': psi0_var[i], 'psi1': psi1_var[i], 'chi0': chi0_var[i]} breg_lsa = BregLSA(paramlist, 1) # CREAna field paramlist = {'alpha': alpha_var[i], 'beta': 0.0, 'theta': 0.0, 'r0': r0_var[i], 'z0': z0_var[i], 'E0': 20.6, 'j0': 0.0217} cre_ana = CREAna(paramlist, 1) # TEregYMW16 field paramlist = dict() fereg_ymw16 = TEregYMW16(paramlist, 1) # BrndES field paramlist = {'rms': rms_var[i], 'k0': 10.0, 'k1': 0.1, 'a1': 0.0, 'a0': a0_var[i], 'rho': rho_var[i], 'r0': 8.0, 'z0': 1.0} brnd_es = BrndES(paramlist, 1) # collect mock data and covariance outputs = mocker([breg_lsa, cre_ana, fereg_ymw16, brnd_es]) mock_raw_q[i, :] = outputs[('sync', str(_freq), str(_nside), 'Q')].data mock_raw_u[i, :] = outputs[('sync', str(_freq), str(_nside), 'U')].data # collect mean and cov from simulated results sim_data = Simulations() mock_data = Measurements() mock_cov = Covariances() mock_mask = Masks() sim_data.append(('sync', str(_freq), str(_nside), 'Q'), mock_raw_q) sim_data.append(('sync', str(_freq), str(_nside), 'U'), mock_raw_u) mask_map = mask_map_prod(_nside, 0, 90, 50) # not parameterizing this mock_mask.append(('sync', str(_freq), str(_nside), 'Q'), np.vstack([mask_map])) mock_mask.append(('sync', str(_freq), str(_nside), 'U'), np.vstack([mask_map])) sim_data.apply_mask(mock_mask) for key in sim_data.keys(): global_mock = np.vstack([(sim_data[key].data)[0]]) comm.Bcast(global_mock, root=0) mock_data.append(key, global_mock, True) mock_cov.append(key, oas_cov(sim_data[key].data), True) return mock_data, mock_cov
def mock_errprop(_nside, _freq): """ return masked mock synchrotron Q, U error propagated from theoretical uncertainties """ # hammurabi parameter base file xmlpath = './params_masked_regular.xml' # active parameters true_b0 = 6.0 true_psi0 = 27.0 true_psi1 = 0.9 true_chi0 = 25. true_alpha = 3.0 true_r0 = 5.0 true_z0 = 1.0 # _npix = 12 * _nside**2 # x = np.zeros((1, _npix)) # only for triggering simulator trigger = Measurements() trigger.append(('sync', str(_freq), str(_nside), 'Q'), x) # Q map trigger.append(('sync', str(_freq), str(_nside), 'U'), x) # U map # initialize simulator mocksize = 20 # ensemble of mock data (per node) error = 0.1 # theoretical raltive uncertainty for each (active) parameter mocker = Hammurabi(measurements=trigger, xml_path=xmlpath) # prepare theoretical uncertainty b0_var = np.random.normal(true_b0, error * true_b0, mocksize) psi0_var = np.random.normal(true_psi0, error * true_psi0, mocksize) psi1_var = np.random.normal(true_psi1, error * true_psi1, mocksize) chi0_var = np.random.normal(true_chi0, error * true_chi0, mocksize) alpha_var = np.random.normal(true_alpha, error * true_alpha, mocksize) r0_var = np.random.normal(true_r0, error * true_r0, mocksize) z0_var = np.random.normal(true_z0, error * true_z0, mocksize) mock_raw_q = np.zeros((mocksize, _npix)) mock_raw_u = np.zeros((mocksize, _npix)) # start simulation np.random.seed(mpirank * 10) for i in range(mocksize): # get one realization each time # BregWMAP field paramlist = { 'b0': b0_var[i], 'psi0': psi0_var[i], 'psi1': psi1_var[i], 'chi0': chi0_var[i] } breg_wmap = BregWMAP(paramlist, 1) # CREAna field paramlist = { 'alpha': alpha_var[i], 'beta': 0.0, 'theta': 0.0, 'r0': r0_var[i], 'z0': z0_var[i], 'E0': 20.6, 'j0': 0.0217 } cre_ana = CREAna(paramlist, 1) # FEregYMW16 field paramlist = dict() fereg_ymw16 = FEregYMW16(paramlist, 1) # collect mock data and covariance outputs = mocker([breg_wmap, cre_ana, fereg_ymw16]) mock_raw_q[i, :] = outputs[('sync', str(_freq), str(_nside), 'Q')].local_data mock_raw_u[i, :] = outputs[('sync', str(_freq), str(_nside), 'U')].local_data # collect mean and cov from simulated results sim_data = Simulations() mock_data = Measurements() mock_cov = Covariances() sim_data.append(('sync', str(_freq), str(_nside), 'Q'), mock_raw_q) sim_data.append(('sync', str(_freq), str(_nside), 'U'), mock_raw_u) mock_mask = mask_map(_nside, _freq) sim_data.apply_mask(mock_mask) for key in sim_data.keys(): mock_data.append( key, np.vstack([(sim_data[key].to_global_data())[np.random.randint( 0, mocksize)]]), True) mock_cov.append(key, oas_cov(sim_data[key].to_global_data()), True) return mock_data, mock_cov