Ejemplo n.º 1
0
def test_subvol_gmf(Mr):
    """
    """
    thr = -1.0 * np.float(Mr)
    model = PrebuiltHodModelFactory("zheng07", threshold=thr, halocat="multidark", redshift=0.0)
    model.new_haloprop_func_dict = {"sim_subvol": util.mk_id_column}

    datsubvol = lambda x: util.mask_func(x, 0)
    model.populate_mock(simname="multidark", masking_function=datsubvol, enforce_PBC=False)

    # compute group richness
    # These are wrong because they assume periodicity
    # rich = richness(model.mock.compute_fof_group_ids())
    # gmf = GMF(rich)  #GMF
    # print gmf
    # print GMF(rich , counts = True)

    galaxy_sample = model.mock.galaxy_table
    x = galaxy_sample["x"]
    y = galaxy_sample["y"]
    z = galaxy_sample["z"]
    vz = galaxy_sample["vz"]

    pos = three_dim_pos_bundle(model.mock.galaxy_table, "x", "y", "z", velocity=vz, velocity_distortion_dimension="z")

    b_para, b_perp = 0.2, 0.2
    groups = FoFGroups(pos, b_perp, b_para, period=None, Lbox=200, num_threads="max")

    gids = groups.group_ids
    rich = richness(gids)
    gmf = GMF(rich)

    print gmf
    print GMF(rich, counts=True)
    return None
Ejemplo n.º 2
0
def build_xi_bins(Mr=21):
    ''' hardcoded r bins for xi.
    '''
    model = PrebuiltHodModelFactory('zheng07', threshold = -1.0*np.float(Mr))
    model.populate_mock() # population mock realization
    r_bin  = model.mock.compute_galaxy_clustering(rbins=hardcoded_xi_bins())[0]
    output_file = ''.join([util.dat_dir(), 'xir_rbin.Mr', str(Mr), '.dat'])
    np.savetxt(output_file, r_bin)
    return None
Ejemplo n.º 3
0
def test_zheng07_mean_occupation_centrals():
    """
  Compares the central probability with halotools
  """
    zheng07_model = PrebuiltHodModelFactory('zheng07')

    test_mass = np.logspace(10, 15).astype('float32')
    p = zheng07_model.mean_occupation_centrals(prim_haloprop=test_mass)
    p_tf = Zheng07Cens(test_mass,
                       **(zheng07_model.param_dict)).distribution.probs
    assert_allclose(p, p_tf.numpy(), atol=1.e-3)
Ejemplo n.º 4
0
def xi_binning_tests(Mr=20):
    model = PrebuiltHodModelFactory('zheng07', threshold = -1.0*np.float(Mr))

    rbins = np.concatenate([np.array([0.1]), np.logspace(np.log10(0.5), np.log10(20.), 15)])
    print 'R bins = ', rbins
    for ii in xrange(10): 
        model.populate_mock() # population mock realization 
        
        #rbins = np.logspace(-1, np.log10(20.), 16)
        r_bin, xi_r = model.mock.compute_galaxy_clustering(rbins=rbins)
        print xi_r
Ejemplo n.º 5
0
    def __init__(self, Mr=21, b_normal=0.25):
        ''' Class object that describes our forward model used in MCMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        self.halocat = CachedHaloCatalog(simname='multidark',
                                         redshift=0,
                                         halo_finder='rockstar')
Ejemplo n.º 6
0
def test_GMFbinning(Mr):
    """ Tests for the GMF binning scheme in order to make it sensible. 
    """
    gids_saved = "gids_saved.p"
    if not os.path.isfile(gids_saved):
        thr = -1.0 * np.float(Mr)
        model = PrebuiltHodModelFactory("zheng07", threshold=thr, halocat="multidark", redshift=0.0)
        model.new_haloprop_func_dict = {"sim_subvol": util.mk_id_column}

        datsubvol = lambda x: util.mask_func(x, 0)
        model.populate_mock(simname="multidark", masking_function=datsubvol, enforce_PBC=False)

        galaxy_sample = model.mock.galaxy_table
        x = galaxy_sample["x"]
        y = galaxy_sample["y"]
        z = galaxy_sample["z"]
        vz = galaxy_sample["vz"]

        pos = three_dim_pos_bundle(
            model.mock.galaxy_table, "x", "y", "z", velocity=vz, velocity_distortion_dimension="z"
        )

        b_para, b_perp = 0.2, 0.2
        groups = FoFGroups(pos, b_perp, b_para, period=None, Lbox=200, num_threads="max")

        pickle.dump(groups, open(gids_saved, "wb"))
    else:
        groups = pickle.load(open(gids_saved, "rb"))

    gids = groups.group_ids
    rich = richness(gids)
    # print "rich=" , rich
    rbins = np.logspace(np.log10(3.0), np.log10(20), 10)
    rbins = np.array([1, 2.0, 3.0, 4.0, 5.0, 6.0, 7, 9, 11, 14, 17, 20])
    gmf = GMF(rich, counts=False, bins=rbins)
    gmf_counts = GMF(rich, counts=True, bins=rbins)

    print rbins
    print gmf
    print gmf_counts
    fig = plt.figure(1)
    sub = fig.add_subplot(111)

    sub.plot(0.5 * (rbins[:-1] + rbins[1:]), gmf)

    sub.set_xscale("log")
    sub.set_yscale("log")

    plt.show()
    # print gmf
    # print GMF(rich , counts = True)
    return None
Ejemplo n.º 7
0
 def Add_Hod(self, param_dict=PARAM_DICT, **kwargs):
     '''
     Initializes a Zheng07 HOD model and populates the mock
     '''
     print('Adding and populating Zheng07 HOD model...')
     start = time()
     self.hod = PrebuiltHodModelFactory('zheng07', redshift=REDSHIFT, modulate_with_cenocc=True)
     self.hod.param_dict.update(param_dict)
     self.hod.populate_mock(self.halos, **kwargs)
     # Compute centrals and satellites numbers
     self.hod.Ncens = (self.hod.mock.galaxy_table['gal_type'] == 'centrals').sum()
     self.hod.Nsats = (self.hod.mock.galaxy_table['gal_type'] == 'satellites').sum()
     print(f'\t Done. Elapsed time: {time()-start:.2f} s')
Ejemplo n.º 8
0
def test_subvol_gmf(Mr):
    '''
    '''
    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07',
                                    threshold=thr,
                                    halocat='multidark',
                                    redshift=0.)
    model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}

    datsubvol = lambda x: util.mask_func(x, 0)
    model.populate_mock(simname='multidark',
                        masking_function=datsubvol,
                        enforce_PBC=False)

    #compute group richness
    # These are wrong because they assume periodicity
    #rich = richness(model.mock.compute_fof_group_ids())
    #gmf = GMF(rich)  #GMF
    #print gmf
    #print GMF(rich , counts = True)

    galaxy_sample = model.mock.galaxy_table
    x = galaxy_sample['x']
    y = galaxy_sample['y']
    z = galaxy_sample['z']
    vz = galaxy_sample['vz']

    pos = three_dim_pos_bundle(model.mock.galaxy_table,
                               'x',
                               'y',
                               'z',
                               velocity=vz,
                               velocity_distortion_dimension="z")

    b_para, b_perp = 0.2, 0.2
    groups = FoFGroups(pos,
                       b_perp,
                       b_para,
                       period=None,
                       Lbox=200,
                       num_threads='max')

    gids = groups.group_ids
    rich = richness(gids)
    gmf = GMF(rich)

    print gmf
    print GMF(rich, counts=True)
    return None
Ejemplo n.º 9
0
def test_zheng07_mean_occupation_satellites():
    """
  Compare the poisson rate with halotools
  """
    zheng07_model = PrebuiltHodModelFactory('zheng07',
                                            modulate_with_cenocc=True)

    test_mass = np.logspace(10, 15).astype('float32')
    p = zheng07_model.mean_occupation_satellites(prim_haloprop=test_mass)

    n_cen = Zheng07Cens(test_mass, **(zheng07_model.param_dict))
    n_sat = Zheng07SatsPoisson(test_mass, n_cen, **(zheng07_model.param_dict))

    assert_allclose(p, n_sat.distribution.rate.numpy(), atol=1.e-2)
Ejemplo n.º 10
0
def main():
     
    # Entire MultiDark Volume (Analytic xi) 
    cov = np.loadtxt("../data/wpxicov_dr72_bright0_mr21.0_z0.159_nj400")
    print(cov.shape)
    model = PrebuiltHodModelFactory('zheng07', threshold=-21)
    print(model.param_dict)
    model.param_dict['logM0'] =  12.59
    model.param_dict['sigma_logM'] =  0.49
    model.param_dict['logMmin'] =  12.78
    model.param_dict['alpha'] =  1.14
    model.param_dict['logM1'] =  13.99
    #, 'sigma_logM': 0.39, 'logMmin': 12.79, 'alpha': 1.15, 'logM1': 13.94}

    halocat = CachedHaloCatalog(simname = 'bolplanck', redshift = 0, halo_finder = 'rockstar')
    model.populate_mock(halocat, enforce_PBC = True)
    pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

    tstart = time.time()
    t0 = tstart
    pos = pos.astype(np.float32)
    x, y, z = pos[:,0] , pos[:,1] , pos[:,2]
    t1 = time.time()
    print("Done reading the data - time taken = {0:10.1f} seconds"
          .format(t1 - t0))
    print("Beginning Correlation functions calculations")
    boxsize = 250
    nthreads = 4
    pimax = 40.0
    binfile = path.join(path.dirname(path.abspath(__file__)),
                        "../", "bin")
    autocorr = 1
    numbins_to_print = 12
    
    print("\nRunning 2-D projected correlation function wp(rp)")
    results_wp = _countpairs.countpairs_wp(boxsize, pimax, nthreads,
                                           binfile, x, y, z)
    print("\n#            ******    wp: first {0} bins  *******         "
          .format(numbins_to_print))
    print("#      rmin        rmax       rpavg        wp       npairs")
    print("##########################################################")
    for ibin in range(numbins_to_print):
        items = results_wp[ibin]
        print("{0:12.4f} {1:12.4f} {2:10.4f} {3:10.1f} {4:10d}"
              .format(items[0], items[1], items[2], items[3], items[4]))
    print("-----------------------------------------------------------")
    
    data_wp = np.loadtxt("../data/wpxi_dr72_bright0_mr21.0_z0.159_nj400")[:,1]
    print(data_wp.shape)
    data_wp_error = np.sqrt(np.diag(cov)[:12])
    print(data_wp_error.shape) 
    rbins = np.loadtxt(binfile)
    rs = np.mean(rbins , axis = 1)
    plt.figure(figsize=(10,10))
    plt.errorbar(rs , data_wp , data_wp_error , fmt=".k" , capsize = 2)
    plt.plot(rs , np.array(results_wp)[:,3])
    plt.loglog()
    plt.savefig("wp.pdf")
Ejemplo n.º 11
0
    def __init__(self, Mr=-21, b_normal=0.25):
        ''' Class object that describes our forward model used in AMC-PMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        #self.model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        self.halocat = CachedHaloCatalog(simname='multidark',
                                         redshift=0,
                                         halo_finder='rockstar')
        self.RR = data_RR(box='md_sub')
        self.randoms = data_random(box='md_sub')
        self.NR = len(self.randoms)
Ejemplo n.º 12
0
class Mock:
        
    def __init__(self, path):
        '''
        Links the object to input catalog
        '''
        self.path = path
        self.model = self.path.split('/')[-2]
    
    def Read_Halo_Table(self):
        '''
        Using the path of the Rockstar catalogue, reads the it and stores the halo table in self.table
        '''
        # Reads the file 
        print('Reading Rockstar file', self.path,'...' )
        start = time()
        self.table = CSVCatalog(self.path, NAMES, usecols=USE_COLS)
        # Creates Position and Velocity columns
        self.table['Position'] = Table_Pos(self.table)
        self.table['Velocity'] = Table_Vel(self.table)
        print(f'\t Done. Elapsed time: {time()-start:.2f} s')
    
    def Create_Halo_Catalog(self):
        '''
        Using table, cosmology and redshift builds the Halo Catalog in self.halos
        '''
        print('Creating Halo catalog...')
        start = time()
        halos = HaloCatalog(self.table, cosmo=cosmology.Planck15, redshift=REDSHIFT, 
                                 mdef='vir', position='Position', velocity='Velocity', mass='m200c')
        self.halos = halos.to_halotools(BoxSize=BOXSIZE)
        print(f'\t Done. Elapsed time: {time()-start:.2f} s')
        
    def Add_Hod(self, param_dict=PARAM_DICT, **kwargs):
        '''
        Initializes a Zheng07 HOD model and populates the mock
        '''
        print('Adding and populating Zheng07 HOD model...')
        start = time()
        self.hod = PrebuiltHodModelFactory('zheng07', redshift=REDSHIFT, modulate_with_cenocc=True)
        self.hod.param_dict.update(param_dict)
        self.hod.populate_mock(self.halos, **kwargs)
        # Compute centrals and satellites numbers
        self.hod.Ncens = (self.hod.mock.galaxy_table['gal_type'] == 'centrals').sum()
        self.hod.Nsats = (self.hod.mock.galaxy_table['gal_type'] == 'satellites').sum()
        print(f'\t Done. Elapsed time: {time()-start:.2f} s')
Ejemplo n.º 13
0
def xigm_tabulated_generator(hod = 'leauthaud11' , tr = 9.8 , \
                             rmin = 0.001 , rmax = 80 , nbins = 10 , \
                             scale = 'log' , sim = 'bolshoi', z = 0.0):


    """
    returns galaxy_matter_cross_correlation <delta_g  delta_m >
    
    arguments:
              hod : HOD model, default = Leauthaud
  	      threshold : log10 of stellar mass threshold in units of Msun/h, default = 10.6
              rmin : minimum radius of the r-bins in Mpc/h, default = .001 Mpc/h
              rmax : maximum radius of the r-bins in Mpc/h, default = 50 Mpc/h
              nbins : number of rbins, default = 100
              scale : log or linear, scaling of the rbins, default = log
              simulation name : bolshoi or multidark, default = bolshoi
              z = redshift

    """
    
    if z<0:
        
        raise ValueError("redshift cannot be negative")

    if scale == 'log':

        rbin = np.logspace(np.log10(rmin) , np.log10(rmax) , nbins)

    elif scale == 'linear':

        rbin = np.linspace(rmin , rmax , nbins)

    else:

        raise ValueError("invalid scaling for the rbins")

    model = PrebuiltHodModelFactory(hod ,threshold = tr , redshift = z)
    model.populate_mock(simname = sim , redshift = z)


    rr , xigm = model.mock.compute_galaxy_matter_cross_clustering(rbins = rbin)

    return rr , xigm
