def test_add_different_fiducial(self):
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(3) ] 
     fiducial_1 = [ float(i) for i in xrange(3) ]
     fiducial_2 = [ float(i+1) for i in xrange(3) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial_1 )
     fisher_2 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial_2 )
     
     assert_raises( ValueError, lambda: fisher_1+fisher_2 )
 def setup(self):
     # generate the Fisher matrix. In this case a simple diagonal matrix.
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(3) ] 
     fiducial = [ float(i) for i in xrange(3) ]
     # initialize the Fisher type:
     self.fisher_1 = fm.fisher_matrix( fisher_matrix=1.0*matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     self.fisher_2 = fm.fisher_matrix( fisher_matrix=10.0*matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     self.fisher_3 = fm.fisher_matrix( fisher_matrix=0.0*matrix, param_names_latex=param_names_latex, fiducial=fiducial )
 def test_save_to_file_1(self):
     # load the fisher matrix:
     fisher_1 = fm.fisher_matrix( file_name=test_input+'/dummy_fisher_matrix_2.dat' )
     # save the fisher matrix back to file:
     fisher_1.save_to_file( file_name=test_output+'/dummy_fisher_matrix_out' )        
     # import it as a second fisher:
     fisher_2 = fm.fisher_matrix( file_name=test_output+'/dummy_fisher_matrix_out.dat' )
     # test equality, to do so we have to set a couple of things to be the same...
     fisher_1.path  = fisher_2.path
     fisher_1.name  = fisher_2.name
     fisher_1.indir = fisher_2.indir
     fisher_1.protect_degenerate( cache=False ) # we have to do it twice otherwise eigenvalues are slightly different
     assert fisher_1==fisher_2
Example #4
0
    def test_add_different_fiducial(self):
        matrix = np.identity(3)
        for i in xrange(3):
            matrix[i, i] = i + 1
        param_names_latex = ['m' + str(i) for i in xrange(3)]
        fiducial_1 = [float(i) for i in xrange(3)]
        fiducial_2 = [float(i + 1) for i in xrange(3)]
        fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                    param_names_latex=param_names_latex,
                                    fiducial=fiducial_1)
        fisher_2 = fm.fisher_matrix(fisher_matrix=matrix,
                                    param_names_latex=param_names_latex,
                                    fiducial=fiducial_2)

        assert_raises(ValueError, lambda: fisher_1 + fisher_2)
 def test_init_from_python_with_add(self):
     # create the list of Fisher matrices:
     fisher_list = []
     matrix = np.identity(3)
     for j in range(3):
         for i in range(3):
             matrix[i, i] = i + j + 1
         param_names = ['pa' + str(i + j) for i in range(3)]
         param_names_latex = ['m' + str(i) for i in range(3)]
         fiducial = [float(i) for i in range(3)]
         fisher = fm.fisher_matrix(fisher_matrix=matrix,
                                   param_names=param_names,
                                   param_names_latex=param_names_latex,
                                   fiducial=fiducial)
         fisher.name = 'fisher' + str(j + 1)
         fisher_list.append(fisher)
     fisher_list_test = fpa.CosmicFish_FisherAnalysis()
     fisher_list_test.add_fisher_matrix(fisher_list)
     # quality check:
     assert fisher_list_test.fisher_name_list == [
         fish.name for fish in fisher_list_test.fisher_list
     ]
     assert fisher_list_test.fisher_name_list == [
         fish.name for fish in fisher_list
     ]
Example #6
0
 def setup(self):
     # create a list of fisher matrices:
     fisher_1 = fm.fisher_matrix(file_name=test_input +
                                 '/dummy_fisher_matrix.dat')
     fisher_1.name = 'realistic fisher'
     self.fisher_list_test = fpa.CosmicFish_FisherAnalysis(
         fisher_list=fisher_1)
 def test_add_different_params(self):
     matrix = np.identity(2)
     for i in xrange(2):
         matrix[i,i] = i+1
     param_names_1 = [ 'm'+str(i) for i in xrange(2) ] 
     param_names_2 = [ 'b'+str(i) for i in xrange(2) ] 
     fiducial = [ float(i) for i in xrange(2) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names = param_names_1, fiducial=fiducial )
     fisher_2 = fm.fisher_matrix( fisher_matrix=matrix, param_names = param_names_2, fiducial=fiducial )
     fisher_3 = fisher_1+fisher_2
     
     assert np.allclose( fisher_3.fisher_matrix, [[1.0,0.0,0.0,0.0],[0.0,2.0,0.0,0.0],[0.0,0.0,1.0,0.0],[0.0,0.0,0.0,2.0]] )
     assert fisher_3.num_params == 4
     assert np.allclose( fisher_3.fisher_eigenvalues, [ 1.0,1.0,2.0,2.0] )
     assert fisher_3.param_names == ['m0', 'm1', 'b0', 'b1']
     assert np.allclose( fisher_3.param_fiducial, [ 0., 1., 0., 1.] ) 
 def test_equality_except(self):
     matrix = np.identity(2)
     for i in xrange(2):
         matrix[i,i] = i+1
     param_names = [ 'm'+str(i) for i in xrange(2) ] 
     fiducial = [ float(i) for i in xrange(2) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names = param_names, fiducial=fiducial )
     
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i,i] = i+1
     param_names = [ 'm'+str(i) for i in xrange(3) ] 
     fiducial = [ float(i) for i in xrange(3) ]
     fisher_2 = fm.fisher_matrix( fisher_matrix=matrix, param_names = param_names, fiducial=fiducial )
     
     assert fisher_1 != fisher_2
 def setup(self):
     # generate the Fisher matrix. In this case a simple diagonal matrix.
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i, i] = i + 1
     # Jacobian matrix:
     matrix_derived = np.zeros((3, 2))
     matrix_derived[0, 0] = 1.0
     matrix_derived[1, 1] = 1.0
     matrix_derived[2, 0] = 1.0
     # parameter names:
     param_names_latex = ['m' + str(i) for i in xrange(3)]
     derived_param_names_latex = ['md' + str(i) for i in xrange(2)]
     # fiducial:
     fiducial = [float(i) for i in xrange(3)]
     fiducial_derived = [float(i) for i in xrange(2)]
     # initialize the Fisher type:
     self.fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                      param_names_latex=param_names_latex,
                                      fiducial=fiducial)
     # initialize the derived matrix:
     self.fisher_der = fd.fisher_derived(
         derived_matrix=matrix_derived,
         param_names_latex=param_names_latex,
         derived_param_names_latex=derived_param_names_latex,
         fiducial=fiducial,
         fiducial_derived=fiducial_derived)
