Example #1
0
 def test_multithread(self):
     obs = ("DeltaGamma_s", "m_W")
     flavio.citations.reset()
     flavio.sm_covariance(obs, threads=1)
     cites_singlethread = flavio.citations.set
     flavio.citations.reset()
     flavio.sm_covariance(obs, threads=4)
     cites_multithread = flavio.citations.set
     self.assertSetEqual(cites_singlethread, cites_multithread)
    def test_sm_covariance(self):
        o1 = Observable('test_obs 1')
        o2 = Observable('test_obs 2')

        def f1(wc_obj, par_dict):
            return par_dict['m_b']

        def f2(wc_obj, par_dict):
            return par_dict['m_c']

        Prediction('test_obs 1', f1)
        Prediction('test_obs 2', f2)
        cov_par = np.array([[0.1**2, 0.1 * 0.2 * 0.3],
                            [0.1 * 0.2 * 0.3, 0.2**2]])
        d = flavio.statistics.probability.MultivariateNormalDistribution(
            [4.2, 1.2], covariance=cov_par)
        par = copy.deepcopy(flavio.parameters.default_parameters)
        par.add_constraint(['m_b', 'm_c'], d)
        # test serial
        np.random.seed(135)
        cov = flavio.sm_covariance(['test_obs 1', 'test_obs 2'],
                                   N=1000,
                                   par_vary='all',
                                   par_obj=par)
        npt.assert_array_almost_equal(cov, cov_par, decimal=2)
        # test parallel
        np.random.seed(135)
        cov_parallel = flavio.sm_covariance(['test_obs 1', 'test_obs 2'],
                                            N=1000,
                                            par_vary='all',
                                            par_obj=par,
                                            threads=4)
        npt.assert_array_almost_equal(cov, cov_parallel, decimal=6)
        np.random.seed(135)
        cov_1 = flavio.sm_covariance(['test_obs 1'],
                                     N=1000,
                                     par_vary='all',
                                     par_obj=par)
        # test with single observable
        npt.assert_array_almost_equal(cov_1, cov[0, 0])
        # test with fixed parameter
        cov_f = flavio.sm_covariance(['test_obs 1', 'test_obs 2'],
                                     N=1000,
                                     par_vary=['m_b'],
                                     par_obj=par)
        npt.assert_array_almost_equal(cov_f, [[cov_par[0, 0], 0], [0, 0]],
                                      decimal=3)
        # delete dummy instances
        Observable.del_instance('test_obs 1')
        Observable.del_instance('test_obs 2')
Example #3
0
 def compute(self, N, threads):
     """Compute the covariance for `N` random values, using `threads`
     CPU threads."""
     return flavio.sm_covariance(obs_list=self.observables,
                                 N=N,
                                 par_vary=self.vary_parameters,
                                 par_obj=self.par_obj,
                                 threads=threads)
Example #4
0
 def compute(self, N, threads):
     """Compute the covariance for `N` random values, using `threads`
     CPU threads."""
     return flavio.sm_covariance(obs_list=self.observables,
                                 N=N,
                                 par_vary=self.vary_parameters,
                                 par_obj=self.par_obj,
                                 threads=threads)
Example #5
0
 def sm_covariance(self, N=1000):
     """Compute the covariance of theory predictions for the four input
     observables in the SM, fixing the CKM elements."""
     par_vary = [
         p for p in self.par_obj.all_parameters if p not in self.ckm_par
     ]
     return flavio.sm_covariance(self.observables,
                                 N=N,
                                 par_obj=self.par_obj,
                                 par_vary=par_vary)
Example #6
0
 def test_sm_covariance(self):
     o1 = Observable( 'test_obs 1' )
     o2 = Observable( 'test_obs 2' )
     def f1(wc_obj, par_dict):
         return par_dict['m_b']
     def f2(wc_obj, par_dict):
         return par_dict['m_c']
     Prediction('test_obs 1', f1)
     Prediction('test_obs 2', f2)
     cov_par = np.array([[0.1**2, 0.1*0.2*0.3], [0.1*0.2*0.3, 0.2**2]])
     d = flavio.statistics.probability.MultivariateNormalDistribution([4.2, 1.2], covariance=cov_par)
     par = copy.deepcopy(flavio.parameters.default_parameters)
     par.add_constraint(['m_b', 'm_c'], d)
     # test serial
     np.random.seed(135)
     cov = flavio.sm_covariance(['test_obs 1', 'test_obs 2'],
                                N=1000, par_vary='all', par_obj=par)
     npt.assert_array_almost_equal(cov, cov_par, decimal=2)
     # test parallel
     np.random.seed(135)
     cov_parallel = flavio.sm_covariance(['test_obs 1', 'test_obs 2'],
                                N=1000, par_vary='all', par_obj=par,
                                threads=4)
     npt.assert_array_almost_equal(cov, cov_parallel, decimal=6)
     np.random.seed(135)
     cov_1 = flavio.sm_covariance(['test_obs 1'],
                                N=1000, par_vary='all', par_obj=par)
     # test with single observable
     npt.assert_array_almost_equal(cov_1, cov[0, 0])
     # test with fixed parameter
     cov_f = flavio.sm_covariance(['test_obs 1', 'test_obs 2'],
                                N=1000, par_vary=['m_b'], par_obj=par)
     npt.assert_array_almost_equal(cov_f, [[cov_par[0, 0], 0], [0, 0]], decimal=3)
     # delete dummy instances
     Observable.del_instance('test_obs 1')
     Observable.del_instance('test_obs 2')
Example #7
0
def compute_sm_covariance(N=100, threads=4):
    """Compute the SM covariance for all observables."""
    # all observables from all experiments at all phases
    return flavio.sm_covariance(allobs, N=N, threads=threads)