Ejemplo n.º 14
0
    def __init__(self, Mr=21, b_normal=0.25):
        ''' Class object that describes our forward model used in MCMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        self.halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
Ejemplo n.º 15
0
    def to_halotools(cosmo, redshift, mdef, concentration_key=None, **kwargs):
        """
        Parameters
        ----------
        cosmo :
            the nbodykit or astropy Cosmology object to use in the model
        redshift : float
            the desired redshift of the model
        mdef : str, optional
            string specifying mass definition, used for computing default
            halo radii and concentration; should be 'vir' or 'XXXc' or
            'XXXm' where 'XXX' is an int specifying the overdensity
        concentration_key : str
            the name of the column that will specify concentration; if not
            provided, the analytic formula from
            `Dutton and Maccio 2014 <https://arxiv.org/abs/1402.7073>`_
            is used.
        **kwargs :
            additional keywords passed to the model components; see the
            Halotools documentation for further details

        Returns
        -------
        :class:`~halotools.empirical_models.HodModelFactory`
            the halotools object implementing the HOD model
        """
        from halotools.empirical_models import PrebuiltHodModelFactory

        # modulate sats with cen occ model by default
        kwargs.setdefault('modulate_with_cenocc', True)

        # need astropy Cosmology
        if isinstance(cosmo, Cosmology):
            cosmo = cosmo.to_astropy()

        # determine concentration key
        if concentration_key is None:
            conc_mass_model = 'dutton_maccio14'
        else:
            conc_mass_model = 'direct_from_halo_catalog'

        # determine mass column
        mass_key = 'halo_m' + mdef

        # the configuration
        kwargs.update({
            'cosmology': cosmo,
            'redshift': redshift,
            'mdef': mdef,
            'prim_haloprop_key': mass_key
        })
        return PrebuiltHodModelFactory(name, **kwargs)
Ejemplo n.º 16
0
def prebuilt_hodmodel_time_profile():
    ''' Profile how long it takes to declare PrebuiltHodModelFactory.
    It takes roughly 0.000933730602264 seconds. So not very long. 
    '''
    ittook = []
    for i in xrange(20):
        start_time = time.time()

        model = PrebuiltHodModelFactory('zheng07', threshold=-20)

        ittook.append(time.time() - start_time)

    print np.mean(np.array(ittook)), ' seconds'
Ejemplo n.º 17
0
def build_xi_nbar_gmf(Mr=21):
    '''
    Build "data" xi, nbar, GMF values and write to file
    '''
    model = PrebuiltHodModelFactory('zheng07', threshold = -1.0*np.float(Mr))
    model.populate_mock(halocat = halocat , enforce_PBC = False) # population mock realization
    pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

    # write xi
    rbins = hardcoded_xi_bins()
    rmax = rbins.max()
    approx_cell1_size = [rmax, rmax, rmax]
    approx_cell2_size = approx_cell1_size
    approx_cellran_size = [rmax, rmax, rmax]
    period = np.array([Lbox , Lbox , Lbox]) 
    data_xir = tpcf(
            sample1, rbins, sample2 = sample2, 
            randoms=randoms, period = period, 
            max_sample_size=int(1e4), estimator='Landy-Szalay', 
            approx_cell1_size=approx_cell1_size, 
            approx_cellran_size=approx_cellran_size, 
            RR_precomputed = RR, 
            NR_precomputed = NR1) 
    output_file = ''.join([util.dat_dir(), 'xir.Mr', str(Mr), '.dat'])
    np.savetxt(output_file, data_xir)

    # write nbar values
    nbar = model.mock.number_density
    output_file = ''.join([util.dat_dir(), 'nbar.Mr', str(Mr), '.dat'])
    np.savetxt(output_file, [nbar])

    # write GMF
    rich = richness(model.mock.compute_fof_group_ids())
    gmf = GMF(rich)  # GMF
    output_file = ''.join([util.dat_dir(), 'gmf.Mr', str(Mr), '.dat'])
    np.savetxt(output_file, gmf)

    return None
Ejemplo n.º 18
0
    def __init__(self, Mr=21, b_normal=0.25):
        ''' Class object that describes our forward model used in AMC-PMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        ####self.model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        self.halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
        self.RR = data_RR(box='md_sub')
        self.randoms = data_random(box='md_sub')
        self.NR = len(self.randoms)
Ejemplo n.º 19
0
# by default, TabCorr applies redshift-space distortions (RSDs) in the
# tabulation of correlation functions.
rp_bins = np.logspace(-1, 1, 20)

halocat = CachedHaloCatalog(simname='bolplanck')
halotab = TabCorr.tabulate(halocat, wp, rp_bins, pi_max=40)

# We can save the result for later use.
halotab.write('bolplanck.hdf5')

# We could read it in like this. Thus, we can skip the previous steps in the
# future.
halotab = TabCorr.read('bolplanck.hdf5')

# Now, we're ready to calculate correlation functions for a specific model.
model = PrebuiltHodModelFactory('zheng07', threshold=-18)

rp_ave = 0.5 * (rp_bins[1:] + rp_bins[:-1])

ngal, wp = halotab.predict(model)
plt.plot(rp_ave, wp, label='total')

ngal, wp = halotab.predict(model, separate_gal_type=True)
for key in wp.keys():
    plt.plot(rp_ave, wp[key], label=key, ls='--')

plt.xscale('log')
plt.yscale('log')
plt.xlabel(r'$r_p \ [h^{-1} \ \mathrm{Mpc}]$')
plt.ylabel(r'$w_p \ [h^{-1} \ \mathrm{Mpc}]$')
plt.legend(loc='lower left', frameon=False)
Ejemplo n.º 20
0
def data_hod_param(Mr=21):
    '''
    HOD parameters of 'observations'. Returns dictionary with hod parameters.
    '''
    model = PrebuiltHodModelFactory('zheng07', threshold = -1.0*np.float(Mr))
    return model.param_dict
Ejemplo n.º 21
0
def test_GMFbinning(Mr):
    ''' Tests for the GMF binning scheme in order to make it sensible. 
    '''
    gids_saved = 'gids_saved.p'
    if not os.path.isfile(gids_saved):
        thr = -1. * np.float(Mr)
        model = PrebuiltHodModelFactory('zheng07',
                                        threshold=thr,
                                        halocat='multidark',
                                        redshift=0.)
        model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}

        datsubvol = lambda x: util.mask_func(x, 0)
        model.populate_mock(simname='multidark',
                            masking_function=datsubvol,
                            enforce_PBC=False)

        galaxy_sample = model.mock.galaxy_table
        x = galaxy_sample['x']
        y = galaxy_sample['y']
        z = galaxy_sample['z']
        vz = galaxy_sample['vz']

        pos = three_dim_pos_bundle(model.mock.galaxy_table,
                                   'x',
                                   'y',
                                   'z',
                                   velocity=vz,
                                   velocity_distortion_dimension="z")

        b_para, b_perp = 0.2, 0.2
        groups = FoFGroups(pos,
                           b_perp,
                           b_para,
                           period=None,
                           Lbox=200,
                           num_threads='max')

        pickle.dump(groups, open(gids_saved, 'wb'))
    else:
        groups = pickle.load(open(gids_saved, 'rb'))

    gids = groups.group_ids
    rich = richness(gids)
    #print "rich=" , rich
    rbins = np.logspace(np.log10(3.), np.log10(20), 10)
    rbins = np.array([1, 2., 3., 4., 5., 6., 7, 9, 11, 14, 17, 20])
    gmf = GMF(rich, counts=False, bins=rbins)
    gmf_counts = GMF(rich, counts=True, bins=rbins)

    print rbins
    print gmf
    print gmf_counts
    fig = plt.figure(1)
    sub = fig.add_subplot(111)

    sub.plot(0.5 * (rbins[:-1] + rbins[1:]), gmf)

    sub.set_xscale('log')
    sub.set_yscale('log')

    plt.show()
    #print gmf
    #print GMF(rich , counts = True)
    return None
Ejemplo n.º 22
0
def build_ABC_cov_nbar_xi_gmf(Mr=21, b_normal=0.25):
    ''' Build covariance matrix used in ABC for the full nbar, xi, gmf data vector
    using realisations of galaxy mocks for "data" HOD parameters in the 
    halos from the multidark simulation. Covariance matrices for different sets of observables
    can be extracted from the full covariance matrix by slicing through 
    the indices. 

    Notes 
    -----
    * This covariance matrix is the covariance matrix calculated from the *entire* multidark 
        box. So this does _not_ account for the sample variance, which the MCMC covariance does. 
    '''
    nbars, xir, gmfs = [], [], []

    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname='multidark',
                                redshift=0,
                                halo_finder='rockstar')
    rbins = xi_binedges()  # some setting for tpcf calculations

    rmax = rbins.max()
    approx_cell1_size = [rmax, rmax, rmax]
    approx_cellran_size = [rmax, rmax, rmax]

    # load randoms and RRs for the ENTIRE MultiDark volume
    ###randoms = data_random(box='md_all')
    ###RR = data_RR(box='md_all')
    ###NR = len(randoms)

    for i in xrange(1, 125):
        print 'mock#', i
        # populate the mock subvolume
        model.populate_mock(halocat)
        # returning the positions of galaxies
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

        # calculate nbar
        nbars.append(len(pos) / 1000**3.)

        # calculate xi(r) for the ENTIRE MultiDark volume
        # using the natural estimator DD/RR - 1
        xi = tpcf(pos,
                  rbins,
                  period=model.mock.Lbox,
                  max_sample_size=int(3e5),
                  estimator='Natural',
                  approx_cell1_size=approx_cell1_size)
        xir.append(xi)

        # calculate gmf
        nbar = len(pos) / 1000**3.
        b = b_normal * (nbar)**(-1. / 3)
        groups = pyfof.friends_of_friends(pos, b)
        w = np.array([len(x) for x in groups])
        gbins = gmf_bins()
        gmf = np.histogram(w, gbins)[0] / (1000.**3.)
        gmfs.append(gmf)  # GMF

    # save nbar variance
    nbar_var = np.var(nbars, axis=0, ddof=1)
    nbar_file = ''.join([util.obvs_dir(), 'abc_nbar_var.Mr', str(Mr), '.dat'])
    np.savetxt(nbar_file, [nbar_var])

    # write full covariance matrix of various combinations of the data
    # and invert for the likelihood evaluations

    # --- covariance for all three ---
    fulldatarr = np.hstack(
        (np.array(nbars).reshape(len(nbars),
                                 1), np.array(xir), np.array(gmfs)))
    fullcov = np.cov(fulldatarr.T)
    fullcorr = np.corrcoef(fulldatarr.T)
    # and save the covariance matrix
    nopoisson_file = ''.join([
        util.obvs_dir(), 'ABC.nbar_xi_gmf_cov', '.no_poisson', '.Mr',
        str(Mr), '.bnorm',
        str(round(b_normal, 2)), '.dat'
    ])
    np.savetxt(nopoisson_file, fullcov)
    return None
Ejemplo n.º 23
0
def build_nbar_xi_gmf(Mr=21, b_normal=0.25):
    ''' Build data vector [nbar, xi, gmf] and save to file 
    This data vector is built from the zeroth slice of the multidark
    The other slices will be used for building the covariance matrix.

    Parameters
    ----------
    Mr : (int) 
        Absolute magnitude cut off M_r. Default M_r = -21.

    b_normal : (float) 
        FoF Linking length
    '''
    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname='multidark',
                                redshift=0,
                                halo_finder='rockstar')
    ####model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}

    ####datsubvol = lambda x: util.mask_func(x, 0)
    ####model.populate_mock(halocat, masking_function=datsubvol, enforce_PBC=False)
    model.populate_mock(halocat)

    #all the things necessary for tpcf calculation
    pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    #masking the galaxies outside the subvolume 0
    pos = util.mask_galaxy_table(pos, 0)
    rbins = xi_binedges()
    rmax = rbins.max()
    approx_cell1_size = [rmax, rmax, rmax]
    approx_cellran_size = [rmax, rmax, rmax]

    #compute number density
    nbar = len(pos) / 200**3.

    # load MD subvolume randoms and RRs
    randoms = data_random(box='md_sub')
    RR = data_RR(box='md_sub')
    NR = len(randoms)

    #compue tpcf with Natural estimator
    data_xir = tpcf(pos,
                    rbins,
                    pos,
                    randoms=randoms,
                    period=None,
                    max_sample_size=int(2e5),
                    estimator='Natural',
                    approx_cell1_size=approx_cell1_size,
                    approx_cellran_size=approx_cellran_size,
                    RR_precomputed=RR,
                    NR_precomputed=NR)

    fullvec = np.append(nbar, data_xir)

    #compute gmf
    b = b_normal * (nbar)**(-1. / 3)
    groups = pyfof.friends_of_friends(pos, b)
    w = np.array([len(x) for x in groups])
    gbins = gmf_bins()
    gmf = np.histogram(w, gbins)[0] / (200.**3.)
    fullvec = np.append(fullvec, gmf)

    output_file = data_file(Mr=Mr, b_normal=b_normal)
    np.savetxt(output_file, fullvec)
    return None
Ejemplo n.º 24
0
def Subvolume_Analytic(N_sub, ratio=False): 
    ''' Test the 2PCF estimates from MultiDark subvolume versus the 
    analytic 2PCF for the entire MultiDark volume

    Parameters
    ----------
    N_sub : (int)
        Number of subvolumes to sample

    '''
    prettyplot()
    pretty_colors = prettycolors()

    pickle_file = ''.join([
        '/export/bbq2/hahn/ccppabc/dump/', 
        'xi_subvolume_test', 
        '.Nsub', str(N_sub), 
        '.p'])
    
    fig = plt.figure(1)
    sub = fig.add_subplot(111)

    xi_bin = xi_binedges() 
    
    if os.path.isfile(pickle_file):
        data_dump = pickle.load(open(pickle_file, 'rb'))
        full_xi = data_dump['full_xi']
    else: 
        # Entire MultiDark Volume (Analytic xi) 
        model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
        
        model.populate_mock(halocat)
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
        
        # while the estimator claims to be Landy-Szalay, I highly suspect it
        # actually uses Landy-Szalay since DR pairs cannot be calculated from 
        # analytic randoms
        full_xi = tpcf(pos, xi_bin, period=model.mock.Lbox, max_sample_size=int(2e5), estimator='Landy-Szalay', num_threads=1)
        data_dump = {} 
        data_dump['full_xi'] = full_xi

    if not ratio:  
        sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), full_xi, lw=2, ls='-', c='k', label=r'Analytic $\xi$ Entire Volume') 
    
    if not os.path.isfile(pickle_file):
        # MultiDark SubVolume (precomputed RR pairs) 
        sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        sub_halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
        RR = data_RR()
        randoms = data_random()
        NR = len(randoms)
    
    for method in ['Landy-Szalay', 'Natural']:
        
        if method == 'Landy-Szalay': 
            iii = 3
        elif method == 'Natural': 
            iii = 5
        
        if not os.path.isfile(pickle_file): 
            sub_xis_list = [] 
            sub_xis = np.zeros(len(full_xi)) 

            for ii in range(1,N_sub+1): 
                # randomly sample one of the subvolumes
                rint = ii #np.random.randint(1, 125)
                simsubvol = lambda x: util.mask_func(x, rint)
                sub_model.populate_mock(sub_halocat, masking_function=simsubvol, enforce_PBC=False)
                   
                pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y', 'z')

                xi, yi , zi = util.random_shifter(rint)
                temp_randoms = randoms.copy()
                temp_randoms[:,0] += xi
                temp_randoms[:,1] += yi
                temp_randoms[:,2] += zi
                
                rmax = xi_bin.max()
                approx_cell1_size = [rmax , rmax , rmax]
                approx_cellran_size = [rmax , rmax , rmax]

                sub_xi = tpcf(
                        pos, xi_bin, pos, 
                        randoms=temp_randoms, 
                        period = None, 
                        max_sample_size=int(1e5), 
                        estimator=method, 
                        approx_cell1_size = approx_cell1_size, 
                        approx_cellran_size = approx_cellran_size,
                        RR_precomputed=RR,
                        NR_precomputed=NR)
                label = None 
                if ii == N_sub - 1: 
                    label = 'Subvolumes'
                
                #if not ratio: 
                #    sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi, lw=0.5, ls='--', c=pretty_colors[iii])
                sub_xis += sub_xi
                sub_xis_list.append(sub_xi)

            sub_xi_avg = sub_xis/np.float(N_sub)

            data_dump[method] = {} 
            data_dump[method]['sub_xi_avg'] = sub_xi_avg
            data_dump[method]['sub_xis_list'] = sub_xis_list 
        else: 
            sub_xis_list = data_dump[method]['sub_xis_list']
            sub_xi_avg = data_dump[method]['sub_xi_avg'] 

        if not ratio: 
            sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg, 
                    lw=2, ls='--', c=pretty_colors[iii], label='Subvolume '+method)
        else: 
            sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg/full_xi, 
                    lw=2, ls='--', c=pretty_colors[iii], label='Subvolume '+method)
    
    if not os.path.isfile(pickle_file): 
        pickle.dump(data_dump, open(pickle_file, 'wb')) 

    sub.set_xlim([0.1, 50.])
    sub.set_xlabel('r', fontsize=30)
    sub.set_xscale('log')
    
    if not ratio: 
        sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
        sub.set_yscale('log')
    else: 
        sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$", fontsize=25)

    sub.legend(loc='lower left')
    
    if ratio: 
        fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_analytic.Nsub', str(N_sub), '.ratio.png'])
    else:
        fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_analytic.Nsub', str(N_sub), '.png'])
    fig.savefig(fig_file, bbox_inches='tight', dpi=100)
    plt.close()
    return None 