Example #10
0
 def setup(self):
     matrix = np.identity(3)
     param_names_latex = ['m' + str(i) for i in xrange(3)]
     fiducial = [float(i) for i in xrange(3)]
     self.fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                      param_names_latex=param_names_latex,
                                      fiducial=fiducial)
     pass
 def setup(self):
     # generate the Fisher matrix. In this case a simple diagonal matrix.
     matrix = np.identity(3)
     for i in range(3):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in range(3)]
     fiducial = [float(i) for i in range(3)]
     # initialize the Fisher type:
     self.fisher_1 = fm.fisher_matrix(fisher_matrix=1.0 * matrix,
                                      param_names_latex=param_names_latex,
                                      fiducial=fiducial)
     self.fisher_2 = fm.fisher_matrix(fisher_matrix=10.0 * matrix,
                                      param_names_latex=param_names_latex,
                                      fiducial=fiducial)
     self.fisher_3 = fm.fisher_matrix(fisher_matrix=0.0 * matrix,
                                      param_names_latex=param_names_latex,
                                      fiducial=fiducial)
 def test_load_paramnames_from_file_invalid_num_params(self):
     matrix = np.identity(5)
     for i in xrange(5):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(5) ] 
     fiducial = [ float(i) for i in xrange(5) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix )
     assert_raises( ValueError, fisher_1.load_paramnames_from_file, file_name=test_input+'/dummy_paramnames_5.paramnames' )
 def test_add_same_params(self):
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(3) ] 
     fiducial = [ float(i) for i in xrange(3) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     fisher_2 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     fisher_3 = fisher_1+fisher_2
     assert np.allclose( 2.0*fisher_1.fisher_matrix, fisher_3.fisher_matrix )
     assert fisher_3.path  == fisher_3.path
     assert fisher_3.name  == "_"
     assert fisher_3.indir == fisher_3.indir
     assert fisher_3.num_params == 3
     assert np.allclose( fisher_3.fisher_eigenvalues, [ 2., 4., 6.] )
     assert fisher_3.param_names == ['p1', 'p2', 'p3']
     assert fisher_3.param_names_latex == fisher_1.param_names_latex
     assert np.allclose( fisher_3.param_fiducial, [ 0., 1., 2.] )
 def test_save_to_file_1(self):
     # load the fisher matrix:
     fisher_1 = fm.fisher_matrix(file_name=test_input +
                                 '/dummy_fisher_matrix_2.dat')
     # save the fisher matrix back to file:
     fisher_1.save_to_file(file_name=test_output +
                           '/dummy_fisher_matrix_out')
     # import it as a second fisher:
     fisher_2 = fm.fisher_matrix(file_name=test_output +
                                 '/dummy_fisher_matrix_out.dat')
     # test equality, to do so we have to set a couple of things to be the same...
     fisher_1.path = fisher_2.path
     fisher_1.name = fisher_2.name
     fisher_1.indir = fisher_2.indir
     fisher_1.protect_degenerate(
         cache=False
     )  # we have to do it twice otherwise eigenvalues are slightly different
     assert fisher_1 == fisher_2
 def test_init_from_file(self):
     fisher_1 = fm.fisher_matrix( file_name=test_input+'/dummy_fisher_matrix.dat' )
     assert np.isclose( fisher_1.fisher_cutoff , 0.100488387718 )
     assert fisher_1.path  == test_input+'/dummy_fisher_matrix.dat'
     assert fisher_1.name  == 'dummy_fisher_matrix'
     assert fisher_1.indir == test_input
     assert fisher_1.num_params == 28
     assert fisher_1.param_names == ['omegabh2', 'omegach2', 'omeganuh2', 'h', 'yhe', 'logA', 'ns', 'nrun', 'nt', 'r', 'tau', 'Bias_W_1', 'Bias_W_2', 'Bias_W_3', 'Bias_W_4', 'Bias_W_5', 'Bias_W_6', 'Bias_W_7', 'Bias_W_8', 'Bias_W_9', 'Bias_W_10', 'Bias_W_11', 'Bias_W_12', 'Bias_W_13', 'Bias_W_14', 'alpha_SN', 'beta_SN', 'M0_SN']
     assert fisher_1.param_names_latex == ['\\Omega_b h^2', '\\Omega_c h^2', '\\Omega_\\nu h^2', 'h', 'Y_{He}', '{\\rm{ln}}(10^{10} A_s)', 'n_s', 'n_{\\rm run}', 'n_t', 'r', '\\tau', 'b_1', 'b_2', 'b_3', 'b_4', 'b_5', 'b_6', 'b_7', 'b_8', 'b_9', 'b_10', 'b_11', 'b_12', 'b_13', 'b_14', '\\alpha_{\\rm SN}', '\\beta_{\\rm SN}', 'M_0^{\\rm SN}']
Example #16
0
 def test_load_paramnames_from_file_invalid_num_params(self):
     matrix = np.identity(5)
     for i in xrange(5):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in xrange(5)]
     fiducial = [float(i) for i in xrange(5)]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix)
     assert_raises(ValueError,
                   fisher_1.load_paramnames_from_file,
                   file_name=test_input + '/dummy_paramnames_5.paramnames')
 def test_realistic_add(self):
     # get the original real Fisher:
     fisher   = fm.fisher_matrix( file_name=test_input+'/dummy_fisher_matrix.dat' )
     # get the derived Fisher:
     fisher_1 = fd.fisher_derived( file_name=test_input+'/dummy_fisher_matrix_derived.dat' )
     # add them:
     new_fisher = fisher_1.add_derived( fisher_matrix=fisher, preserve_input=True )
     # check wether the initial spectrum is contained in the final spectrum:
     old_eigen = [ i for i in fisher.fisher_eigenvalues if i> 1.1*fisher.fisher_cutoff ] # remove the cutoff modes
     assert np.amin(new_fisher.fisher_eigenvalues) < np.amin(old_eigen)
     assert np.amax(new_fisher.fisher_eigenvalues) > np.amax(old_eigen)
 def test_realistic_add(self):
     # get the original real Fisher:
     fisher   = fm.fisher_matrix( file_name=test_input+'/dummy_fisher_matrix.dat' )
     # get the derived Fisher:
     fisher_1 = fd.fisher_derived( file_name=test_input+'/dummy_fisher_matrix_derived.dat' )
     # add them:
     new_fisher = fisher_1.add_derived( fisher_matrix=fisher, preserve_input=True )
     # check wether the initial spectrum is contained in the final spectrum:
     old_eigen = [ i for i in fisher.fisher_eigenvalues if i> 1.1*fisher.fisher_cutoff ] # remove the cutoff modes
     assert np.amin(new_fisher.fisher_eigenvalues) < np.amin(old_eigen)
     assert np.amax(new_fisher.fisher_eigenvalues) > np.amax(old_eigen)
 def test_fisher_save_paramnames_to_file_1(self):
     matrix = np.identity(5)
     for i in xrange(5):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(5) ] 
     fiducial = [ float(i) for i in xrange(5) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     fisher_1.save_paramnames_to_file(file_name=test_output+'/dummy_paramnames_out.paramnames')
     fisher_1.indir = './dont_exist'
     fisher_1.name  = 'dont_exist'
     assert_raises( IOError, fisher_1.save_paramnames_to_file )
Example #20
0
    def test_equality_except(self):
        matrix = np.identity(2)
        for i in xrange(2):
            matrix[i, i] = i + 1
        param_names = ['m' + str(i) for i in xrange(2)]
        fiducial = [float(i) for i in xrange(2)]
        fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                    param_names=param_names,
                                    fiducial=fiducial)

        matrix = np.identity(3)
        for i in xrange(3):
            matrix[i, i] = i + 1
        param_names = ['m' + str(i) for i in xrange(3)]
        fiducial = [float(i) for i in xrange(3)]
        fisher_2 = fm.fisher_matrix(fisher_matrix=matrix,
                                    param_names=param_names,
                                    fiducial=fiducial)

        assert fisher_1 != fisher_2
 def test_load_paramnames_from_file_4(self):
     matrix = np.identity(5)
     for i in xrange(5):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(5) ] 
     fiducial = [ float(i) for i in xrange(5) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix )
     fisher_1.load_paramnames_from_file( file_name=test_input+'/dummy_paramnames_4.paramnames')
     # test if everything is properly initialized:
     assert fisher_1.param_names == ['p1', 'p2', 'p3', 'p4', 'p5']
     assert fisher_1.param_names_latex == ['p1', 'p2', 'p3', 'p4', 'p5']
     assert np.allclose( fisher_1.param_fiducial, [ 1.0,2.0,3.0,4.0,5.0 ] )
 def setup(self):
     # create a list of fisher matrices:
     fisher_list = []
     matrix = np.identity(3)
     for j in xrange(3):
         for i in xrange(3):
             matrix[i,i] = i+j+1
         param_names_latex = [ 'm'+str(i) for i in xrange(3) ] 
         fiducial = [ float(i) for i in xrange(3) ]
         fisher = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
         fisher.name = 'fisher'+str(j+1)
         fisher_list.append( fisher )
     self.fisher_list_test = fpa.CosmicFish_FisherAnalysis(fisher_list=fisher_list)
Example #23
0
 def test_load_paramnames_from_file_4(self):
     matrix = np.identity(5)
     for i in xrange(5):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in xrange(5)]
     fiducial = [float(i) for i in xrange(5)]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix)
     fisher_1.load_paramnames_from_file(file_name=test_input +
                                        '/dummy_paramnames_4.paramnames')
     # test if everything is properly initialized:
     assert fisher_1.param_names == ['p1', 'p2', 'p3', 'p4', 'p5']
     assert fisher_1.param_names_latex == ['p1', 'p2', 'p3', 'p4', 'p5']
     assert np.allclose(fisher_1.param_fiducial, [1.0, 2.0, 3.0, 4.0, 5.0])
Example #24
0
    def test_add_different_params(self):
        matrix = np.identity(2)
        for i in xrange(2):
            matrix[i, i] = i + 1
        param_names_1 = ['m' + str(i) for i in xrange(2)]
        param_names_2 = ['b' + str(i) for i in xrange(2)]
        fiducial = [float(i) for i in xrange(2)]
        fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                    param_names=param_names_1,
                                    fiducial=fiducial)
        fisher_2 = fm.fisher_matrix(fisher_matrix=matrix,
                                    param_names=param_names_2,
                                    fiducial=fiducial)
        fisher_3 = fisher_1 + fisher_2

        assert np.allclose(fisher_3.fisher_matrix,
                           [[1.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0],
                            [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 2.0]])
        assert fisher_3.num_params == 4
        assert np.allclose(fisher_3.fisher_eigenvalues, [1.0, 1.0, 2.0, 2.0])
        assert fisher_3.param_names == ['m0', 'm1', 'b0', 'b1']
        assert np.allclose(fisher_3.param_fiducial, [0., 1., 0., 1.])
 def test_init_with_add_raises(self):
     # init the list:
     fisher_list_test = fpa.CosmicFish_FisherAnalysis()
     # check first raise:
     assert_raises( ValueError, fisher_list_test.add_fisher_matrix, [0.0] )
     # check second raise:
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i,i] = i+1
     fisher = fm.fisher_matrix( fisher_matrix=matrix )
     # add a fisher without a name:
     fisher_list_test.add_fisher_matrix( fisher )
     # add another fisher with the same (empty) name:
     assert_raises( ValueError, fisher_list_test.add_fisher_matrix, fisher )
 def test_fisher_save_paramnames_to_file_1(self):
     matrix = np.identity(5)
     for i in xrange(5):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in xrange(5)]
     fiducial = [float(i) for i in xrange(5)]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                 param_names_latex=param_names_latex,
                                 fiducial=fiducial)
     fisher_1.save_paramnames_to_file(file_name=test_output +
                                      '/dummy_paramnames_out.paramnames')
     fisher_1.indir = './dont_exist'
     fisher_1.name = 'dont_exist'
     assert_raises(IOError, fisher_1.save_paramnames_to_file)