Ejemplo n.º 25
0
def initialise_model(redshift, model_name, halo_m_prop='halo_m'):
    '''
    create an instance of halotools model class

    logMcut : The cut-off mass for the halo to host in a central galaxy. Given
    in solar mass.

    sigma_lnM : Parameter that modulates the shape of the number of
    central galaxies.

    logM1 : The scale mass for the number of satellite galaxies.

    kappa : Parameter that affects the cut-off mass for satellite galaxies.
    A detailed discussion and best-fit values of these parameters can be found
    in Zheng+2009.

    alpha : The power law index of the number of satellite galaxies.

    alpha_c : float. The central velocity bias parameter. Modulates the
    peculiar velocity of the central galaxy. The larger the absolute value of
    the parameter, the larger the peculiar velocity of the central. The sign
    of the value does not matter.

    s : The satellite profile modulation parameter. Modulates how the radial
    distribution of satellite galaxies within halos deviate from the radial
    profile of the halo. Positive value favors satellite galaxies to populate
    the outskirts of the halo whereas negative value favors satellite galaxy
    to live near the center of the halo. |s| must be < 1.

    s_v : float. The satellite velocity bias parameter. Modulates how the
    satellite galaxy peculiar velocity deviates from that of the local dark
    matter particle. Positive value favors high peculiar velocity satellite
    galaxies and vice versa. Note that our implementation preserves the
    Newton's second law of the satellite galaxies. |s| must be < 1.

    s_p : float. The perihelion distance modulation parameter. A positive
    value favors satellite galaxies to have larger distances to the halo
    center upon their closest approach to the center and vice versa. This can
    be regarded as a "fancier" satellite profile modulation parameter.
    |s| must be < 1.

    A : float. The assembly bias parameter. Introduces the effect of assembly
    bias. A positive value favors higher concentration halos to host galaxies
    whereas a negative value favors lower concentration halos to host galaxies.
    If you are invoking assembly bias decoration, i.e. a non-zero A parameter,
    you need to run gen_medianc.py first. A detailed discussion of these
    parameters can be found in Yuan et al. in prep. To turn off any of the five
    decorations, just set the corresponding parameter to 0.

    '''

    # print('Initialising HOD model: {}...'.format(model_name))

    # halotools prebiult models
    if model_name == 'matter':
        model_type = 'matter'
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=redshift,
                                        threshold=-18,
                                        prim_haloprop_key=halo_m_prop)
        model.param_dict['logMmin'] = 13.3
        model.param_dict['sigma_logM'] = 0.8
        model.param_dict['alpha'] = 1
        model.param_dict['logM0'] = 13.3
        model.param_dict['logM1'] = 13.8
    elif model_name in PrebuiltHodModelFactory.prebuilt_model_nickname_list:
        model_type = 'prebuilt'
        if model_name == 'zheng07':
            model = PrebuiltHodModelFactory('zheng07',
                                            redshift=redshift,
                                            threshold=-18,
                                            prim_haloprop_key=halo_m_prop)
            model.param_dict['logMmin'] = 13.3
            model.param_dict['sigma_logM'] = 0.8
            model.param_dict['alpha'] = 1
            model.param_dict['logM0'] = 13.3
            model.param_dict['logM1'] = 13.8

        elif model_name == 'cacciato09':
            model = PrebuiltHodModelFactory('cacciato09',
                                            redshift=redshift,
                                            threshold=10,
                                            prim_haloprop_key=halo_m_prop)

            model.param_dict['log_L_0'] = 9.935
            model.param_dict['log_M_1'] = 12.9  # 11.07
            model.param_dict['gamma_1'] = 0.3  # 3.273
            model.param_dict['gamma_2'] = 0.255
            model.param_dict['sigma'] = 0.143
            model.param_dict['a_1'] = 0.501
            model.param_dict['a_2'] = 2.106
            model.param_dict['log_M_2'] = 14.28
            model.param_dict['b_0'] = -0.5  # -0.766
            model.param_dict['b_1'] = 1.008
            model.param_dict['b_2'] = -0.094
            model.param_dict['delta_1'] = 0
            model.param_dict['delta_2'] = 0

        elif model_name == 'leauthaud11':
            model = PrebuiltHodModelFactory('leauthaud11',
                                            redshift=redshift,
                                            threshold=11,
                                            prim_haloprop_key=halo_m_prop)
            model.param_dict['smhm_m0_0'] = 11.5  # 10.72
            model.param_dict['smhm_m0_a'] = 0.59
            model.param_dict['smhm_m1_0'] = 13.4  # 12.35
            model.param_dict['smhm_m1_a'] = 0.3
            model.param_dict['smhm_beta_0'] = 2  # 0.43
            model.param_dict['smhm_beta_a'] = 0.18
            model.param_dict['smhm_delta_0'] = 0.1  # 0.56
            model.param_dict['smhm_delta_a'] = 0.18
            model.param_dict['smhm_gamma_0'] = 1  # 1.54
            model.param_dict['smhm_gamma_a'] = 2.52
            model.param_dict['scatter_model_param1'] = 0.2
            model.param_dict['alphasat'] = 1
            model.param_dict['betasat'] = 1.1  # 0.859
            model.param_dict['bsat'] = 11  # 10.62
            model.param_dict['betacut'] = 6  # -0.13
            model.param_dict['bcut'] = 0.01  # 1.47

        elif model_name == 'tinker13':
            model = PrebuiltHodModelFactory(
                'tinker13',
                redshift=redshift,
                threshold=11,
                prim_haloprop_key=halo_m_prop,
                quiescent_fraction_abscissa=[1e12, 1e13, 1e14, 1e15],
                quiescent_fraction_ordinates=[0.25, 0.5, 0.75, 0.9])

            model.param_dict['smhm_m0_0_active'] = 11
            model.param_dict['smhm_m0_0_quiescent'] = 10.8
            model.param_dict['smhm_m1_0_active'] = 12.2
            model.param_dict['smhm_m1_0_quiescent'] = 11.8
            model.param_dict['smhm_beta_0_active'] = 0.44
            model.param_dict['smhm_beta_0_quiescent'] = 0.32
            # model.param_dict['alphasat_active'] = 1
            # model.param_dict['alphasat_quiescent'] = 1
            # model.param_dict['betacut_active'] = 0.77
            # model.param_dict['betacut_quiescent'] = -0.12
            # model.param_dict['bcut_active'] = 0.2
            # model.param_dict['bcut_quiescent'] = 0.2
            # model.param_dict['betasat_active'] = 1.5
            # model.param_dict['betasat_quiescent'] = 0.62
            model.param_dict['bsat_active'] = 13
            model.param_dict['bsat_quiescent'] = 8

        elif model_name == 'hearin15':
            model = PrebuiltHodModelFactory('hearin15',
                                            redshift=redshift,
                                            threshold=11)
        elif model_name == 'zu_mandelbaum15':
            model = PrebuiltHodModelFactory('zheng07',
                                            redshift=redshift,
                                            threshold=-1)
        elif model_name == 'zu_mandelbaum16':
            model = PrebuiltHodModelFactory('zheng07',
                                            redshift=redshift,
                                            threshold=-1)
    # generalised HOD models with 5-parameter zheng07 as base model
    else:  # 'gen_base1'
        model_type = 'general'
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=redshift,
                                        threshold=-18,
                                        prim_haloprop_key=halo_m_prop)
        # five baseline parameters
        model.param_dict['logMcut'] = 13.35
        model.param_dict['sigma_lnM'] = 0.85
        model.param_dict['kappa'] = 1
        model.param_dict['logM1'] = 13.8
        model.param_dict['alpha'] = 1
        # decoration parameters
        model.param_dict['s'] = 0  # sat ranking by halo centric distance
        model.param_dict['s_v'] = 0  # sat ranking by relative speed
        model.param_dict['s_p'] = 0  # sat ranking perihelion distance
        model.param_dict['alpha_c'] = 0  # centrals velocity bias
        model.param_dict['A_cen'] = 0  # centrals assembly bias, pseudomass
        model.param_dict['A_sat'] = 0  # satellites assembly bias, pseudomass
        ''' BOOKKEEPING: DO NOT MODIFY EXISTING MODELS, CREATE NEW ONES '''

        if model_name == 'gen_base2':  # params are tweaked to produce same ND
            model.param_dict['logM1'] = 13.85
            model.param_dict['alpha'] = 1.377
        elif model_name == 'gen_base3':
            model.param_dict['logM1'] = 13.9
            model.param_dict['alpha'] = 1.663
        elif model_name == 'gen_base4':
            model.param_dict['logM1'] = 13.796
            model.param_dict['alpha'] = 0.95
        elif model_name == 'gen_base5':
            model.param_dict['logM1'] = 13.805
            model.param_dict['alpha'] = 1.05
        elif model_name == 'gen_base6':
            model.param_dict['logM1'] = 13.770
            model.param_dict['alpha'] = 0.75
        elif model_name == 'gen_base7':
            model.param_dict['logM1'] = 13.848
            model.param_dict['alpha'] = 1.25
        elif model_name == 'gen_ass1':
            model.param_dict['A_cen'] = 1
            model.param_dict['A_sat'] = 0
        elif model_name == 'gen_ass2':
            model.param_dict['A_cen'] = 0
            model.param_dict['A_sat'] = 1
        elif model_name == 'gen_ass3':
            model.param_dict['A_cen'] = 1
            model.param_dict['A_sat'] = 1
        elif model_name == 'gen_ass1_n':
            model.param_dict['A_cen'] = -1
            model.param_dict['A_sat'] = 0
        elif model_name == 'gen_ass2_n':
            model.param_dict['A_cen'] = 0
            model.param_dict['A_sat'] = -1
        elif model_name == 'gen_ass3_n':
            model.param_dict['A_cen'] = -1
            model.param_dict['A_sat'] = -1
        elif model_name == 'gen_vel1':
            model.param_dict['alpha_c'] = 1
        elif model_name == 'gen_vel2':
            model.param_dict['alpha_c'] = 0.2
        elif model_name == 'gen_s1':
            model.param_dict['s'] = 0.9
        elif model_name == 'gen_sv1':
            model.param_dict['s_v'] = 0.9
        elif model_name == 'gen_sp1':
            model.param_dict['s_p'] = 0.9
        elif model_name == 'gen_s1_n':
            model.param_dict['s'] = -0.9
        elif model_name == 'gen_sv1_n':
            model.param_dict['s_v'] = -0.9
        elif model_name == 'gen_sp1_n':
            model.param_dict['s_p'] = -0.9
        elif model_name == 'gen_allbiases':
            model.param_dict['A_cen'] = 1
            model.param_dict['A_sat'] = 1
            model.param_dict['alpha_c'] = 1
            model.param_dict['s'] = 0.9
            model.param_dict['s_v'] = 0.9
            model.param_dict['s_p'] = 0.9
        elif model_name == 'gen_allbiases_n':
            model.param_dict['A_cen'] = -1
            model.param_dict['A_sat'] = -1
            model.param_dict['alpha_c'] = 1
            model.param_dict['s'] = -0.9
            model.param_dict['s_v'] = -0.9
            model.param_dict['s_p'] = -0.9

    # add useful model properties here
    model.model_name = model_name
    model.model_type = model_type
    model.halo_m_prop = halo_m_prop

    return model
Ejemplo n.º 26
0
def main():
   

    ###############################Multi-Dark########################### 
    
    model = PrebuiltHodModelFactory('zheng07', threshold=-21)
    halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
    t0 = time.time()
    model.populate_mock(halocat, enforce_PBC = False)
    print(time.time() - t0)
    t0 = time.time()
    model.populate_mock(halocat, enforce_PBC = False)
    print(time.time() - t0)
    pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    nthreads = 1

    binfile = path.join(path.dirname(path.abspath(__file__)),
                        "/home/mj/Corrfunc/xi_theory/tests/", "bins")
    autocorr = 1
    pos = pos.astype(np.float32)
   
    x , y , z = pos[:,0] , pos[:,1] , pos[:,2]
    DD = _countpairs.countpairs(autocorr, nthreads, binfile, x, y, z,
                                x , y , z)
    ND = len(pos)
    NR = 50*800000
    DD = np.array(DD)[:,3]
    
    
    num_randoms = 50 * 800000
    xran = np.random.uniform(0, 1000, num_randoms)
    yran = np.random.uniform(0, 1000, num_randoms)
    zran = np.random.uniform(0, 1000, num_randoms)
    randoms = np.vstack((xran, yran, zran)).T 
    
    randoms = randoms.astype(np.float32)

    xran = randoms[:,0]
    yran = randoms[:,1]
    zran = randoms[:,2]

     
    results_RR = _countpairs.countpairs(autocorr, nthreads, binfile, xran, yran, zran,
                                        xran, yran, zran)
    
    RR = np.array(results_RR)[:,3]
    factor1 = 1.*ND*ND/(NR*NR)
    mult = lambda x,y: x*y
    xi_MD = mult(1.0/factor1 , DD/RR) - 1.

    print(xi_MD)
   

    ###############################Subvolume of Multi-Dark########################### 
     
    num_srandoms = 50 * 8000
    xran = np.random.uniform(0, 200, num_srandoms)
    yran = np.random.uniform(0, 200, num_srandoms)
    zran = np.random.uniform(0, 200, num_srandoms)
    randoms = np.vstack((xran, yran, zran)).T 
    
    randoms = randoms.astype(np.float32)

    xran = randoms[:,0]
    yran = randoms[:,1]
    zran = randoms[:,2]

    results_RR = _countpairs.countpairs(autocorr, nthreads, binfile, xran, yran, zran,
                                        xran, yran, zran)
    RR_sub = np.array(results_RR)[:,3] 
    
    
    import util    
    sub_model = PrebuiltHodModelFactory('zheng07' , threshold = -21)
    sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
    sub_halocat = CachedHaloCatalog(simname='multidark', redshift=0, halo_finder='rockstar')     
    xi_subs = [] 
    for i in range(10):
      simsubvol = lambda x: util.mask_func(x, i)
      sub_model.populate_mock(sub_halocat, masking_function=simsubvol, enforce_PBC=False)
      sub_pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y', 'z')
      nthreads = 1
      binfile = path.join(path.dirname(path.abspath(__file__)),
                        "/home/mj/Corrfunc/xi_theory/tests/", "bins")
      autocorr = 1
      sub_pos = sub_pos.astype(np.float32)
      x , y , z = sub_pos[:,0] , sub_pos[:,1] , sub_pos[:,2]
      DD_sub = _countpairs.countpairs(autocorr, nthreads, binfile, x, y, z,
                                        x, y, z)
    
      ND_sub = len(sub_pos)
      NR_sub = 50 * 8000
      DD_sub = np.array(DD_sub)[:,3]
      factor1 = 1.*ND_sub*ND_sub/(NR_sub*NR_sub)
      mult = lambda x,y: x*y
      xi_n = mult(1.0/factor1 , DD_sub/RR_sub) - 1.
      xi_subs.append(xi_n)
    
    xi_subs = np.array(xi_subs)
    np.savetxt("xi_subs.dat" , xi_subs)
     
    import matplotlib.pyplot as plt
    from ChangTools.plotting import prettyplot
    from ChangTools.plotting import prettycolors 

        
    binfile = path.join(path.dirname(path.abspath(__file__)),
                        "/home/mj/Corrfunc/xi_theory/tests/", "bins")
    rbins =  np.loadtxt(binfile)
    rbins_centers = np.mean(rbins , axis = 1)
    
    xi_subs = np.loadtxt("xi_subs.dat")

    fig = plt.figure(figsize=(10,10))
    ax = fig.add_subplot(111)
    for i in range(10):

        ax.semilogx(rbins_centers , xi_subs[i,:] / xi_MD , alpha = 0.2)
        plt.xlabel(r"$r$" , fontsize = 20)
        plt.ylabel(r"$\xi_{\rm subvolume}(r) / \xi_{\rm MD}(r)$" , fontsize = 20) 
        plt.savefig("xi_ratios.pdf")
Ejemplo n.º 27
0
def build_ABC_cov_nbar_xi_gmf(Mr=21, b_normal=0.25):
    ''' Build covariance matrix used in ABC for the full nbar, xi, gmf data vector
    using realisations of galaxy mocks for "data" HOD parameters in the 
    halos from the multidark simulation. Covariance matrices for different sets of observables
    can be extracted from the full covariance matrix by slicing through 
    the indices. 

    Notes 
    -----
    * This covariance matrix is the covariance matrix calculated from the *entire* multidark 
        box. So this does _not_ account for the sample variance, which the MCMC covariance does. 
    '''
    nbars, xir, gmfs = [], [], [] 

    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
    rbins = xi_binedges()  # some setting for tpcf calculations

    rmax = rbins.max()
    approx_cell1_size = [rmax , rmax , rmax]
    approx_cellran_size = [rmax , rmax , rmax]
    
    # load randoms and RRs for the ENTIRE MultiDark volume 
    ###randoms = data_random(box='md_all')
    ###RR = data_RR(box='md_all')
    ###NR = len(randoms)

    for i in xrange(1,125):
        print 'mock#', i
        # populate the mock subvolume
        model.populate_mock(halocat)
        # returning the positions of galaxies
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

        # calculate nbar
        nbars.append(len(pos) / 1000**3.)

        # calculate xi(r) for the ENTIRE MultiDark volume 
        # using the natural estimator DD/RR - 1
        xi = tpcf(
                pos, rbins, period=model.mock.Lbox, 
                max_sample_size=int(3e5), estimator='Natural', 
                approx_cell1_size=approx_cell1_size)
        xir.append(xi)

        # calculate gmf
        nbar = len(pos) / 1000**3.
        b = b_normal * (nbar)**(-1./3) 
        groups = pyfof.friends_of_friends(pos , b)
        w = np.array([len(x) for x in groups])
        gbins = gmf_bins()
        gmf = np.histogram(w , gbins)[0] / (1000.**3.)
        gmfs.append(gmf)  # GMF

    # save nbar variance
    nbar_var = np.var(nbars, axis=0, ddof=1)
    nbar_file = ''.join([util.obvs_dir(), 'abc_nbar_var.Mr', str(Mr), '.dat'])
    np.savetxt(nbar_file, [nbar_var])

    # write full covariance matrix of various combinations of the data
    # and invert for the likelihood evaluations

    # --- covariance for all three ---
    fulldatarr = np.hstack((np.array(nbars).reshape(len(nbars), 1),
                            np.array(xir),
                            np.array(gmfs)))
    fullcov = np.cov(fulldatarr.T)
    fullcorr = np.corrcoef(fulldatarr.T)
    # and save the covariance matrix
    nopoisson_file = ''.join([util.obvs_dir(),
        'ABC.nbar_xi_gmf_cov', '.no_poisson', '.Mr', str(Mr), '.bnorm', str(round(b_normal, 2)), '.dat'])
    np.savetxt(nopoisson_file, fullcov)
    return None
Ejemplo n.º 28
0
def build_MCMC_cov_nbar_xi_gmf(Mr=21, b_normal=0.25):
    ''' Build covariance matrix used in MCMC for the full nbar, xi, gmf data vector
    using realisations of galaxy mocks for "data" HOD parameters in the 
    halos from the other subvolumes (subvolume 1 to subvolume 125) of
    the simulation. Covariance matrices for different sets of observables
    can be extracted from the full covariance matrix by slicing through 
    the indices. 

    '''
    nbars = []
    xir = []
    gmfs = []

    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
    ###model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
    
    #some settings for tpcf calculations
    rbins = xi_binedges()
    rmax = rbins.max()
    approx_cell1_size = [rmax , rmax , rmax]
    approx_cellran_size = [rmax , rmax , rmax]
    
    #load randoms and RRs
    
    randoms = data_random(box='md_sub')
    RR = data_RR(box='md_sub')
    NR = len(randoms)

    for i in xrange(1,125):
        print 'mock#', i

        # populate the mock subvolume
        ###mocksubvol = lambda x: util.mask_func(x, i)
        ###model.populate_mock(halocat,
        ###                    masking_function=mocksubvol,
        ###                    enforce_PBC=False)
        model.populate_mock(halocat)
        # returning the positions of galaxies in the entire volume
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
        # masking out the galaxies outside the subvolume i
        pos = util.mask_galaxy_table(pos , i)
        # calculate nbar
        print "shape of pos" , pos.shape 
        nbars.append(len(pos) / 200**3.)
        # translate the positions of randoms to the new subbox
        xi0 , yi0 , zi0 = util.random_shifter(i)
        temp_randoms = randoms.copy()
        temp_randoms[:,0] += xi0
        temp_randoms[:,1] += yi0
        temp_randoms[:,2] += zi0
        #calculate xi(r)        
        xi=tpcf(
             pos, rbins, pos, 
             randoms=temp_randoms, period=None, 
             max_sample_size=int(3e5), estimator='Natural', 
             approx_cell1_size=approx_cell1_size, 
             approx_cellran_size=approx_cellran_size,
             RR_precomputed = RR,
	     NR_precomputed = NR)
        xir.append(xi)
        # calculate gmf

        nbar = len(pos) / 200**3.
        b = b_normal * (nbar)**(-1./3) 
        groups = pyfof.friends_of_friends(pos , b)
    	w = np.array([len(x) for x in groups])
    	gbins = gmf_bins()
    	gmf = np.histogram(w , gbins)[0] / 200.**3.
        gmfs.append(gmf)

    # save nbar variance
    nbar_var = np.var(nbars, axis=0, ddof=1)
    nbar_file = ''.join([util.obvs_dir(), 'nbar_var.Mr', str(Mr), '.dat'])
    np.savetxt(nbar_file, [nbar_var])

    # write full covariance matrix of various combinations of the data
    # and invert for the likelihood evaluations

    # --- covariance for all three ---
    fulldatarr = np.hstack((np.array(nbars).reshape(len(nbars), 1),
                            np.array(xir),
                            np.array(gmfs)))
    fullcov = np.cov(fulldatarr.T)
    fullcorr = np.corrcoef(fulldatarr.T)

    # and save the covariance matrix
    nopoisson_file = ''.join([util.obvs_dir(),
        'MCMC.nbar_xi_gmf_cov', '.no_poisson', '.Mr', str(Mr), '.bnorm', str(round(b_normal,2)), '.dat'])
    np.savetxt(nopoisson_file, fullcov)
    return None
Ejemplo n.º 29
0
def build_nbar_xi_gmf(Mr=21, b_normal=0.25):
    ''' Build data vector [nbar, xi, gmf] and save to file 
    This data vector is built from the zeroth slice of the multidark
    The other slices will be used for building the covariance matrix.

    Parameters
    ----------
    Mr : (int) 
        Absolute magnitude cut off M_r. Default M_r = -21.

    b_normal : (float) 
        FoF Linking length
    '''
    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
    ####model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}

    ####datsubvol = lambda x: util.mask_func(x, 0)
    ####model.populate_mock(halocat, masking_function=datsubvol, enforce_PBC=False)
    model.populate_mock(halocat)
    
    #all the things necessary for tpcf calculation
    pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    #masking the galaxies outside the subvolume 0
    pos = util.mask_galaxy_table(pos , 0)
    rbins = xi_binedges()
    rmax = rbins.max()
    approx_cell1_size = [rmax , rmax , rmax]
    approx_cellran_size = [rmax , rmax , rmax]

    #compute number density    
    nbar = len(pos) / 200**3.
    
    # load MD subvolume randoms and RRs
    randoms = data_random(box='md_sub')
    RR = data_RR(box='md_sub')
    NR = len(randoms)
 
    #compue tpcf with Natural estimator
    data_xir = tpcf(
                 pos, rbins, pos, 
                 randoms=randoms, period=None, 
                 max_sample_size=int(2e5), estimator='Natural', 
                 approx_cell1_size=approx_cell1_size, 
                 approx_cellran_size=approx_cellran_size, 
                 RR_precomputed=RR, 
                 NR_precomputed=NR)

    fullvec = np.append(nbar, data_xir)
    
    #compute gmf
    b = b_normal * (nbar)**(-1./3) 
    groups = pyfof.friends_of_friends(pos , b)
    w = np.array([len(x) for x in groups])
    gbins = gmf_bins()
    gmf = np.histogram(w , gbins)[0] / (200.**3.)
    fullvec = np.append(fullvec, gmf)

    output_file = data_file(Mr=Mr, b_normal=b_normal)
    np.savetxt(output_file, fullvec)
    return None
Ejemplo n.º 30
0
def model(theta, Mstar, prior_range = None):

    '''
    Given theta (HOD parameters) and stellar mass threshold Mstar, 
    compute wp
    not sure prior_range is necessary here
    '''

    model = PrebuiltHodModelFactory('hearin15', threshold = Mstar, 
                                     redshift = 0.0 ,
                                     central_assembias_strength = 0.,
                                     satellite_assembias_strength = 0.)

    model.param_dict['alphasat'] = theta[0]#1.0
    model.param_dict['bcut'] = theta[1]#1.47, 
    model.param_dict['betacut'] = theta[2]#0.13
    model.param_dict['betasat'] =  theta[3]#0.859
    model.param_dict['bsat'] = theta[4]#0.62
    model.param_dict['mean_occupation_centrals_assembias_param1'] = theta[5] # 0
    model.param_dict['mean_occupation_satellites_assembias_param1'] = theta[6] #.75
    model.param_dict['scatter_model_param1'] = theta[7]#0.2
    model.param_dict['smhm_beta_0'] = theta[8]# 0.43 
    model.param_dict['smhm_beta_a'] = theta[9]#0.18 
    model.param_dict['smhm_delta_0'] = theta[10]#0.56
    model.param_dict['smhm_delta_a'] = theta[11]#0.18, 
    model.param_dict['smhm_gamma_0']= theta[12]#1.54 
    model.param_dict['smhm_gamma_a'] = theta[13]#2.52, 
    model.param_dict['smhm_m0_0'] = theta[14]# 10.72, 
    model.param_dict['smhm_m0_a'] = theta[15]# 0.59 
    model.param_dict['smhm_m1_0'] = theta[16]# 12.35, 
    model.param_dict['smhm_m1_a'] = theta[17]#0.3
 
    
    model.populate_mock(simname = 'bolshoi', redshift = 0, halo_finder = 'rockstar')
    #x = model.mock.galaxy_table['x']
    #y = model.mock.galaxy_table['y']
    #z = model.mock.galaxy_table['z']
    #all_positions = return_xyz_formatted_array(x, y, z)    
    all_positions = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    
    wp_all = wp(all_positions, rp_bins, pi_bins,
                period=model.mock.Lbox, estimator = 'Landy-Szalay', num_threads = 1)
    #wp = proj_clustering(pos , rbins , pbins , cellsize = [rmax, rmax, rmax])
    print 1
    return rp_bin_centers, wp_all
Ejemplo n.º 31
0
def populate_halocat(halocat, model_name):

    print('Initialising HOD model...')
    if model_name == 'zheng07':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=halocat.redshift,
                                        threshold=-18)
        # model_instance.param_dict['logMmin'] = 12.1
        # model_instance.mock.populate()

    if model_name == 'leauthaud11':
        model = PrebuiltHodModelFactory('leauthaud11',
                                        redshift=halocat.redshift,
                                        threshold=10)

    if model_name == 'tinker13':
        model = PrebuiltHodModelFactory(
            'tinker13',
            redshift=halocat.redshift,
            threshold=10,
            quiescent_fraction_abscissa=[1e12, 1e13, 1e14, 1e15],
            quiescent_fraction_ordinates=[0.25, 0.5, 0.75, 0.9])

    if model_name == 'hearin15':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=halocat.redshift,
                                        threshold=-1)
    if model_name == 'zu_mandelbaum15':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=halocat.redshift,
                                        threshold=-1)
    if model_name == 'zu_mandelbaum16':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=halocat.redshift,
                                        threshold=-1)
    if model_name == 'cacciato09':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=halocat.redshift,
                                        threshold=-1)
    print('HOD model initialised. Populating {} halos with {}...'.format(
        len(halocat.halo_table), model_name))
    model.populate_mock(halocat, Num_ptcl_requirement=100)
    print('Mock catalogue populated with {} galaxies'.format(
        len(model.mock.galaxy_table)))
    return model