Example #27
0
 def test_add_same_params(self):
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in xrange(3)]
     fiducial = [float(i) for i in xrange(3)]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                 param_names_latex=param_names_latex,
                                 fiducial=fiducial)
     fisher_2 = fm.fisher_matrix(fisher_matrix=matrix,
                                 param_names_latex=param_names_latex,
                                 fiducial=fiducial)
     fisher_3 = fisher_1 + fisher_2
     assert np.allclose(2.0 * fisher_1.fisher_matrix,
                        fisher_3.fisher_matrix)
     assert fisher_3.path == fisher_3.path
     assert fisher_3.name == "_"
     assert fisher_3.indir == fisher_3.indir
     assert fisher_3.num_params == 3
     assert np.allclose(fisher_3.fisher_eigenvalues, [2., 4., 6.])
     assert fisher_3.param_names == ['p1', 'p2', 'p3']
     assert fisher_3.param_names_latex == fisher_1.param_names_latex
     assert np.allclose(fisher_3.param_fiducial, [0., 1., 2.])
 def test_init_with_add_raises(self):
     # init the list:
     fisher_list_test = fpa.CosmicFish_FisherAnalysis()
     # check first raise:
     assert_raises(ValueError, fisher_list_test.add_fisher_matrix, [0.0])
     # check second raise:
     matrix = np.identity(3)
     for i in range(3):
         matrix[i, i] = i + 1
     fisher = fm.fisher_matrix(fisher_matrix=matrix)
     # add a fisher without a name:
     fisher_list_test.add_fisher_matrix(fisher)
     # add another fisher with the same (empty) name:
     assert_raises(ValueError, fisher_list_test.add_fisher_matrix, fisher)