Ejemplo n.º 32
0
def Subvolume_FullvolumeCut(N_sub, ratio=False):
    ''' Test the 2PCF estimates from MultiDark subvolume versus the 
    2PCF for the entire MultiDark volume WITHOUT periodic boundary conditions
    and actual pair counts, CUT into subvolumes of the same size *AFTER*
    populate mock 


    Parameters
    ----------
    N_sub : (int)
        Number of subvolumes to sample

    '''
    prettyplot()
    pretty_colors = prettycolors()

    pickle_file = ''.join([
        '/export/bbq2/hahn/ccppabc/dump/', 'xi_subvolume_fullvolume_cut_test',
        '.Nsub',
        str(N_sub), '.p'
    ])

    fig = plt.figure(1)
    sub = fig.add_subplot(111)

    xi_bin = xi_binedges()

    # Entire MultiDark Volume (No Periodic Boundary Conditions)
    model = PrebuiltHodModelFactory('zheng07', threshold=-21)
    halocat = CachedHaloCatalog(simname='multidark',
                                redshift=0,
                                halo_finder='rockstar')

    sub_RR = data_RR(box='md_sub')
    sub_randoms = data_random(box='md_sub')
    sub_NR = len(sub_randoms)

    rmax = xi_bin.max()
    full_approx_cell1_size = [rmax, rmax, rmax]
    full_approx_cellran_size = [rmax, rmax, rmax]

    model.populate_mock(halocat, enforce_PBC=False)
    subvol_id = util.mk_id_column(table=model.mock.galaxy_table)
    full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

    # Full Volume
    if os.path.isfile(pickle_file):
        data_dump = pickle.load(open(pickle_file, 'rb'))
        full_xi = data_dump['full_xi']
    else:
        model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        halocat = CachedHaloCatalog(simname='multidark',
                                    redshift=0,
                                    halo_finder='rockstar')

        full_randoms = data_random(box='md_all')
        full_RR = data_RR(box='md_all')
        full_NR = len(full_randoms)

        rmax = xi_bin.max()
        full_approx_cell1_size = [rmax, rmax, rmax]
        full_approx_cellran_size = [rmax, rmax, rmax]

        model.populate_mock(halocat, enforce_PBC=False)
        full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

        full_xi = tpcf(full_pos,
                       xi_bin,
                       randoms=full_randoms,
                       period=None,
                       do_auto=True,
                       do_cross=False,
                       num_threads=5,
                       max_sample_size=int(full_pos.shape[0]),
                       estimator='Natural',
                       approx_cell1_size=full_approx_cell1_size,
                       approx_cellran_size=full_approx_cellran_size,
                       RR_precomputed=full_RR,
                       NR_precomputed=full_NR)
        data_dump = {}
        data_dump['full_xi'] = full_xi

    if not ratio:
        sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                 full_xi,
                 lw=2,
                 ls='-',
                 c='k',
                 label=r'Full Volume')

    if os.path.isfile(pickle_file):
        fullcut_xi_list = data_dump['fullcut_xi']['fullcut_xi_list']
        fullcut_xi_avg = data_dump['fullcut_xi']['fullcut_xi_avg']
    else:
        data_dump['fullcut_xi'] = {}
        fullcut_xi_list = []
        fullcut_xi_tot = np.zeros(len(xi_bin) - 1)
        for id in np.unique(subvol_id)[:N_sub]:
            print 'Subvolume ', id
            in_cut = np.where(subvol_id == id)

            fullcut_pos = full_pos[in_cut]

            fullcut_xi = tpcf(fullcut_pos,
                              xi_bin,
                              randoms=sub_randoms,
                              period=None,
                              do_auto=True,
                              do_cross=False,
                              num_threads=5,
                              max_sample_size=int(fullcut_pos.shape[0]),
                              estimator='Natural',
                              approx_cell1_size=full_approx_cell1_size,
                              approx_cellran_size=full_approx_cellran_size,
                              RR_precomputed=sub_RR,
                              NR_precomputed=sub_NR)

            fullcut_xi_list.append(fullcut_xi)
            fullcut_xi_tot += fullcut_xi

        fullcut_xi_avg = fullcut_xi_tot / np.float(N_sub)
        data_dump['fullcut_xi']['fullcut_xi_list'] = fullcut_xi_list
        data_dump['fullcut_xi']['fullcut_xi_avg'] = fullcut_xi_avg

    if not ratio:
        sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                 fullcut_xi_avg,
                 lw=2,
                 ls='-',
                 c='k',
                 label=r'Full Volume Cut Average')
    else:
        sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                 fullcut_xi_avg / full_xi,
                 lw=2,
                 ls='-',
                 c='k',
                 label=r'Full Volume Cut Average')

    if not os.path.isfile(pickle_file):
        # MultiDark SubVolume (precomputed RR pairs)
        sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        sub_halocat = CachedHaloCatalog(simname='multidark',
                                        redshift=0,
                                        halo_finder='rockstar')
        sub_RR = data_RR(box='md_sub')
        sub_randoms = data_random(box='md_sub')
        sub_NR = len(sub_randoms)

        sub_xis_list = []
        sub_xis = np.zeros(len(full_xi))

        for ii in range(1, N_sub):
            print 'Subvolume ', ii
            # randomly sample one of the subvolumes
            rint = ii  #np.random.randint(1, 125)
            simsubvol = lambda x: util.mask_func(x, rint)
            sub_model.populate_mock(sub_halocat,
                                    masking_function=simsubvol,
                                    enforce_PBC=False)

            pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y',
                                       'z')

            xi, yi, zi = util.random_shifter(rint)
            temp_randoms = sub_randoms.copy()
            temp_randoms[:, 0] += xi
            temp_randoms[:, 1] += yi
            temp_randoms[:, 2] += zi

            rmax = xi_bin.max()
            sub_approx_cell1_size = [rmax, rmax, rmax]
            sub_approx_cellran_size = [rmax, rmax, rmax]

            sub_xi = tpcf(pos,
                          xi_bin,
                          randoms=temp_randoms,
                          period=None,
                          do_auto=True,
                          do_cross=False,
                          num_threads=5,
                          max_sample_size=int(pos.shape[0]),
                          estimator='Natural',
                          approx_cell1_size=sub_approx_cell1_size,
                          approx_cellran_size=sub_approx_cellran_size,
                          RR_precomputed=sub_RR,
                          NR_precomputed=sub_NR)

            label = None
            if ii == N_sub - 1:
                label = 'Subvolumes'

            sub_xis += sub_xi
            sub_xis_list.append(sub_xi)

        sub_xi_avg = sub_xis / np.float(N_sub)

        data_dump['Natural'] = {}
        data_dump['Natural']['sub_xi_avg'] = sub_xi_avg
        data_dump['Natural']['sub_xis_list'] = sub_xis_list
    else:
        sub_xis_list = data_dump['Natural']['sub_xis_list']
        sub_xi_avg = data_dump['Natural']['sub_xi_avg']

    if not os.path.isfile(pickle_file):
        pickle.dump(data_dump, open(pickle_file, 'wb'))

    if not ratio:
        sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                 sub_xi_avg,
                 lw=2,
                 ls='--',
                 c=pretty_colors[3],
                 label='Subvolume')
    else:
        sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                 sub_xi_avg / full_xi,
                 lw=2,
                 ls='--',
                 c=pretty_colors[3],
                 label='Subvolume')

    sub.set_xlim([0.1, 50.])
    sub.set_xlabel('r', fontsize=30)
    sub.set_xscale('log')

    if not ratio:
        sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
        sub.set_yscale('log')
    else:
        sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$",
                       fontsize=25)

    sub.legend(loc='lower left')

    if ratio:
        fig_file = ''.join([
            util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub',
            str(N_sub), '.ratio.png'
        ])
    else:
        fig_file = ''.join([
            util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub',
            str(N_sub), '.png'
        ])
    fig.savefig(fig_file, bbox_inches='tight', dpi=100)
    plt.close()
    return None
Ejemplo n.º 33
0
def build_nbar_xi_gmf_cov(Mr=21):
    ''' Build covariance matrix for the full nbar, xi, gmf data vector
    using realisations of galaxy mocks for "data" HOD parameters in the 
    halos from the multidark simulation. Covariance matrices for different sets of observables
    can be extracted from the full covariance matrix by slicing through 
    the indices. 

    '''
    nbars = []
    xir = []
    gmfs = []

    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname='multidark',
                                redshift=0,
                                halo_finder='rockstar')
    #some settings for tpcf calculations
    rbins = hardcoded_xi_bins()

    for i in xrange(1, 125):
        print 'mock#', i

        # populate the mock subvolume
        model.populate_mock(halocat)
        # returning the positions of galaxies
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
        # calculate nbar
        nbars.append(len(pos) / 1000**3.)
        # translate the positions of randoms to the new subbox
        #calculate xi(r)
        xi = tpcf(pos,
                  rbins,
                  period=model.mock.Lbox,
                  max_sample_size=int(2e5),
                  estimator='Landy-Szalay')
        xir.append(xi)
        # calculate gmf
        nbar = len(pos) / 1000**3.
        b_normal = 0.75
        b = b_normal * (nbar)**(-1. / 3)
        groups = pyfof.friends_of_friends(pos, b)
        w = np.array([len(x) for x in groups])
        gbins = gmf_bins()
        gmf = np.histogram(w, gbins)[0] / (1000.**3.)
        gmfs.append(gmf)  # GMF
    # save nbar variance
    nbar_var = np.var(nbars, axis=0, ddof=1)
    nbar_file = ''.join(
        [util.multidat_dir(), 'abc_nbar_var.Mr',
         str(Mr), '.dat'])
    np.savetxt(nbar_file, [nbar_var])

    # write full covariance matrix of various combinations of the data
    # and invert for the likelihood evaluations

    # --- covariance for all three ---
    fulldatarr = np.hstack(
        (np.array(nbars).reshape(len(nbars),
                                 1), np.array(xir), np.array(gmfs)))
    fullcov = np.cov(fulldatarr.T)
    fullcorr = np.corrcoef(fulldatarr.T)
    # and save the covariance matrix
    nopoisson_file = ''.join([
        util.multidat_dir(), 'abc_nbar_xi_gmf_cov.no_poisson.Mr',
        str(Mr), '.dat'
    ])
    np.savetxt(nopoisson_file, fullcov)

    # and a correlation matrix
    full_corr_file = ''.join(
        [util.multidat_dir(), 'abc_nbar_xi_gmf_corr.Mr',
         str(Mr), '.dat'])
    np.savetxt(full_corr_file, fullcorr)

    return None
Ejemplo n.º 34
0
def standard_hod_model():
    return PrebuiltHodModelFactory('zheng07', threshold=-20)
Ejemplo n.º 35
0
class MCMC_HODsim(object):
    def __init__(self, Mr=-21, b_normal=0.25):
        ''' Class object that describes our forward model used in AMC-PMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        self.halocat = CachedHaloCatalog(simname='multidark',
                                         redshift=0,
                                         halo_finder='rockstar')

        self.RR = data_RR(box='md_all')
        self.randoms = data_random('md_all')
        self.NR = len(self.randoms)

    def __call__(self, theta, prior_range=None, observables=['nbar', 'gmf']):
        return self._sum_stat(theta,
                              prior_range=prior_range,
                              observables=observables)

    def _sum_stat(self, theta, prior_range=None, observables=['nbar', 'gmf']):
        '''
        Given theta, sum_stat calculates the observables from our forward model

        Parameters
        ----------
        theta : (self explanatory)
        prior_range : If specified, checks to make sure that theta is within the prior range.
        '''
        self.model.param_dict['logM0'] = theta[0]
        self.model.param_dict['sigma_logM'] = np.exp(theta[1])
        self.model.param_dict['logMmin'] = theta[2]
        self.model.param_dict['alpha'] = theta[3]
        self.model.param_dict['logM1'] = theta[4]

        rbins = xi_binedges()
        rmax = rbins.max()
        approx_cell1_size = [rmax, rmax, rmax]
        approx_cellran_size = [rmax, rmax, rmax]

        if prior_range is None:

            self.model.populate_mock(self.halocat, enforce_PBC=False)
            pos = three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y',
                                       'z')
            obvs = []

            for obv in observables:
                if obv == 'nbar':
                    obvs.append(len(pos) /
                                1000.**3.)  # nbar of the galaxy catalog
                elif obv == 'gmf':
                    nbar = len(pos) / 1000**3.
                    b = self.b_normal * (nbar)**(-1. / 3)
                    groups = pyfof.friends_of_friends(pos, b)
                    w = np.array([len(x) for x in groups])
                    gbins = data_gmf_bins()
                    gmf = np.histogram(w, gbins)[0] / (1000.**3.)
                    obvs.append(gmf)
                elif obv == 'xi':
                    greek_xi = tpcf(pos,
                                    rbins,
                                    pos,
                                    randoms=randoms,
                                    period=None,
                                    max_sample_size=int(3e5),
                                    estimator='Natural',
                                    approx_cell1_size=approx_cell1_size,
                                    approx_cellran_size=approx_cellran_size,
                                    RR_precomputed=self.RR,
                                    NR_precomputed=self.NR)
                    obvs.append(greek_xi)
                else:
                    raise NotImplementedError(
                        'Only nbar 2pcf, gmf implemented so far')

            return obvs

        else:
            if np.all((prior_range[:, 0] < theta)
                      & (theta < prior_range[:, 1])):
                # if all theta_i is within prior range ...
                try:

                    self.model.populate_mock(self.halocat)
                    pos = three_dim_pos_bundle(self.model.mock.galaxy_table,
                                               'x', 'y', 'z')
                    obvs = []
                    for obv in observables:
                        if obv == 'nbar':
                            obvs.append(len(pos) /
                                        1000**3.)  # nbar of the galaxy catalog
                        elif obv == 'gmf':
                            nbar = len(pos) / 1000**3.
                            b = self.b_normal * (nbar)**(-1. / 3)
                            groups = pyfof.friends_of_friends(pos, b)
                            w = np.array([len(x) for x in groups])
                            gbins = data_gmf_bins()
                            gmf = np.histogram(w, gbins)[0] / (1000.**3.)
                            obvs.append(gmf)
                        elif obv == 'xi':
                            greek_xi = tpcf(
                                pos,
                                rbins,
                                pos,
                                randoms=randoms,
                                period=None,
                                max_sample_size=int(3e5),
                                estimator='Natural',
                                approx_cell1_size=approx_cell1_size,
                                approx_cellran_size=approx_cellran_size,
                                RR_precomputed=self.RR,
                                NR_precomputed=self.NR)
                            obvs.append(greek_xi)
                        else:
                            raise NotImplementedError(
                                'Only nbar, tpcf, and gmf are implemented so far'
                            )

                    return obvs

                except ValueError:

                    obvs = []
                    for obv in observables:
                        if obv == 'nbar':
                            obvs.append(10.)
                        elif obv == 'gmf':
                            bins = data_gmf_bins()
                            obvs.append(np.ones_like(bins)[:-1] * 1000.)
                        elif obv == 'xi':
                            obvs.append(np.zeros(len(xi_binedges()[:-1])))
                    return obvs
            else:
                obvs = []
                for obv in observables:
                    if obv == 'nbar':
                        obvs.append(10.)
                    elif obv == 'gmf':
                        bins = data_gmf_bins()
                        obvs.append(np.ones_like(bins)[:-1] * 1000.)
                    elif obv == 'xi':
                        obvs.append(np.zeros(len(xi_binedges()[:-1])))
                return obvs
Ejemplo n.º 36
0

xi_bin = np.concatenate([np.array([0.15]),
                         np.logspace(np.log10(0.5),
                                     np.log10(20.), 15)])
rmax = xi_bin.max()

# Get those randoms
num_randoms = 50 * 800000
xran = np.random.uniform(0, 1000, num_randoms)
yran = np.random.uniform(0, 1000, num_randoms)
zran = np.random.uniform(0, 1000, num_randoms)
full_randoms = np.vstack((xran, yran, zran)).T

# Get the full box mock
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname='multidark', redshift=0,
                            halo_finder='rockstar')
model.populate_mock(halocat, enforce_PBC=False)
pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

# Get full tpcf
print "getting full vol tpcf..."
xi_full_pc = tpcf(pos, xi_bin,
                  randoms=full_randoms,
                  do_auto=True, do_cross=False,
                  max_sample_size=int(pos.shape[0]),
                  estimator='Natural',
                  approx_cell1_size=[rmax, rmax, rmax],
                  approx_cellran_size=[rmax, rmax, rmax])
print "done"
Ejemplo n.º 37
0
def Subvolume_FullvolumeCut(N_sub, ratio=False): 
    ''' Test the 2PCF estimates from MultiDark subvolume versus the 
    2PCF for the entire MultiDark volume WITHOUT periodic boundary conditions
    and actual pair counts, CUT into subvolumes of the same size *AFTER*
    populate mock 


    Parameters
    ----------
    N_sub : (int)
        Number of subvolumes to sample

    '''
    prettyplot()
    pretty_colors = prettycolors()

    pickle_file = ''.join([
        '/export/bbq2/hahn/ccppabc/dump/', 
        'xi_subvolume_fullvolume_cut_test', 
        '.Nsub', str(N_sub), 
        '.p'])
    
    fig = plt.figure(1)
    sub = fig.add_subplot(111)

    xi_bin = xi_binedges() 
    
    # Entire MultiDark Volume (No Periodic Boundary Conditions) 
    model = PrebuiltHodModelFactory('zheng07', threshold=-21)
    halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')

    sub_RR = data_RR(box='md_sub')
    sub_randoms = data_random(box='md_sub')
    sub_NR = len(sub_randoms)

    rmax = xi_bin.max()
    full_approx_cell1_size = [rmax , rmax , rmax]
    full_approx_cellran_size = [rmax , rmax , rmax]

    model.populate_mock(halocat, enforce_PBC=False)
    subvol_id = util.mk_id_column(table=model.mock.galaxy_table)
    full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    
    # Full Volume 
    if os.path.isfile(pickle_file):
        data_dump = pickle.load(open(pickle_file, 'rb'))
        full_xi = data_dump['full_xi']
    else: 
        model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')

        full_randoms = data_random(box='md_all')
        full_RR = data_RR(box='md_all')
        full_NR = len(full_randoms)

        rmax = xi_bin.max()
        full_approx_cell1_size = [rmax , rmax , rmax]
        full_approx_cellran_size = [rmax , rmax , rmax]

        model.populate_mock(halocat, enforce_PBC=False)
        full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
        
        full_xi = tpcf(
                full_pos, xi_bin, 
                randoms=full_randoms, period=None, 
                do_auto=True,
                do_cross=False, 
                num_threads=5, 
                max_sample_size=int(full_pos.shape[0]), estimator='Natural', 
                approx_cell1_size=full_approx_cell1_size, 
                approx_cellran_size=full_approx_cellran_size,
                RR_precomputed = full_RR,
                NR_precomputed = full_NR)
        data_dump = {} 
        data_dump['full_xi'] = full_xi
    
    if not ratio:  
        sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), full_xi, 
                lw=2, ls='-', c='k', label=r'Full Volume') 

    if os.path.isfile(pickle_file):
        fullcut_xi_list = data_dump['fullcut_xi']['fullcut_xi_list']
        fullcut_xi_avg =  data_dump['fullcut_xi']['fullcut_xi_avg']
    else: 
        data_dump['fullcut_xi'] = {}
        fullcut_xi_list = [] 
        fullcut_xi_tot = np.zeros(len(xi_bin)-1)
        for id in np.unique(subvol_id)[:N_sub]: 
            print 'Subvolume ', id
            in_cut = np.where(subvol_id == id) 

            fullcut_pos = full_pos[in_cut]

            fullcut_xi = tpcf(
                    fullcut_pos, xi_bin, 
                    randoms=sub_randoms, period=None, 
                    do_auto=True,
                    do_cross=False, 
                    num_threads=5, 
                    max_sample_size=int(fullcut_pos.shape[0]), estimator='Natural', 
                    approx_cell1_size=full_approx_cell1_size, 
                    approx_cellran_size=full_approx_cellran_size,
                    RR_precomputed=sub_RR,
                    NR_precomputed=sub_NR)

            fullcut_xi_list.append(fullcut_xi)
            fullcut_xi_tot += fullcut_xi
        
        fullcut_xi_avg = fullcut_xi_tot / np.float(N_sub)
        data_dump['fullcut_xi']['fullcut_xi_list']= fullcut_xi_list
        data_dump['fullcut_xi']['fullcut_xi_avg']= fullcut_xi_avg

    if not ratio:  
        sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), fullcut_xi_avg, 
                lw=2, ls='-', c='k', label=r'Full Volume Cut Average') 
    else: 
        sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), fullcut_xi_avg/full_xi, 
                lw=2, ls='-', c='k', label=r'Full Volume Cut Average') 
    
    if not os.path.isfile(pickle_file):
        # MultiDark SubVolume (precomputed RR pairs) 
        sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        sub_halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
        sub_RR = data_RR(box='md_sub')
        sub_randoms = data_random(box='md_sub')
        sub_NR = len(sub_randoms)
    
        
        sub_xis_list = [] 
        sub_xis = np.zeros(len(full_xi)) 

        for ii in range(1,N_sub): 
            print 'Subvolume ', ii 
            # randomly sample one of the subvolumes
            rint = ii #np.random.randint(1, 125)
            simsubvol = lambda x: util.mask_func(x, rint)
            sub_model.populate_mock(sub_halocat, masking_function=simsubvol, enforce_PBC=False)
               
            pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y', 'z')

            xi, yi , zi = util.random_shifter(rint)
            temp_randoms = sub_randoms.copy()
            temp_randoms[:,0] += xi
            temp_randoms[:,1] += yi
            temp_randoms[:,2] += zi
            
            rmax = xi_bin.max()
            sub_approx_cell1_size = [rmax , rmax , rmax]
            sub_approx_cellran_size = [rmax , rmax , rmax]

            sub_xi = tpcf(
                    pos, xi_bin,  
                    randoms=temp_randoms, 
                    period = None, 
                    do_auto=True,
                    do_cross=False, 
                    num_threads=5, 
                    max_sample_size=int(pos.shape[0]), 
                    estimator='Natural', 
                    approx_cell1_size = sub_approx_cell1_size, 
                    approx_cellran_size = sub_approx_cellran_size,
                    RR_precomputed=sub_RR,
                    NR_precomputed=sub_NR)

            label = None 
            if ii == N_sub - 1: 
                label = 'Subvolumes'
            
            sub_xis += sub_xi
            sub_xis_list.append(sub_xi)

        sub_xi_avg = sub_xis/np.float(N_sub)

        data_dump['Natural'] = {} 
        data_dump['Natural']['sub_xi_avg'] = sub_xi_avg
        data_dump['Natural']['sub_xis_list'] = sub_xis_list 
    else: 
        sub_xis_list = data_dump['Natural']['sub_xis_list']
        sub_xi_avg = data_dump['Natural']['sub_xi_avg'] 

    if not os.path.isfile(pickle_file): 
        pickle.dump(data_dump, open(pickle_file, 'wb')) 

    if not ratio: 
        sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg, 
                lw=2, ls='--', c=pretty_colors[3], label='Subvolume')
    else: 
        sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg/full_xi, 
                lw=2, ls='--', c=pretty_colors[3], label='Subvolume')

    sub.set_xlim([0.1, 50.])
    sub.set_xlabel('r', fontsize=30)
    sub.set_xscale('log')
    
    if not ratio: 
        sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
        sub.set_yscale('log')
    else: 
        sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$", fontsize=25)

    sub.legend(loc='lower left')
    
    if ratio: 
        fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub', str(N_sub), '.ratio.png'])
    else:
        fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub', str(N_sub), '.png'])
    fig.savefig(fig_file, bbox_inches='tight', dpi=100)
    plt.close()
    return None 
        d['mean_occupation_centrals_assembias_param1'] = chain['Acen'][idx_random]
        d['mean_occupation_satellites_assembias_param1'] = chain['Asat'][idx_random]
    except KeyError:
        pass
    return d


def update_param_dict(model, chain):
    new_param_dict = retrieve_random_param_dict(chain)
    for key, value in new_param_dict.iteritems():
        model.param_dict[key] = value

################################################################################
# build the two models

std_model = PrebuiltHodModelFactory('zheng07')

centrals_occupation = AssembiasZheng07Cens()
centrals_profile = TrivialPhaseSpace()
satellites_occupation = AssembiasZheng07Sats()
satellites_profile = NFWPhaseSpace()

satellites_occupation._suppress_repeated_param_warning = True

model_dict = ({'centrals_occupation': centrals_occupation,
    'centrals_profile': centrals_profile,
    'satellites_occupation': satellites_occupation,
    'satellites_profile': satellites_profile})
ab_model = HodModelFactory(**model_dict)

################################################################################
Ejemplo n.º 39
0
def build_MCMC_cov_nbar_xi_gmf(Mr=21, b_normal=0.25):
    ''' Build covariance matrix used in MCMC for the full nbar, xi, gmf data vector
    using realisations of galaxy mocks for "data" HOD parameters in the 
    halos from the other subvolumes (subvolume 1 to subvolume 125) of
    the simulation. Covariance matrices for different sets of observables
    can be extracted from the full covariance matrix by slicing through 
    the indices. 

    '''
    nbars = []
    xir = []
    gmfs = []

    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname='multidark',
                                redshift=0,
                                halo_finder='rockstar')
    ###model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}

    #some settings for tpcf calculations
    rbins = xi_binedges()
    rmax = rbins.max()
    approx_cell1_size = [rmax, rmax, rmax]
    approx_cellran_size = [rmax, rmax, rmax]

    #load randoms and RRs

    randoms = data_random(box='md_sub')
    RR = data_RR(box='md_sub')
    NR = len(randoms)

    for i in xrange(1, 125):
        print 'mock#', i

        # populate the mock subvolume
        ###mocksubvol = lambda x: util.mask_func(x, i)
        ###model.populate_mock(halocat,
        ###                    masking_function=mocksubvol,
        ###                    enforce_PBC=False)
        model.populate_mock(halocat)
        # returning the positions of galaxies in the entire volume
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
        # masking out the galaxies outside the subvolume i
        pos = util.mask_galaxy_table(pos, i)
        # calculate nbar
        print "shape of pos", pos.shape
        nbars.append(len(pos) / 200**3.)
        # translate the positions of randoms to the new subbox
        xi0, yi0, zi0 = util.random_shifter(i)
        temp_randoms = randoms.copy()
        temp_randoms[:, 0] += xi0
        temp_randoms[:, 1] += yi0
        temp_randoms[:, 2] += zi0
        #calculate xi(r)
        xi = tpcf(pos,
                  rbins,
                  pos,
                  randoms=temp_randoms,
                  period=None,
                  max_sample_size=int(3e5),
                  estimator='Natural',
                  approx_cell1_size=approx_cell1_size,
                  approx_cellran_size=approx_cellran_size,
                  RR_precomputed=RR,
                  NR_precomputed=NR)
        xir.append(xi)
        # calculate gmf

        nbar = len(pos) / 200**3.
        b = b_normal * (nbar)**(-1. / 3)
        groups = pyfof.friends_of_friends(pos, b)
        w = np.array([len(x) for x in groups])
        gbins = gmf_bins()
        gmf = np.histogram(w, gbins)[0] / 200.**3.
        gmfs.append(gmf)

    # save nbar variance
    nbar_var = np.var(nbars, axis=0, ddof=1)
    nbar_file = ''.join([util.obvs_dir(), 'nbar_var.Mr', str(Mr), '.dat'])
    np.savetxt(nbar_file, [nbar_var])

    # write full covariance matrix of various combinations of the data
    # and invert for the likelihood evaluations

    # --- covariance for all three ---
    fulldatarr = np.hstack(
        (np.array(nbars).reshape(len(nbars),
                                 1), np.array(xir), np.array(gmfs)))
    fullcov = np.cov(fulldatarr.T)
    fullcorr = np.corrcoef(fulldatarr.T)

    # and save the covariance matrix
    nopoisson_file = ''.join([
        util.obvs_dir(), 'MCMC.nbar_xi_gmf_cov', '.no_poisson', '.Mr',
        str(Mr), '.bnorm',
        str(round(b_normal, 2)), '.dat'
    ])
    np.savetxt(nopoisson_file, fullcov)
    return None
Ejemplo n.º 40
0
class ABC_HODsim(object):
    def __init__(self, Mr=21, b_normal=0.25):
        ''' Class object that describes our forward model used in AMC-PMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        ####self.model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        self.halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
        self.RR = data_RR(box='md_sub')
        self.randoms = data_random(box='md_sub')
        self.NR = len(self.randoms)

    def __call__(self, theta, prior_range=None, observables=['nbar', 'gmf']):
        return self._sum_stat(theta, prior_range=prior_range, observables=observables)

    def _sum_stat(self, theta, prior_range=None, observables=['nbar', 'gmf']):
        '''
        Given theta, sum_stat calculates the observables from our forward model

        Parameters
        ----------
        theta : (self explanatory)
        prior_range : If specified, checks to make sure that theta is within the prior range.
        '''
        self.model.param_dict['logM0'] = theta[0]
        self.model.param_dict['sigma_logM'] = np.exp(theta[1])
        self.model.param_dict['logMmin'] = theta[2]
        self.model.param_dict['alpha'] = theta[3]
        self.model.param_dict['logM1'] = theta[4]

        rbins = xi_binedges()
        rmax = rbins.max()
        period = None
        approx_cell1_size = [rmax , rmax , rmax]
        approx_cellran_size = [rmax , rmax , rmax]

        if prior_range is None:
            rint = np.random.randint(1, 125)
            ####simsubvol = lambda x: util.mask_func(x, rint)
            ####self.model.populate_mock(self.halocat,
            ####                masking_function=simsubvol,
            ####                enforce_PBC=False)
            self.model.populate_mock(self.halocat)
                        
            pos =three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y', 'z')
            pos = util.mask_galaxy_table(pos , rint) 

            xi , yi , zi = util.random_shifter(rint)
            temp_randoms = self.randoms.copy()
            temp_randoms[:,0] += xi
            temp_randoms[:,1] += yi
            temp_randoms[:,2] += zi

            obvs = []
            for obv in observables:
                if obv == 'nbar':
                    obvs.append(len(pos) / 200**3.)       # nbar of the galaxy catalog
                elif obv == 'gmf':
                    #compute group richness 
                    nbar = len(pos) / 200**3.
    		    b = self.b_normal * (nbar)**(-1./3) 
    		    groups = pyfof.friends_of_friends(pos , b)
    		    w = np.array([len(x) for x in groups])
    		    gbins = data_gmf_bins()
    		    gmf = np.histogram(w , gbins)[0] / (200.**3.)
                    obvs.append(gmf)   
                elif obv == 'xi':
                    greek_xi = tpcf(
                        pos, rbins, pos, 
                        randoms=temp_randoms, period = period, 
                        max_sample_size=int(1e5), estimator='Natural', 
                        approx_cell1_size=approx_cell1_size, 
                        approx_cellran_size=approx_cellran_size,
                        RR_precomputed = self.RR,
	                NR_precomputed = self.NR)

                    obvs.append(greek_xi)
                else:
                    raise NotImplementedError('Only nbar 2pcf, gmf implemented so far')

            return obvs

        else:
            if np.all((prior_range[:,0] < theta) & (theta < prior_range[:,1])):
                # if all theta_i is within prior range ...
                try:
                    rint = np.random.randint(1, 125)
                    simsubvol = lambda x: util.mask_func(x, rint)
                    self.model.populate_mock(self.halocat,
                                masking_function=simsubvol,
                                enforce_PBC=False)
           
                    pos =three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y', 'z')
                    #imposing mask on the galaxy table
                    pos = util.mask_galaxy_table(pos , rint) 
            	    xi , yi , zi = util.random_shifter(rint)
            	    temp_randoms = self.randoms.copy()
            	    temp_randoms[:,0] += xi
            	    temp_randoms[:,1] += yi
            	    temp_randoms[:,2] += zi
            	    obvs = []

            	    for obv in observables:
                        if obv == 'nbar':
                    	    obvs.append(len(pos) / 200**3.)       # nbar of the galaxy catalog
                        elif obv == 'gmf':
                            nbar = len(pos) / 200**3.
    		            b = self.b_normal * (nbar)**(-1./3) 
    		            groups = pyfof.friends_of_friends(pos , b)
    		            w = np.array([len(x) for x in groups])
    		    	    gbins =data_gmf_bins()
    		            gmf = np.histogram(w , gbins)[0] / (200.**3.)
                    	    obvs.append(gmf)   
                        elif obv == 'xi':
                    	    greek_xi = tpcf(
                                     pos, rbins, pos, 
                        	     randoms=temp_randoms, period = period, 
                                     max_sample_size=int(1e5), estimator='Natural', 
                                     approx_cell1_size=approx_cell1_size, 
                                     approx_cellran_size=approx_cellran_size,
                                     RR_precomputed = self.RR,
	                             NR_precomputed = self.NR)

                    	    obvs.append(greek_xi)
                        else:
                            raise NotImplementedError('Only nbar, tpcf, and gmf are implemented so far')

                    return obvs

                except ValueError:

                    obvs = []
                    for obv in observables:
                        if obv == 'nbar':
                            obvs.append(10.)
                        elif obv == 'gmf':
                            bins = data_gmf_bins()
                            obvs.append(np.ones_like(bins)[:-1]*1000.)
                        elif obv == 'xi':
                            obvs.append(np.zeros(len(xi_binedges()[:-1])))
                    return obvs
            else:
                obvs = []
                for obv in observables:
                    if obv == 'nbar':
                        obvs.append(10.)
                    elif obv == 'gmf':
                        bins = data_gmf_bins()
                        obvs.append(np.ones_like(bins)[:-1]*1000.)
                    elif obv == 'xi':
                        obvs.append(np.zeros(len(xi_binedges()[:-1])))
                return obvs