Example #29
0
 def test_init_0D_fisher(self):
     matrix = 10
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix)
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose(fisher_1.fisher_matrix, matrix)
     assert fisher_1.path == ''
     assert fisher_1.name == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 1
     assert np.allclose(fisher_1.fisher_eigenvalues, [10.0])
     assert np.allclose(fisher_1.fisher_eigenvectors, [[1.]])
     assert np.allclose(fisher_1.fisher_matrix_inv, [[0.1]])
     assert fisher_1.param_names == ['p1']
     assert fisher_1.param_names_latex == fisher_1.param_names
     assert np.allclose(fisher_1.param_fiducial, [0.0])
     assert fisher_1.param_names_dict == {1: 'p1', 'p1': 1}
 def setup(self):
     # create a list of fisher matrices:
     fisher_list = []
     matrix = np.identity(3)
     for j in range(3):
         for i in range(3):
             matrix[i, i] = i + j + 1
         param_names_latex = ['m' + str(i) for i in range(3)]
         fiducial = [float(i) for i in range(3)]
         fisher = fm.fisher_matrix(fisher_matrix=matrix,
                                   param_names_latex=param_names_latex,
                                   fiducial=fiducial)
         fisher.name = 'fisher' + str(j + 1)
         fisher_list.append(fisher)
     self.fisher_list_test = fpa.CosmicFish_FisherAnalysis(
         fisher_list=fisher_list)
 def setup(self):
     # create a list of fisher matrices:
     fisher_list = []
     num_param = 4
     num_fish  = 3
     matrix = np.identity(num_param)
     for j in xrange(num_fish):
         for i in xrange(num_param):
             #matrix[i,i] = i+j+1
             matrix[i,i] = (i+1)/float(j+1)
         param_names_latex = [ 'm'+str(i) for i in xrange(num_param) ] 
         fiducial = [ float(i) for i in xrange(num_param) ]
         fisher = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
         fisher.name = 'fisher'+str(j+1)
         fisher_list.append( fisher )
     self.fisher_list_test = fpa.CosmicFish_FisherAnalysis(fisher_list=fisher_list)
 def test_init_0D_fisher(self):
     matrix = 10
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix )
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose( fisher_1.fisher_matrix, matrix )
     assert fisher_1.path  == ''
     assert fisher_1.name  == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 1
     assert np.allclose( fisher_1.fisher_eigenvalues, [ 10.0 ] )
     assert np.allclose( fisher_1.fisher_eigenvectors, [[ 1.]] )
     assert np.allclose( fisher_1.fisher_matrix_inv, [[ 0.1]] )
     assert fisher_1.param_names == ['p1']
     assert fisher_1.param_names_latex == fisher_1.param_names
     assert np.allclose( fisher_1.param_fiducial, [ 0.0 ] )
     assert fisher_1.param_names_dict == {1: 'p1', 'p1': 1}