Ejemplo n.º 41
0
pbins = np.logspace(-1, 1.25, 15)



def proj_clustering(pos , rbins, pbins , cellsize):

    return wp(sample1 = pos, rp_bins = rbins, 
              pi_bins = pbins, sample2 = None, 
              period = np.array([250,250,250]), approx_cell1_size = cellsize)


from halotools.empirical_models import PrebuiltHodModelFactory

# The "fiducial" stellar mass threshold is 10**10.5
model = PrebuiltHodModelFactory('hearin15', threshold = 10.5, redshift = 0., 
                        central_assembias_strength = 1, 
                        satellite_assembias_strength = 1)
model.param_dict['scatter_model_param1'] = 0.4 # This is the "fiducial" scatter used throughout the paper

baseline_model = PrebuiltHodModelFactory('leauthaud11', threshold = 10.5, redshift = 0.)
baseline_model.param_dict['scatter_model_param1'] = 0.4

#base_model

baseline_model.populate_mock()
pos = three_dim_pos_bundle(baseline_model.mock.galaxy_table, 'x', 'y', 'z')
wp_base = proj_clustering(pos , rbins , pbins , cellsize = [rmax, rmax, rmax])


#central assembly bias only
def initialise_model(redshift, model_name='zheng07'):

    print('Initialising HOD model: {}...'.format(model_name))

    # Default is ‘halo_mvir’
    if model_name == 'zheng07':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=redshift,
                                        threshold=-18,
                                        prim_haloprop_key=halo_m_prop)
        model.param_dict['logMmin'] = 13.3
        model.param_dict['sigma_logM'] = 0.8
        model.param_dict['alpha'] = 1
        model.param_dict['logM0'] = 13.3
        model.param_dict['logM1'] = 13.8

    elif model_name == 'leauthaud11':
        model = PrebuiltHodModelFactory('leauthaud11',
                                        redshift=redshift,
                                        threshold=11,
                                        prim_haloprop_key=halo_m_prop)
        model.param_dict['smhm_m0_0'] = 11.5  # 10.72
        model.param_dict['smhm_m0_a'] = 0.59
        model.param_dict['smhm_m1_0'] = 13.4  # 12.35
        model.param_dict['smhm_m1_a'] = 0.3
        model.param_dict['smhm_beta_0'] = 2  # 0.43
        model.param_dict['smhm_beta_a'] = 0.18
        model.param_dict['smhm_delta_0'] = 0.1  # 0.56
        model.param_dict['smhm_delta_a'] = 0.18
        model.param_dict['smhm_gamma_0'] = 1  # 1.54
        model.param_dict['smhm_gamma_a'] = 2.52
        model.param_dict['scatter_model_param1'] = 0.2
        model.param_dict['alphasat'] = 1
        model.param_dict['betasat'] = 1.1  # 0.859
        model.param_dict['bsat'] = 11  # 10.62
        model.param_dict['betacut'] = 6  # -0.13
        model.param_dict['bcut'] = 0.01  # 1.47

    elif model_name == 'tinker13':
        model = PrebuiltHodModelFactory(
            'tinker13',
            redshift=redshift,
            threshold=11,
            prim_haloprop_key=halo_m_prop,
            quiescent_fraction_abscissa=[1e12, 1e13, 1e14, 1e15],
            quiescent_fraction_ordinates=[0.25, 0.5, 0.75, 0.9])

        model.param_dict['smhm_m0_0_active'] = 11
        model.param_dict['smhm_m0_0_quiescent'] = 10.8
        model.param_dict['smhm_m1_0_active'] = 12.2
        model.param_dict['smhm_m1_0_quiescent'] = 11.8
        model.param_dict['smhm_beta_0_active'] = 0.44
        model.param_dict['smhm_beta_0_quiescent'] = 0.32
        # model.param_dict['alphasat_active'] = 1
        # model.param_dict['alphasat_quiescent'] = 1
        # model.param_dict['betacut_active'] = 0.77
        # model.param_dict['betacut_quiescent'] = -0.12
        # model.param_dict['bcut_active'] = 0.2
        # model.param_dict['bcut_quiescent'] = 0.2
        # model.param_dict['betasat_active'] = 1.5
        # model.param_dict['betasat_quiescent'] = 0.62
        model.param_dict['bsat_active'] = 13
        model.param_dict['bsat_quiescent'] = 8

    elif model_name == 'hearin15':
        model = PrebuiltHodModelFactory('hearin15',
                                        redshift=redshift,
                                        threshold=11)
    elif model_name == 'zu_mandelbaum15':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=redshift,
                                        threshold=-1)
    elif model_name == 'zu_mandelbaum16':
        model = PrebuiltHodModelFactory('zheng07',
                                        redshift=redshift,
                                        threshold=-1)
    elif model_name == 'cacciato09':
        model = PrebuiltHodModelFactory('cacciato09',
                                        redshift=redshift,
                                        threshold=10,
                                        prim_haloprop_key=halo_m_prop)

        model.param_dict['log_L_0'] = 9.935
        model.param_dict['log_M_1'] = 12.9  # 11.07
        model.param_dict['gamma_1'] = 0.3  # 3.273
        model.param_dict['gamma_2'] = 0.255
        model.param_dict['sigma'] = 0.143
        model.param_dict['a_1'] = 0.501
        model.param_dict['a_2'] = 2.106
        model.param_dict['log_M_2'] = 14.28
        model.param_dict['b_0'] = -0.5  # -0.766
        model.param_dict['b_1'] = 1.008
        model.param_dict['b_2'] = -0.094
        model.param_dict['delta_1'] = 0
        model.param_dict['delta_2'] = 0

    # add useful model properties here
    model.model_name = model_name  # add model_name field

    return model
Ejemplo n.º 43
0
            upper_assembias_bound = np.inf,
            **kwargs)

cens_occ_model =  AssembiasZheng07Cens(threshold = -21)
cens_prof_model = TrivialPhaseSpace()
sats_occ_model =  AssembiasZheng07Sats(threshold = -21)
sats_prof_model = NFWPhaseSpace()

model= HodModelFactory(
        centrals_occupation = cens_occ_model,
        centrals_profile = cens_prof_model,
        satellites_occupation = sats_occ_model,
        satellites_profile = sats_prof_model)

print model.param_dict
baseline_model = PrebuiltHodModelFactory("Zheng07" , threshold = -21)


############### Setting the model parameters to those of Guo 15#######
model.param_dict['logM0'] =  12.59
model.param_dict['sigma_logM'] =  0.49
model.param_dict['logMmin'] =  12.78
model.param_dict['alpha'] =  1.14
model.param_dict['logM1'] =  13.99
model.param_dict['mean_occupation_satellites_assembias_param1'] = 1.0
baseline_model.param_dict['logM0'] =  12.59
baseline_model.param_dict['sigma_logM'] =  0.49
baseline_model.param_dict['logMmin'] =  12.78
baseline_model.param_dict['alpha'] =  1.14
baseline_model.param_dict['logM1'] =  13.99
Ejemplo n.º 44
0
import numpy as np
from astropy.table import Table
import pyfof

def richness(group_id):
    '''
    Calculate the richness of a group given group_ids of galaxies. Uses astropy.table module
    '''
    gals = Table()
    gals['groupid'] = group_id
    gals['dummy'] = 1
    grouped_table = gals.group_by('groupid')
    grp_richness = grouped_table['dummy'].groups.aggregate(np.sum)

    return grp_richness
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')

model.populate_mock(halocat)
pos =three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

#groups = FoFGroups(pos, 0.75, 0.75, Lbox = model.mock.Lbox, num_threads=1)
#gids = groups.group_ids

#print richness(gids)
import time

a = time.time()

groups = pyfof.friends_of_friends(pos, 0.75*(len(pos)/1000**3.)**(-1./3))
Ejemplo n.º 45
0
def build_nbar_xi_gmf_cov(Mr=21):
    ''' Build covariance matrix for the full nbar, xi, gmf data vector
    using realisations of galaxy mocks for "data" HOD parameters in the 
    halos from the multidark simulation. Covariance matrices for different sets of observables
    can be extracted from the full covariance matrix by slicing through 
    the indices. 

    '''
    nbars = []
    xir = []
    gmfs = []

    thr = -1. * np.float(Mr)
    model = PrebuiltHodModelFactory('zheng07', threshold=thr)
    halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
    #some settings for tpcf calculations
    rbins = hardcoded_xi_bins()

    for i in xrange(1,125):
        print 'mock#', i

        # populate the mock subvolume
        model.populate_mock(halocat)
        # returning the positions of galaxies
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
        # calculate nbar
        nbars.append(len(pos) / 1000**3.)
        # translate the positions of randoms to the new subbox
        #calculate xi(r)        
        xi = tpcf(pos, rbins, period = model.mock.Lbox, 
                  max_sample_size=int(2e5), estimator='Landy-Szalay')
        xir.append(xi)
        # calculate gmf
        nbar = len(pos) / 1000**3.
        b_normal = 0.75
        b = b_normal * (nbar)**(-1./3) 
        groups = pyfof.friends_of_friends(pos , b)
        w = np.array([len(x) for x in groups])
        gbins = gmf_bins()
        gmf = np.histogram(w , gbins)[0] / (1000.**3.)
        gmfs.append(gmf)  # GMF
    # save nbar variance
    nbar_var = np.var(nbars, axis=0, ddof=1)
    nbar_file = ''.join([util.multidat_dir(), 'abc_nbar_var.Mr', str(Mr), '.dat'])
    np.savetxt(nbar_file, [nbar_var])


    # write full covariance matrix of various combinations of the data
    # and invert for the likelihood evaluations

    # --- covariance for all three ---
    fulldatarr = np.hstack((np.array(nbars).reshape(len(nbars), 1),
                            np.array(xir),
                            np.array(gmfs)))
    fullcov = np.cov(fulldatarr.T)
    fullcorr = np.corrcoef(fulldatarr.T)
    # and save the covariance matrix
    nopoisson_file = ''.join([util.multidat_dir(), 'abc_nbar_xi_gmf_cov.no_poisson.Mr', str(Mr), '.dat'])
    np.savetxt(nopoisson_file, fullcov)

    # and a correlation matrix
    full_corr_file = ''.join([util.multidat_dir(), 'abc_nbar_xi_gmf_corr.Mr', str(Mr), '.dat'])
    np.savetxt(full_corr_file, fullcorr)

    return None
Ejemplo n.º 46
0
class MCMC_HODsim(object):
    def __init__(self, Mr=21, b_normal=0.25):
        ''' Class object that describes our forward model used in MCMC inference.
        Our model forward models the galaxy catalog using HOD parameters using HaloTools.
        '''
        self.Mr = Mr
        self.b_normal = b_normal
        thr = -1. * np.float(Mr)

        self.model = PrebuiltHodModelFactory('zheng07', threshold=thr)
        self.halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')

        ##self.RR = data_RR(box='md_all')
        ##self.randoms = data_random('md_all')
        ##self.NR = len(self.randoms)
    
    def __call__(self, theta, prior_range=None, observables=['nbar', 'gmf']):
        return self._sum_stat(theta, prior_range=prior_range, observables=observables)

    def _sum_stat(self, theta, prior_range=None, observables=['nbar', 'gmf']):
        '''
        Given theta, sum_stat calculates the observables from our forward model

        Parameters
        ----------
        theta : (self explanatory)
        prior_range : If specified, checks to make sure that theta is within the prior range.
        '''
        self.model.param_dict['logM0'] = theta[0]
        self.model.param_dict['sigma_logM'] = np.exp(theta[1])
        self.model.param_dict['logMmin'] = theta[2]
        self.model.param_dict['alpha'] = theta[3]
        self.model.param_dict['logM1'] = theta[4]

        rbins = xi_binedges()
        rmax = rbins.max()
        approx_cell1_size = [rmax , rmax , rmax]
        approx_cellran_size = [rmax , rmax , rmax]

        if prior_range is None:
            
            self.model.populate_mock(self.halocat)
            pos =three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y', 'z')
            obvs = []

            for obv in observables:
                if obv == 'nbar':
                    obvs.append(len(pos) / 1000.**3.)       # nbar of the galaxy catalog
                elif obv == 'gmf':
                    nbar = len(pos) / 1000**3.
    		    b = self.b_normal * (nbar)**(-1./3) 
    		    groups = pyfof.friends_of_friends(pos , b)
    		    w = np.array([len(x) for x in groups])
    		    gbins =data_gmf_bins()
    		    gmf = np.histogram(w , gbins)[0] / (1000.**3.)
                    obvs.append(gmf)   
                elif obv == 'xi':
                    greek_xi = tpcf(
                            pos, rbins,  
                            period=self.model.mock.Lbox, 
                            max_sample_size=int(3e5), estimator='Natural', 
                            approx_cell1_size=approx_cell1_size)
                    obvs.append(greek_xi)
                else:
                    raise NotImplementedError('Only nbar 2pcf, gmf implemented so far')

            return obvs

        else:
            if np.all((prior_range[:,0] < theta) & (theta < prior_range[:,1])):
                # if all theta_i is within prior range ...
                try:


                    self.model.populate_mock(self.halocat) 
                    pos=three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y', 'z')
            	    obvs = []
            	    for obv in observables:
                        if obv == 'nbar':
                    	    obvs.append(len(pos) / 1000**3.)       # nbar of the galaxy catalog
                        elif obv == 'gmf':
                    	    nbar = len(pos) / 1000**3.
    		    	    b = self.b_normal * (nbar)**(-1./3) 
    		    	    groups = pyfof.friends_of_friends(pos , b)
    		    	    w = np.array([len(x) for x in groups])
    		    	    gbins =data_gmf_bins()
    		    	    gmf = np.histogram(w , gbins)[0] / (1000.**3.)
                    	    obvs.append(gmf)   
                        elif obv == 'xi':
                            greek_xi = tpcf(
                                    pos, rbins, period=self.model.mock.Lbox, 
                                    max_sample_size=int(3e5), estimator='Natural', 
                                    approx_cell1_size=approx_cell1_size)
                            obvs.append(greek_xi)
                        else:
                            raise NotImplementedError('Only nbar, tpcf, and gmf are implemented so far')

                    return obvs

                except ValueError:

                    obvs = []
                    for obv in observables:
                        if obv == 'nbar':
                            obvs.append(10.)
                        elif obv == 'gmf':
                            bins = data_gmf_bins()
                            obvs.append(np.ones_like(bins)[:-1]*1000.)
                        elif obv == 'xi':
                            obvs.append(np.zeros(len(xi_binedges()[:-1])))
                    return obvs
            else:
                obvs = []
                for obv in observables:
                    if obv == 'nbar':
                        obvs.append(10.)
                    elif obv == 'gmf':
                        bins = data_gmf_bins()
                        obvs.append(np.ones_like(bins)[:-1]*1000.)
                    elif obv == 'xi':
                        obvs.append(np.zeros(len(xi_binedges()[:-1])))
                return obvs