Example #33
0
 def test_init_from_python(self):
     matrix = np.identity(10)
     for i in xrange(10):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in xrange(10)]
     fiducial = [float(i) for i in xrange(10)]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix,
                                 param_names_latex=param_names_latex,
                                 fiducial=fiducial)
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose(fisher_1.fisher_matrix, matrix)
     assert fisher_1.path == ''
     assert fisher_1.name == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 10
     assert np.allclose(fisher_1.fisher_eigenvalues,
                        [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
     assert fisher_1.param_names == [
         'p1', 'p2', 'p3', 'p4', 'p5', 'p6', 'p7', 'p8', 'p9', 'p10'
     ]
     assert fisher_1.param_names_latex == [
         'm0', 'm1', 'm2', 'm3', 'm4', 'm5', 'm6', 'm7', 'm8', 'm9'
     ]
     assert np.allclose(fisher_1.param_fiducial,
                        [0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
     assert fisher_1.param_names_dict == {
         'p2': 2,
         1: 'p1',
         2: 'p2',
         'p1': 1,
         4: 'p4',
         5: 'p5',
         'p4': 4,
         'p3': 3,
         8: 'p8',
         9: 'p9',
         'p8': 8,
         'p5': 5,
         'p10': 10,
         3: 'p3',
         7: 'p7',
         'p6': 6,
         6: 'p6',
         'p9': 9,
         10: 'p10',
         'p7': 7
     }
Example #34
0
 def test_init_1D_fisher(self):
     matrix = [10]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix)
     # after calling init all the objects of the class have to be initialized properly:
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose(fisher_1.fisher_matrix, matrix)
     assert fisher_1.path == ''
     assert fisher_1.name == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 1
     assert np.allclose(fisher_1.fisher_eigenvalues, [10.0])
     assert np.allclose(fisher_1.fisher_eigenvectors, [[1.]])
     assert np.allclose(fisher_1.fisher_matrix_inv, [[0.1]])
     assert fisher_1.param_names == ['p1']
     assert fisher_1.param_names_latex == fisher_1.param_names
     assert np.allclose(fisher_1.param_fiducial, [0.0])
     assert fisher_1.param_names_dict == {1: 'p1', 'p1': 1}
 def test_init_from_python(self):
     # create the list of Fisher matrices:
     fisher_list = []
     matrix = np.identity(3)
     for j in xrange(3):
         for i in xrange(3):
             matrix[i,i] = i+j+1
         param_names = [ 'pa'+str(i+j) for i in xrange(3) ] 
         param_names_latex = [ 'm'+str(i) for i in xrange(3) ] 
         fiducial = [ float(i) for i in xrange(3) ]
         fisher = fm.fisher_matrix( fisher_matrix=matrix, param_names=param_names, param_names_latex=param_names_latex, fiducial=fiducial )
         fisher.name = 'fisher'+str(j+1)
         fisher_list.append( fisher )
     fisher_list_test = fpa.CosmicFish_FisherAnalysis(fisher_list=fisher_list)
     # quality check:
     assert fisher_list_test.fisher_name_list == [ fish.name for fish in fisher_list_test.fisher_list ]
     assert fisher_list_test.fisher_name_list == [ fish.name for fish in fisher_list ]
 def test_init_1D_fisher(self):
     matrix = [10]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix )
     # after calling init all the objects of the class have to be initialized properly:
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose( fisher_1.fisher_matrix, matrix )
     assert fisher_1.path  == ''
     assert fisher_1.name  == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 1
     assert np.allclose( fisher_1.fisher_eigenvalues, [ 10.0 ] )
     assert np.allclose( fisher_1.fisher_eigenvectors, [[ 1.]] )
     assert np.allclose( fisher_1.fisher_matrix_inv, [[ 0.1]] )
     assert fisher_1.param_names == ['p1']
     assert fisher_1.param_names_latex == fisher_1.param_names
     assert np.allclose( fisher_1.param_fiducial, [ 0.0 ] )
     assert fisher_1.param_names_dict == {1: 'p1', 'p1': 1}
 def test_init_from_python(self):
     matrix = np.identity(10)
     for i in xrange(10):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(10) ] 
     fiducial = [ float(i) for i in xrange(10) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose( fisher_1.fisher_matrix, matrix )
     assert fisher_1.path  == ''
     assert fisher_1.name  == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 10
     assert np.allclose( fisher_1.fisher_eigenvalues, [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ] )
     assert fisher_1.param_names == ['p1', 'p2', 'p3', 'p4', 'p5', 'p6', 'p7', 'p8', 'p9', 'p10']
     assert fisher_1.param_names_latex == ['m0', 'm1', 'm2', 'm3', 'm4', 'm5', 'm6', 'm7', 'm8', 'm9']
     assert np.allclose( fisher_1.param_fiducial, [ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.] )
     assert fisher_1.param_names_dict == {'p2': 2, 1: 'p1', 2: 'p2', 'p1': 1, 4: 'p4', 5: 'p5', 'p4': 4, 'p3': 3, 8: 'p8', 9: 'p9', 'p8': 8, 'p5': 5, 'p10': 10, 3: 'p3', 7: 'p7', 'p6': 6, 6: 'p6', 'p9': 9, 10: 'p10', 'p7': 7}
Example #38
0
 def test_init_from_python_only_fisher(self):
     matrix = np.identity(10)
     for i in xrange(10):
         matrix[i, i] = i + 1
     param_names_latex = ['m' + str(i) for i in xrange(10)]
     fiducial = [float(i) for i in xrange(10)]
     fisher_1 = fm.fisher_matrix(fisher_matrix=matrix)
     # after calling init all the objects of the class have to be initialized properly:
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose(fisher_1.fisher_matrix, matrix)
     assert fisher_1.path == ''
     assert fisher_1.name == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 10
     assert np.allclose(fisher_1.fisher_eigenvalues,
                        [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
     assert fisher_1.param_names == [
         'p1', 'p2', 'p3', 'p4', 'p5', 'p6', 'p7', 'p8', 'p9', 'p10'
     ]
     assert fisher_1.param_names_latex == fisher_1.param_names
     assert np.allclose(fisher_1.param_fiducial,
                        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
     assert fisher_1.param_names_dict == {
         'p2': 2,
         1: 'p1',
         2: 'p2',
         'p1': 1,
         4: 'p4',
         5: 'p5',
         'p4': 4,
         'p3': 3,
         8: 'p8',
         9: 'p9',
         'p8': 8,
         'p5': 5,
         'p10': 10,
         3: 'p3',
         7: 'p7',
         'p6': 6,
         6: 'p6',
         'p9': 9,
         10: 'p10',
         'p7': 7
     }
 def test_init_from_python_only_fisher(self):
     matrix = np.identity(10)
     for i in xrange(10):
         matrix[i,i] = i+1
     param_names_latex = [ 'm'+str(i) for i in xrange(10) ] 
     fiducial = [ float(i) for i in xrange(10) ]
     fisher_1 = fm.fisher_matrix( fisher_matrix=matrix )
     # after calling init all the objects of the class have to be initialized properly:
     assert fisher_1.fisher_cutoff == 1e-09
     assert np.allclose( fisher_1.fisher_matrix, matrix )
     assert fisher_1.path  == ''
     assert fisher_1.name  == ''
     assert fisher_1.indir == ''
     assert fisher_1.num_params == 10
     assert np.allclose( fisher_1.fisher_eigenvalues, [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ] )
     assert fisher_1.param_names == ['p1', 'p2', 'p3', 'p4', 'p5', 'p6', 'p7', 'p8', 'p9', 'p10']
     assert fisher_1.param_names_latex == fisher_1.param_names
     assert np.allclose( fisher_1.param_fiducial, [ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.] )
     assert fisher_1.param_names_dict == {'p2': 2, 1: 'p1', 2: 'p2', 'p1': 1, 4: 'p4', 5: 'p5', 'p4': 4, 'p3': 3, 8: 'p8', 9: 'p9', 'p8': 8, 'p5': 5, 'p10': 10, 3: 'p3', 7: 'p7', 'p6': 6, 6: 'p6', 'p9': 9, 10: 'p10', 'p7': 7}
Example #40
0
 def test_init_from_file(self):
     fisher_1 = fm.fisher_matrix(file_name=test_input +
                                 '/dummy_fisher_matrix.dat')
     assert np.isclose(fisher_1.fisher_cutoff, 0.100488387718)
     assert fisher_1.path == test_input + '/dummy_fisher_matrix.dat'
     assert fisher_1.name == 'dummy_fisher_matrix'
     assert fisher_1.indir == test_input
     assert fisher_1.num_params == 28
     assert fisher_1.param_names == [
         'omegabh2', 'omegach2', 'omeganuh2', 'h', 'yhe', 'logA', 'ns',
         'nrun', 'nt', 'r', 'tau', 'Bias_W_1', 'Bias_W_2', 'Bias_W_3',
         'Bias_W_4', 'Bias_W_5', 'Bias_W_6', 'Bias_W_7', 'Bias_W_8',
         'Bias_W_9', 'Bias_W_10', 'Bias_W_11', 'Bias_W_12', 'Bias_W_13',
         'Bias_W_14', 'alpha_SN', 'beta_SN', 'M0_SN'
     ]
     assert fisher_1.param_names_latex == [
         '\\Omega_b h^2', '\\Omega_c h^2', '\\Omega_\\nu h^2', 'h',
         'Y_{He}', '{\\rm{ln}}(10^{10} A_s)', 'n_s', 'n_{\\rm run}', 'n_t',
         'r', '\\tau', 'b_1', 'b_2', 'b_3', 'b_4', 'b_5', 'b_6', 'b_7',
         'b_8', 'b_9', 'b_10', 'b_11', 'b_12', 'b_13', 'b_14',
         '\\alpha_{\\rm SN}', '\\beta_{\\rm SN}', 'M_0^{\\rm SN}'
     ]
 def setup(self):
     # generate the Fisher matrix. In this case a simple diagonal matrix.
     matrix = np.identity(3)
     for i in xrange(3):
         matrix[i,i] = i+1
     # Jacobian matrix:
     matrix_derived = np.zeros( (3, 2) )
     matrix_derived[0,0] = 1.0
     matrix_derived[1,1] = 1.0
     matrix_derived[2,0] = 1.0
     # parameter names:
     param_names_latex = [ 'm'+str(i) for i in xrange(3) ]
     derived_param_names_latex = [ 'md'+str(i) for i in xrange(2) ]
     # fiducial:
     fiducial = [ float(i) for i in xrange(3) ]
     fiducial_derived = [ float(i) for i in xrange(2) ]
     # initialize the Fisher type:
     self.fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     # initialize the derived matrix:
     self.fisher_der = fd.fisher_derived( derived_matrix=matrix_derived, 
                                          param_names_latex=param_names_latex, 
                                          derived_param_names_latex=derived_param_names_latex, 
                                          fiducial=fiducial, fiducial_derived=fiducial_derived)
 def setup(self):
     matrix = np.identity(3)
     param_names_latex = [ 'm'+str(i) for i in xrange(3) ] 
     fiducial = [ float(i) for i in xrange(3) ]
     self.fisher_1 = fm.fisher_matrix( fisher_matrix=matrix, param_names_latex=param_names_latex, fiducial=fiducial )
     pass
Example #43
0
 def setup(self):
     # create a list of fisher matrices:
     fisher_1      = fm.fisher_matrix( file_name=test_input+'/dummy_fisher_matrix.dat'  )
     fisher_1.name = 'realistic fisher'
     self.fisher_list_test = fpa.CosmicFish_FisherAnalysis(fisher_list=fisher_1)