Ejemplo n.º 47
0
def build_xi_nbar_gmf_cov(Mr=21, Nmock=500):
    '''
    Build covariance matrix for xi, variance for nbar, and a bunch of stuff for gmf
    ...
    using Nmock realizations of halotool mocks
    '''
    xir = []
    model = PrebuiltHodModelFactory('zheng07', threshold = -1.0*np.float(Mr))
    #nbars = []
    #gmfs = []
    #gmf_counts = []
    for i in xrange(Nmock):
        print 'mock#', i
        model.populate_mock()

        # xi(r)
        xir.append(model.mock.compute_galaxy_clustering(rbins=hardcoded_xi_bins())[1])
        # nbar
        #nbars.append(model.mock.number_density)
        # gmf
        #rich = richness(model.mock.compute_fof_group_ids())
        #gmfs.append(GMF(rich))  # GMF
        #gmf_counts.append(GMF(rich, counts=True))   # Group counts

    # save xi covariance
    xi_covar = np.cov(np.array(xir).T)
    output_file = ''.join([util.dat_dir(), 'xir_covariance.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    np.savetxt(output_file, xi_covar)

    # save nbar values
    #nbar_cov = np.var(nbars, axis=0)
    #output_file = ''.join([util.dat_dir(), 'nbar_cov.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(output_file, [nbar_cov])

    # write GMF covariance
    #gmf_cov = np.cov(np.array(gmfs).T)
    #output_file = ''.join([util.dat_dir(), 'gmf_cov.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(output_file, gmf_cov)
    # write GMF Poisson
    #gmf_counts_mean = np.mean(gmf_counts, axis=0)
    #poisson_gmf = np.sqrt(gmf_counts_mean) / 250.**3    # poisson errors
    #output_file = ''.join([util.dat_dir(), 'gmf_sigma_poisson.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(output_file, poisson_gmf)
    # write GMF standard dev
    #sigma_gmf = np.std(gmfs, axis=0)                    # sample variance
    #output_file = ''.join([util.dat_dir(), 'gmf_sigma_stddev.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(output_file, sigma_gmf)
    # write GMF total noise
    #sigma_tot = (sigma_gmf**2 + poisson_gmf**2)**0.5    # total sigma
    #output_file = ''.join([util.dat_dir(), 'gmf_sigma.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(output_file, sigma_tot)

    # write full covariance matrix of various combinations of the data

    # covariance for all three
    #fulldatarr = np.hstack(np.array(nbars).reshape(nbars.shape[0], 1),
    #                       np.array(gmfs), np.array(xir))

    #fullcov = np.cov(fulldatarr.T)
    #outfn = ''.join([util.dat_dir(), 'nbar_gmf_xir_cov.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(outfn, fullcov)

    # covariance for nbar and gmf
    ##nbgmf_arr = np.hstack(np.array(nbars).reshape(nbars.shape[0], 1),
    #                     np.array(gmfs))
    #nbgmf_cov = np.cov(nbgmf_arr.T)
    #outfn = ''.join([util.dat_dir(), 'nbar_gmf_cov.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(outfn, nbgmf_cov)

    # covariance for nbar and xi
    #nbxi_arr = np.hstack(np.array(nbars).reshape(nbars.shape[0], 1),
    #                     np.array(xir))
    #nbxi_cov = np.cov(nbxi_arr.T)
    #outfn = ''.join([util.dat_dir(), 'nbar_xi_cov.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(outfn, nbxi_cov)

    # covariance for gmf and xi
    #gmfxi_arr = np.hstack(np.array(gmfs), np.array(xir))
    #gmfxi_cov = np.cov(gmfxi_arr.T)
    #outfn = ''.join([util.dat_dir(), 'gmf_xi_cov.Mr', str(Mr), '.Nmock', str(Nmock), '.dat'])
    #np.savetxt(outfn, gmfxi_cov)

    return None
Ejemplo n.º 48
0
def test_precomputed_rr(Nr, Mr = 21):
    '''
    Mr = Luminositty threshold
    Nr = Number of randoms
    '''

    rbins = np.logspace(-1, 1.25, 15)
    rmax = rbins.max()
    rbin_centers = (rbins[1:] + rbins[0:-1])/2.    

    halocat = CachedHaloCatalog(simname = 'bolshoi', redshift = 0)
    model = PrebuiltHodModelFactory("zheng07")
    model.populate_mock(halocat = halocat, enforce_PBC = False)
    data = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    print data.shape
    L = halocat.Lbox

    xmin , ymin , zmin = 0., 0., 0.
    xmax , ymax , zmax = L, L, L
   
    
    num_randoms = Nr
    xran = np.random.uniform(xmin, xmax, num_randoms)
    yran = np.random.uniform(ymin, ymax, num_randoms)
    zran = np.random.uniform(zmin, zmax, num_randoms)
    randoms = np.vstack((xran, yran, zran)).T
    

    verbose = False
    num_threads = cpu_count()

    period = None
    approx_cell1_size = [rmax, rmax, rmax]
    approx_cell2_size = approx_cell1_size
    approx_cellran_size = [rmax, rmax, rmax]

    normal_result = tpcf(
            data, rbins, data, 
            randoms=randoms, period = period, 
            max_sample_size=int(1e4), estimator='Landy-Szalay', 
            approx_cell1_size=approx_cell1_size, 
            approx_cellran_size=approx_cellran_size)


    #count data pairs
    DD = npairs(
            data, data, rbins, period,
            verbose, num_threads,
            approx_cell1_size, approx_cell2_size)
    DD = np.diff(DD)
    #count random pairs
    RR = npairs(
            randoms, randoms, rbins, period,
            verbose, num_threads,
            approx_cellran_size, approx_cellran_size)
    RR = np.diff(RR)
    #count data random pairs 
    DR = npairs(
            data, randoms, rbins, period,
            verbose, num_threads,
            approx_cell1_size, approx_cell2_size)
    DR = np.diff(DR)

    print "DD=", DD
    print "DR=", DR
    print "RR=", RR        
    
    ND = len(data)
    NR = len(randoms)

    factor1 = ND*ND/(NR*NR)
    factor2 = ND*NR/(NR*NR)

    mult = lambda x,y: x*y
    xi_LS = mult(1.0/factor1,DD/RR) - mult(1.0/factor2,2.0*DR/RR) + 1.0

    print "xi=" , xi_LS
    print "normal=" , normal_result

    result_with_RR_precomputed = tpcf(
            data, rbins, data, 
            randoms=randoms, period = period, 
            max_sample_size=int(1e5), estimator='Landy-Szalay', 
            approx_cell1_size=approx_cell1_size, 
            approx_cellran_size=approx_cellran_size, 
            RR_precomputed = RR, 
            NR_precomputed = NR)
    
    print "xi_pre=" , result_with_RR_precomputed
Ejemplo n.º 49
0
def test_precomputed_rr(Nr, Mr=21):
    '''
    Mr = Luminositty threshold
    Nr = Number of randoms
    '''

    rbins = np.logspace(-1, 1.25, 15)
    rmax = rbins.max()
    rbin_centers = (rbins[1:] + rbins[0:-1]) / 2.

    halocat = CachedHaloCatalog(simname='bolshoi', redshift=0)
    model = PrebuiltHodModelFactory("zheng07")
    model.populate_mock(halocat=halocat, enforce_PBC=False)
    data = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
    print data.shape
    L = halocat.Lbox

    xmin, ymin, zmin = 0., 0., 0.
    xmax, ymax, zmax = L, L, L

    num_randoms = Nr
    xran = np.random.uniform(xmin, xmax, num_randoms)
    yran = np.random.uniform(ymin, ymax, num_randoms)
    zran = np.random.uniform(zmin, zmax, num_randoms)
    randoms = np.vstack((xran, yran, zran)).T

    verbose = False
    num_threads = cpu_count()

    period = None
    approx_cell1_size = [rmax, rmax, rmax]
    approx_cell2_size = approx_cell1_size
    approx_cellran_size = [rmax, rmax, rmax]

    normal_result = tpcf(data,
                         rbins,
                         data,
                         randoms=randoms,
                         period=period,
                         max_sample_size=int(1e4),
                         estimator='Landy-Szalay',
                         approx_cell1_size=approx_cell1_size,
                         approx_cellran_size=approx_cellran_size)

    #count data pairs
    DD = npairs(data, data, rbins, period, verbose, num_threads,
                approx_cell1_size, approx_cell2_size)
    DD = np.diff(DD)
    #count random pairs
    RR = npairs(randoms, randoms, rbins, period, verbose, num_threads,
                approx_cellran_size, approx_cellran_size)
    RR = np.diff(RR)
    #count data random pairs
    DR = npairs(data, randoms, rbins, period, verbose, num_threads,
                approx_cell1_size, approx_cell2_size)
    DR = np.diff(DR)

    print "DD=", DD
    print "DR=", DR
    print "RR=", RR

    ND = len(data)
    NR = len(randoms)

    factor1 = ND * ND / (NR * NR)
    factor2 = ND * NR / (NR * NR)

    mult = lambda x, y: x * y
    xi_LS = mult(1.0 / factor1, DD / RR) - mult(1.0 / factor2,
                                                2.0 * DR / RR) + 1.0

    print "xi=", xi_LS
    print "normal=", normal_result

    result_with_RR_precomputed = tpcf(data,
                                      rbins,
                                      data,
                                      randoms=randoms,
                                      period=period,
                                      max_sample_size=int(1e5),
                                      estimator='Landy-Szalay',
                                      approx_cell1_size=approx_cell1_size,
                                      approx_cellran_size=approx_cellran_size,
                                      RR_precomputed=RR,
                                      NR_precomputed=NR)

    print "xi_pre=", result_with_RR_precomputed
Ejemplo n.º 50
0
def Subvolume_Analytic(N_sub, ratio=False):
    ''' Test the 2PCF estimates from MultiDark subvolume versus the 
    analytic 2PCF for the entire MultiDark volume

    Parameters
    ----------
    N_sub : (int)
        Number of subvolumes to sample

    '''
    prettyplot()
    pretty_colors = prettycolors()

    pickle_file = ''.join([
        '/export/bbq2/hahn/ccppabc/dump/', 'xi_subvolume_test', '.Nsub',
        str(N_sub), '.p'
    ])

    fig = plt.figure(1)
    sub = fig.add_subplot(111)

    xi_bin = xi_binedges()

    if os.path.isfile(pickle_file):
        data_dump = pickle.load(open(pickle_file, 'rb'))
        full_xi = data_dump['full_xi']
    else:
        # Entire MultiDark Volume (Analytic xi)
        model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        halocat = CachedHaloCatalog(simname='multidark',
                                    redshift=0,
                                    halo_finder='rockstar')

        model.populate_mock(halocat)
        pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')

        # while the estimator claims to be Landy-Szalay, I highly suspect it
        # actually uses Landy-Szalay since DR pairs cannot be calculated from
        # analytic randoms
        full_xi = tpcf(pos,
                       xi_bin,
                       period=model.mock.Lbox,
                       max_sample_size=int(2e5),
                       estimator='Landy-Szalay',
                       num_threads=1)
        data_dump = {}
        data_dump['full_xi'] = full_xi

    if not ratio:
        sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                 full_xi,
                 lw=2,
                 ls='-',
                 c='k',
                 label=r'Analytic $\xi$ Entire Volume')

    if not os.path.isfile(pickle_file):
        # MultiDark SubVolume (precomputed RR pairs)
        sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
        sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
        sub_halocat = CachedHaloCatalog(simname='multidark',
                                        redshift=0,
                                        halo_finder='rockstar')
        RR = data_RR()
        randoms = data_random()
        NR = len(randoms)

    for method in ['Landy-Szalay', 'Natural']:

        if method == 'Landy-Szalay':
            iii = 3
        elif method == 'Natural':
            iii = 5

        if not os.path.isfile(pickle_file):
            sub_xis_list = []
            sub_xis = np.zeros(len(full_xi))

            for ii in range(1, N_sub + 1):
                # randomly sample one of the subvolumes
                rint = ii  #np.random.randint(1, 125)
                simsubvol = lambda x: util.mask_func(x, rint)
                sub_model.populate_mock(sub_halocat,
                                        masking_function=simsubvol,
                                        enforce_PBC=False)

                pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x',
                                           'y', 'z')

                xi, yi, zi = util.random_shifter(rint)
                temp_randoms = randoms.copy()
                temp_randoms[:, 0] += xi
                temp_randoms[:, 1] += yi
                temp_randoms[:, 2] += zi

                rmax = xi_bin.max()
                approx_cell1_size = [rmax, rmax, rmax]
                approx_cellran_size = [rmax, rmax, rmax]

                sub_xi = tpcf(pos,
                              xi_bin,
                              pos,
                              randoms=temp_randoms,
                              period=None,
                              max_sample_size=int(1e5),
                              estimator=method,
                              approx_cell1_size=approx_cell1_size,
                              approx_cellran_size=approx_cellran_size,
                              RR_precomputed=RR,
                              NR_precomputed=NR)
                label = None
                if ii == N_sub - 1:
                    label = 'Subvolumes'

                #if not ratio:
                #    sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi, lw=0.5, ls='--', c=pretty_colors[iii])
                sub_xis += sub_xi
                sub_xis_list.append(sub_xi)

            sub_xi_avg = sub_xis / np.float(N_sub)

            data_dump[method] = {}
            data_dump[method]['sub_xi_avg'] = sub_xi_avg
            data_dump[method]['sub_xis_list'] = sub_xis_list
        else:
            sub_xis_list = data_dump[method]['sub_xis_list']
            sub_xi_avg = data_dump[method]['sub_xi_avg']

        if not ratio:
            sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                     sub_xi_avg,
                     lw=2,
                     ls='--',
                     c=pretty_colors[iii],
                     label='Subvolume ' + method)
        else:
            sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
                     sub_xi_avg / full_xi,
                     lw=2,
                     ls='--',
                     c=pretty_colors[iii],
                     label='Subvolume ' + method)

    if not os.path.isfile(pickle_file):
        pickle.dump(data_dump, open(pickle_file, 'wb'))

    sub.set_xlim([0.1, 50.])
    sub.set_xlabel('r', fontsize=30)
    sub.set_xscale('log')

    if not ratio:
        sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
        sub.set_yscale('log')
    else:
        sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$",
                       fontsize=25)

    sub.legend(loc='lower left')

    if ratio:
        fig_file = ''.join([
            util.fig_dir(), 'test_xi_subvolume_analytic.Nsub',
            str(N_sub), '.ratio.png'
        ])
    else:
        fig_file = ''.join([
            util.fig_dir(), 'test_xi_subvolume_analytic.Nsub',
            str(N_sub), '.png'
        ])
    fig.savefig(fig_file, bbox_inches='tight', dpi=100)
    plt.close()
    return None