def _galCorr(cat, scale_factor, outputdir): 'Helper function that uses the built in cat object' h = 0.7 RBINS = np.logspace(-1, 1.25, 15) redshift = 1.0/scale_factor - 1.0 print cat if outputdir[-1] != '/': outputdir+='/' #Note: Confusing name between cat and halocat. Consider changing. halocat = CachedHaloCatalog(simname = cat.simname, halo_finder = cat.halo_finder,version_name = cat.version_name, redshift = redshift) model = HodModelFactory( centrals_occupation=StepFuncCens(redshift=redshift), centrals_profile=TrivialPhaseSpace(redshift=redshift), satellites_occupation=StepFuncSats(redshift=redshift), satellites_profile=NFWPhaseSpace(redshift=redshift)) model.populate_mock(halocat, Num_ptcl_requirement = 30) #Now, calculate with Halotools builtin #TODO include the fast version x, y, z = [model.mock.galaxy_table[c] for c in ['x','y','z'] ] pos = return_xyz_formatted_array(x,y,z) #TODO N procs xi_all = tpcf(pos*h, RBINS, period = model.mock.Lbox*h, num_threads = cpu_count()) np.savetxt(outputdir + 'xi_all_gal_%.3f_h.npy' %(scale_factor), xi_all)
def __init__(self, config): super().__init__(config) self.cur_wp = np.zeros(11) if self['sim'] == "bolplanck": halocat = CachedHaloCatalog(simname='bolplanck') elif self['sim'] == "old": halocat = CachedHaloCatalog( fname='/home/lom31/Halo/hlist_1.00231.list.halotools_v0p1.hdf5', update_cached_fname=True) halocat.redshift = 0. elif self['sim'] == "smdpl": halocat = CachedHaloCatalog( fname= '/home/lom31/.astropy/cache/halotools/halo_catalogs/SMDPL/rockstar/2019-07-03-18-38-02-9731.dat.my_cosmosim_halos.hdf5', update_cached_fname=True) #halocat = CachedHaloCatalog(fname='/home/lom31/.astropy/cache/halotools/halo_catalogs/smdpl/rockstar/2019-07-03-18-38-02-9731.dat.my_cosmosim_halos.hdf5',update_cached_fname = True) halocat.redshift = 0. elif self['sim'] == "mdr1": halocat = CachedHaloCatalog( fname= '/home/lom31/.astropy/cache/halotools/halo_catalogs/multidark/rockstar/hlist_0.68215.list.halotools_v0p4.hdf5', update_cached_fname=True) if self['param'] == 'mvir': cens_occ_model = Zheng07Cens(threshold=-19) cens_prof_model = TrivialPhaseSpace() sats_occ_model = Zheng07Sats(modulate_with_cenocc=True, threshold=-19) sats_prof_model = NFWPhaseSpace() elif self['param'] == 'vmax': cens_occ_model = Zheng07Cens(prim_haloprop_key='halo_vmax', threshold=-19) cens_prof_model = TrivialPhaseSpace() sats_occ_model = Zheng07Sats(prim_haloprop_key='halo_vmax', threshold=-19, modulate_with_cenocc=True) sats_prof_model = NFWPhaseSpace() global model_instance model_instance = HodModelFactory(centrals_occupation=cens_occ_model, centrals_profile=cens_prof_model, satellites_occupation=sats_occ_model, satellites_profile=sats_prof_model) try: model_instance.mock.populate() except: model_instance.populate_mock(halocat)
def __makemodel__(self): """ Return the Zheng 07 HOD model. This model evaluates Eqs. 2 and 5 of Zheng et al. 2007 """ from halotools.empirical_models import HodModelFactory from halotools.empirical_models import Zheng07Sats, Zheng07Cens from halotools.empirical_models import NFWPhaseSpace, TrivialPhaseSpace model = {} # use concentration from halo table if 'halo_nfw_conc' in self._halos.halo_table.colnames: conc_mass_model = 'direct_from_halo_catalog' # use empirical prescription for c(M) else: conc_mass_model = 'dutton_maccio14' # occupation functions cenocc = Zheng07Cens(prim_haloprop_key=self.mass) satocc = Zheng07Sats(prim_haloprop_key=self.mass, modulate_with_cenocc=True, cenocc_model=cenocc) satocc._suppress_repeated_param_warning = True # add to model model['centrals_occupation'] = cenocc model['satellites_occupation'] = satocc # profile functions kws = {'cosmology':self.cosmo.to_astropy(), 'redshift':self.attrs['redshift'], 'mdef':self.attrs['mdef']} model['centrals_profile'] = TrivialPhaseSpace(**kws) model['satellites_profile'] = NFWPhaseSpace(conc_mass_model=conc_mass_model, **kws) return HodModelFactory(**model)
def decorated_hod_model(): cen_occ_model = AssembiasZheng07Cens(prim_haloprop_key='halo_mvir', sec_haloprop_key='halo_nfw_conc') cen_prof_model = TrivialPhaseSpace() sat_occ_model = AssembiasZheng07Sats(prim_haloprop_key='halo_mvir', sec_haloprop_key='halo_nfw_conc') sat_prof_model = NFWPhaseSpace() return HodModelFactory(centrals_occupation=cen_occ_model, centrals_profile=cen_prof_model, satellites_occupation=sat_occ_model, satellites_profile=sat_prof_model)
cens_occ_model = Zheng07Cens() cens_prof_model = TrivialPhaseSpace() #sats_occ_model = Zheng07Sats(prim_haloprop_key = 'halo_vmax', modulate_with_cenocc=True) sats_occ_model = Zheng07Sats(modulate_with_cenocc=True) sats_prof_model = NFWPhaseSpace() halocat = CachedHaloCatalog( fname= '/home/lom31/.astropy/cache/halotools/halo_catalogs/SMDPL/rockstar/2019-07-03-18-38-02-9731.dat.my_cosmosim_halos.hdf5', update_cached_fname=True) halocat.redshift = 0. pi_max = 60. Lbox = 400. model_instance = HodModelFactory(centrals_occupation=cens_occ_model, centrals_profile=cens_prof_model, satellites_occupation=sats_occ_model, satellites_profile=sats_prof_model) try: model_instance.mock.populate() except: model_instance.populate_mock(halocat) alpha, logM0, logM1 = [1.16, 13.28 - 1.7, 13.28] model_instance.param_dict['alpha'] = alpha model_instance.param_dict['logM0'] = logM0 model_instance.param_dict['logM1'] = logM1 halo_table = halocat.halo_table logMmin = np.logspace(11, 14, 100)
def __init__(self, **kwargs): """ Initialize a ABHodFitModel. """ # first, set up appropriate priors on parameters if ('priors' in kwargs.keys()): self.set_prior(kwargs['priors']) else: self.set_prior(default_priors) # set up keys for the parameter names for plotting self.param_names = [ 'alpha', 'logM1', 'siglogM', 'logM0', 'logMmin', 'Acens', 'Asats' ] self.latex_param_names = [ r'$\alpha$', r'$\log(M_1)$', r'$\sigma_{\log M}$', r'$\log(M_0)$', r'$\log(M_{\rm min})$', r'$\mathcal{A}_{\rm cens}$', r'$\mathcal{A}_{\rm sats}' ] # set up size parameters for any MCMC self.set_nwalkers(ndim=default_ndim, nwalkers=default_nwalkers) # if data is specified, load it into memory if 'rpcut' in kwargs.keys(): self.rpcut = kwargs['rpcut'] else: self.rpcut = default_rpcut if ('datafile' in kwargs.keys()): self.read_datafile(datafile=kwargs['datafile']) else: self.read_datafile(datafile=default_wp_datafile) if ('covarfile' in kwargs.keys()): self.read_covarfile(covarfile=kwargs['covarfile']) else: self.read_covarfile(covarfile=default_wp_covarfile) # if binfile is specified, load it into memory # these are Manodeep-style bins if ('binfile' in kwargs.keys()): self.binfile = kwargs['binfile'] else: self.binfile = default_binfile # set up a default HOD Model if ('cen_occ_model' in kwargs.keys()): cen_occ_model = kwargs['cen_occ_model'] else: cen_occ_model = AssembiasZheng07Cens( prim_haloprop_key='halo_mvir', sec_haloprop_key='halo_nfw_conc') if ('cen_prof_model' in kwargs.keys()): cen_prof_model = kwargs['cen_prof_model'] else: cen_prof_model = TrivialPhaseSpace() if ('sat_occ_model' in kwargs.keys()): sat_occ_model = kwargs['sat_occ_model'] else: sat_occ_model = AssembiasZheng07Sats( prim_haloprop_key='halo_mvir', sec_haloprop_key='halo_nfw_conc') if ('sat_prof_model' in kwargs.keys()): sat_prof_model = kwargs['sat_prof_model'] else: sat_prof_model = NFWPhaseSpace() # Default HOD Model is Zheng07 with Heaviside Assembly Bias self.hod_model = HodModelFactory(centrals_occupation=cen_occ_model, centrals_profile=cen_prof_model, satellites_occupation=sat_occ_model, satellites_profile=sat_prof_model) # set pi_max for wp(rp) calculations self.pi_max = default_pi_max if ('simname' in kwargs.keys()): simname = kwargs['simname'] else: simname = default_simname if ('halo_finder' in kwargs.keys()): halo_finder = kwargs['halo_finder'] else: halo_finder = default_halofinder if ('redshift' in kwargs.keys()): redshift = kwargs['redshift'] else: redshift = default_simredshift if ('version_name' in kwargs.keys()): version_name = kwargs['version_name'] else: version_name = default_version_name # set default simulation halocatalog to work with self.halocatalog = CachedHaloCatalog(simname=simname, halo_finder=halo_finder, redshift=redshift, version_name=version_name) return None
class ABHodFitModel(): """ HOD with assembly bias Fit model class for wp(rp) """ ################################################################### # Initialize an instance of the ABHodFitModel def __init__(self, **kwargs): """ Initialize a ABHodFitModel. """ # first, set up appropriate priors on parameters if ('priors' in kwargs.keys()): self.set_prior(kwargs['priors']) else: self.set_prior(default_priors) # set up keys for the parameter names for plotting self.param_names = [ 'alpha', 'logM1', 'siglogM', 'logM0', 'logMmin', 'Acens', 'Asats' ] self.latex_param_names = [ r'$\alpha$', r'$\log(M_1)$', r'$\sigma_{\log M}$', r'$\log(M_0)$', r'$\log(M_{\rm min})$', r'$\mathcal{A}_{\rm cens}$', r'$\mathcal{A}_{\rm sats}' ] # set up size parameters for any MCMC self.set_nwalkers(ndim=default_ndim, nwalkers=default_nwalkers) # if data is specified, load it into memory if 'rpcut' in kwargs.keys(): self.rpcut = kwargs['rpcut'] else: self.rpcut = default_rpcut if ('datafile' in kwargs.keys()): self.read_datafile(datafile=kwargs['datafile']) else: self.read_datafile(datafile=default_wp_datafile) if ('covarfile' in kwargs.keys()): self.read_covarfile(covarfile=kwargs['covarfile']) else: self.read_covarfile(covarfile=default_wp_covarfile) # if binfile is specified, load it into memory # these are Manodeep-style bins if ('binfile' in kwargs.keys()): self.binfile = kwargs['binfile'] else: self.binfile = default_binfile # set up a default HOD Model if ('cen_occ_model' in kwargs.keys()): cen_occ_model = kwargs['cen_occ_model'] else: cen_occ_model = AssembiasZheng07Cens( prim_haloprop_key='halo_mvir', sec_haloprop_key='halo_nfw_conc') if ('cen_prof_model' in kwargs.keys()): cen_prof_model = kwargs['cen_prof_model'] else: cen_prof_model = TrivialPhaseSpace() if ('sat_occ_model' in kwargs.keys()): sat_occ_model = kwargs['sat_occ_model'] else: sat_occ_model = AssembiasZheng07Sats( prim_haloprop_key='halo_mvir', sec_haloprop_key='halo_nfw_conc') if ('sat_prof_model' in kwargs.keys()): sat_prof_model = kwargs['sat_prof_model'] else: sat_prof_model = NFWPhaseSpace() # Default HOD Model is Zheng07 with Heaviside Assembly Bias self.hod_model = HodModelFactory(centrals_occupation=cen_occ_model, centrals_profile=cen_prof_model, satellites_occupation=sat_occ_model, satellites_profile=sat_prof_model) # set pi_max for wp(rp) calculations self.pi_max = default_pi_max if ('simname' in kwargs.keys()): simname = kwargs['simname'] else: simname = default_simname if ('halo_finder' in kwargs.keys()): halo_finder = kwargs['halo_finder'] else: halo_finder = default_halofinder if ('redshift' in kwargs.keys()): redshift = kwargs['redshift'] else: redshift = default_simredshift if ('version_name' in kwargs.keys()): version_name = kwargs['version_name'] else: version_name = default_version_name # set default simulation halocatalog to work with self.halocatalog = CachedHaloCatalog(simname=simname, halo_finder=halo_finder, redshift=redshift, version_name=version_name) return None ############################################################################## ############################################################################## # Set MCMC dimension and number of walkers def set_nwalkers(self, **kwargs): """ Sets the number of MCMC dimensions and sets the number of walkers. Parameters ---------- Takes keyword arguments ndim and nwalkers. """ if ('ndim' in kwargs.keys()): self.ndim = kwargs['ndim'] if ('nwalkers' in kwargs.keys()): self.nwalkers = kwargs['nwalkers'] return None # Routine to set priors on model parameters def set_prior(self, prior_array): """ Sets the model priors. Parameters ----------- Takes keyword arguments r0min, r0max, gammamin, gammamax """ self.priors = {} # priors are stored in a dictionary if 'alpha' in prior_array.keys(): self.priors['alpha'] = prior_array['alpha'] if 'logM1' in prior_array.keys(): self.priors['logM1'] = prior_array['logM1'] if 'sigma_logM' in prior_array.keys(): self.priors['sigma_logM'] = prior_array['sigma_logM'] if 'logM0' in prior_array.keys(): self.priors['logM0'] = prior_array['logM0'] if 'logMmin' in prior_array.keys(): self.priors['logMmin'] = prior_array['logMmin'] if 'mean_occupation_centrals_assembias_param1' in prior_array.keys(): self.priors[ 'mean_occupation_centrals_assembias_param1'] = prior_array[ 'mean_occupation_centrals_assembias_param1'] if 'mean_occupation_satellites_assembias_param1' in prior_array.keys(): self.priors[ 'mean_occupation_satellites_assembias_param1'] = prior_array[ 'mean_occupation_satellites_assembias_param1'] return None # Read in the data def read_datafile(self, **kwargs): """ Read in the data. This can assume the input_data_file attribute or it can accept a new data file as a keyword argument, datafile. """ if ('datafile' in kwargs.keys()): self.datafile = kwargs['datafile'] col1, col2, col3 = np.loadtxt(self.datafile, unpack=True) self.Number_gals = col1[0] self.ngal = col2[0] self.ngalerr = col3[0] self.rp = col1[1:] self.wp = col2[1:] self.wperr = col3[1:] # Use data only out to the bin at rp=rpcut ikeep = np.where(self.rp <= self.rpcut) self.rp = self.rp[ikeep] self.wp = self.wp[ikeep] self.wpT = self.wp.T self.wperr = self.wperr[ikeep] # set the number of bins self.nrpbins = self.rp.size return None # Read in the data covariances def read_covarfile(self, **kwargs): """ Read in the data covariances """ if ('covarfile' in kwargs.keys()): self.covarfile = kwargs['covarfile'] else: self.covarfile = default_wp_covarfile self.covar = np.loadtxt(self.covarfile, unpack=True) self.cov_inv = np.linalg.inv(self.covar) # A routine to give wp(rp) computed via a halo model. def wp_hod(self, hod_parameters): """ An HOD model for wp(rp) computed by direct simulation population. hod_parameters[0] : alpha hod_parameters[1] : logM1 hod_parameters[2] : sigma_logM hod_parameters[3] : logM0 hod_parameters[4] : logMmin hod_parameters[5] : Acen hod_parameters[6] : Asat """ # The first step is to set the param_dict of the hod_model. self.hod_model.param_dict['alpha'] = hod_parameters[0] self.hod_model.param_dict['logM1'] = hod_parameters[1] self.hod_model.param_dict['sigma_logM'] = hod_parameters[2] self.hod_model.param_dict['logM0'] = hod_parameters[3] self.hod_model.param_dict['logMmin'] = hod_parameters[4] self.hod_model.param_dict[ 'mean_occupation_centrals_assembias_param1'] = hod_parameters[5] self.hod_model.param_dict[ 'mean_occupation_satellites_assembias_param1'] = hod_parameters[6] # Populate a mock galaxy catalog #self.hod_model.populate_mock() try: self.hod_model.mock.populate() except: self.hod_model.populate_mock(self.halocatalog) # Instruct wp(rp) routine to compute autocorrelation autocorr = 1 # Number of threads nthreads = 4 # use the z-direction as line-of-sight and add RSD z_distorted = self.hod_model.mock.galaxy_table[ 'z'] + self.hod_model.mock.galaxy_table['vz'] / 100.0 # enforce periodicity of the box self.hod_model.mock.galaxy_table[ 'zdist'] = z_distorted % self.hod_model.mock.Lbox[0] # Return projected correlation function computed using # Manodeep Simha's optimized C code. cpout = np.array( _countpairs.countpairs_wp( self.hod_model.mock.Lbox[0], self.pi_max, nthreads, self.binfile, self.hod_model.mock.galaxy_table['x'].astype('float32'), self.hod_model.mock.galaxy_table['y'].astype('float32'), self.hod_model.mock.galaxy_table['zdist'].astype('float32'))) return np.array(cpout[0])[:, 3] # A routine to compute wp(rp) in a power-law model xi = (r/r0)^-gamma. def wp_powerlaw_model(self, rsep, r0, gamma): """ Power law model for wp(rp) assuming that xi = (r/r0)^-gamma. """ if rsep.any < 0.0: return np.inf return rsep * (rsep / r0)**(-gamma) * gammafn(0.5) * gammafn( (gamma - 1.0) / 2.0) / gammafn(gamma / 2.0) # A routine to compute the likelihood of a power-law wp(rp) given data. def lnlike(self, theta): """ Log likelihood of a power-law model. Parameters ------------ theta : (alpha,logM1,sigma_logM,logM0,logMmin) rp : numpy array containing separations wp : numpy array containing projected correlation functions wperr : numpy array containing errors on measured wp """ # log likelihood from clustering wpmodel = self.wp_hod(theta) #print 'wpmodel shape = ',np.shape(wpmodel) #print 'wperr shape = ',np.shape(self.wperr) #print 'wp shape = ',np.shape(self.wp) #print 'rp shape = ',np.shape(self.rp) wp_dev = (wpmodel - self.wp) wplike = -0.5 * np.dot(np.dot(wp_dev, self.cov_inv), wp_dev) # log likelihood from number density number_gals = len(self.hod_model.mock.galaxy_table) ngal = number_gals / (self.hod_model.mock.Lbox[0]**3) ng_theory_error = ngal / np.sqrt(number_gals) nglike = -0.5 * ((ngal - self.ngal)**2 / (self.ngalerr**2 + ng_theory_error**2)) return wplike + nglike # A prior function on the two parameters in the list theta def lnprior(self, theta): """ Prior function Parameters ---------- theta : [alpha,logM1,sigma_logM,logM0,logMmin,Acen,Asat] Priors are so-called hard priors specified in self.priors. """ alpha, logM1, sigma_logM, logM0, logMmin, Acen, Asat = theta if alpha < self.priors['alpha'][0]: return -np.inf if alpha > self.priors['alpha'][1]: return -np.inf if logM1 < self.priors['logM1'][0]: return -np.inf if logM1 > self.priors['logM1'][1]: return -np.inf if sigma_logM < self.priors['sigma_logM'][0]: return -np.inf if sigma_logM > self.priors['sigma_logM'][1]: return -np.inf if logM0 < self.priors['logM0'][0]: return -np.inf if logM0 > self.priors['logM0'][1]: return -np.inf if logMmin < self.priors['logMmin'][0]: return -np.inf if logMmin > self.priors['logMmin'][1]: return -np.inf if Acen < self.priors['mean_occupation_centrals_assembias_param1'][0]: return -np.inf if Acen > self.priors['mean_occupation_centrals_assembias_param1'][1]: return -np.inf if Asat < self.priors['mean_occupation_satellites_assembias_param1'][0]: return -np.inf if Asat > self.priors['mean_occupation_satellites_assembias_param1'][1]: return -np.inf return 0.0 # The probability function including priors and likelihood def lnprob(self, theta): """ Probability function to sample in an MCMC. """ lp = self.lnprior(theta) if not np.isfinite(lp): return -np.inf return lp + self.lnlike(theta) # Set the starting position of an MCMC. def set_start_position(self, theta_start=default_start): """ Set the starting position for the MCMC. """ self.position = np.zeros([self.nwalkers, self.ndim]) for iparam in range(self.ndim): self.position[:, iparam] = theta_start[ iparam] + 0.05 * np.random.randn(self.nwalkers) return None # Fit the data with the hod model model def mcmcfit(self, theta_start, **kwargs): """ Peform an MCMC fit to the wp data using the power-law model. """ if ('samples' in kwargs.keys()): self.nsamples = kwargs['samples'] else: self.nsamples = 100 if ('nwalkers' in kwargs.keys()): self.set_nwalkers(nwalkers=kwargs['nwalkers']) self.wpsampler = emcee.EnsembleSampler(self.nwalkers, self.ndim, self.lnprob) self.set_start_position(theta_start) if ('burnin' in kwargs.keys()): self.nburnin = kwargs['burnin'] self.position, self.prob, self.state = self.wpsampler.run_mcmc( self.position, self.nburnin) self.wpsampler.reset() else: self.nburnin = 0 self.wpsampler.run_mcmc(self.position, self.nsamples) self.mcmcsamples = self.wpsampler.chain[:, :, :].reshape( (-1, self.ndim)) self.lnprobability = self.wpsampler.lnprobability.reshape(-1, 1) self.compute_parameter_constraints() return None # given a set of MCMC samples in self.mcmcsamples, compute the 1-D parameter constraints. def compute_parameter_constraints(self): """ Computes the 1D marginalized parameter constraints from self.mcmcsamples. """ self.alpha_mcmc, self.logM1_mcmc, self.sigma_logM_mcmc, self.logM0_mcmc, self.logMmin_mcmc, self.Acen_mcmc, self.Asat_mcmc = map( lambda v: (v[1], v[2] - v[1], v[1] - v[0]), zip(*np.percentile(self.mcmcsamples, [16, 50, 84], axis=0))) self.alpha_1side, self.logM1_1side, self.sigma_logM_1side, self.logM0_1side, self.logMmin_1side, self.Acen_1side, self.Asat_1side = map( lambda v: (v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]), zip(*np.percentile( self.mcmcsamples, [1, 5, 10, 16, 84, 90, 95, 99], axis=0))) return None # save chains to file def save_chains(self, **kwargs): """ Save the chain to an ascii file. """ if ('filename' in kwargs.keys()): fname = kwargs['filename'] else: fname = self.datafile if fname.endswith('.dat'): fname = fname[:-4] fname = fname + '_abfit.chain' out_data = np.hstack((self.mcmcsamples, self.lnprobability)) np.savetxt(fname, out_data, delimiter=' ') return None # load a chain from an existing chain file def load_chains(self, chainfile_names): """ Load a pre-existing chain into memory from a file. """ for chainfile in chainfile_names: read_data = np.loadtxt(chainfile, unpack=True).T samples = read_data[:, 0:self.ndim] lnprob = read_data[:, self.ndim] samples = samples.reshape(-1, self.ndim) lnprob = lnprob.reshape(-1, 1) if (hasattr(self, 'mcmcsamples')): self.mcmcsamples = np.concatenate((self.mcmcsamples, samples), axis=0) self.lnprobability = np.concatenate( (self.lnprobability, lnprob), axis=0) else: self.mcmcsamples = samples self.lnprobability = lnprob # self.mcmcsamples=self.mcmcsamples.reshape(-1,self.ndim) # self.lnprobability=self.lnprobability.reshape(-1,1) return None # plot the data def plot_data(self): """ plot the data only """ fig1 = plt.figure() plt.loglog(self.rp, self.wp, 'sk') plt.errorbar(self.rp, self.wp, yerr=self.wperr, fmt='sk', ecolor='k') plt.xlabel(r'$r_{\rm p}$') plt.ylabel(r'$w_{\rm p}(r_{\rm p})$') fig1.savefig('wpdata.png') return None # plot the mcmc run def plot_parameter_run(self): """ plot the mcmc samples. """ for idim in range(self.ndim): fig = plt.figure() plt.plot(range(len(self.mcmcsamples[:, idim])), self.mcmcsamples[:, idim], 'k') plt.xlabel('sample number') plt.ylabel(self.latex_param_names[idim]) filename = self.datafile if filename.endswith('.dat'): filename = filename[:-4] plabel = self.param_names[idim].strip('$') plabel = plabel.strip('\\') filename = filename + '_' + plabel + '_' + 'chain.png' fig.savefig(filename) del fig # plot fitting results def plot_chain_samples(self, **kwargs): """ Plots samples from the mcmc chain alongside the data. """ lnp_max = np.max(self.lnprobability) if ('deltachi2' in kwargs.keys()): lnp_threshold = lnp_max - kwargs['deltachi2'] / 2.0 else: lnp_threshold = lnp_max - 0.5 if ('samples' in kwargs.keys()): numsamples = kwargs['samples'] else: numsamples = 50 fig = plt.figure() #print ' + Beginning sample selection.' igood = np.where((self.lnprobability.reshape(-1) > lnp_threshold)) #print 'numsamples = ',numsamples #print 'Length(igood) = ',len(igood[0]) #print 'Shape(igood) = ',np.shape(igood) # reduce the number of samples if there are very few if len(igood[0]) < 1: print ' > Too few samples that satisfy criterion, n = ', len( igood[0]) return None elif len(igood[0]) < numsamples: numsamples = len(igood[0]) - 1 good_models = self.mcmcsamples[igood] #print 'igood is ',igood #print 'good_models = ',good_models #print 'numsamples = ',numsamples irandoms = np.random.randint(len(good_models), size=numsamples) #print 'len(irandoms) = ',len(irandoms) #print 'irandoms = ',irandoms for parameters in good_models[irandoms, :]: #print 'Within for loop' #print 'Parameters are',parameters plt.loglog(self.rp, self.wp_hod(parameters), color='k', alpha=0.07) plt.xlim(0.92 * np.min(self.rp), 1.05 * np.max(self.rp)) plt.xticks(size=15) plt.yticks(size=15) plt.xlabel(r'$r_{\rm p}$ [$h^{-1}$Mpc]', fontsize=20) plt.ylabel(r'$w_{\rm p}(r_{\rm p})$ [$h^{-1}$Mpc]', fontsize=20) #plt.loglog(self.rp,self.wp,'sk') plt.errorbar(self.rp, self.wp, yerr=self.wperr, fmt='s', color='firebrick', ecolor='firebrick') filename = self.datafile if filename.endswith('.dat'): filename = filename[:-4] filename = filename + '_chainsamples.pdf' fig.savefig(filename, format='pdf', bbox_inches='tight')
Zheng07Sats.__init__(self, threshold = -21) HeavisideAssembias.__init__(self, method_name_to_decorate = 'mean_occupation', lower_assembias_bound = 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
def tabulate(cls, halocat, tpcf, *tpcf_args, mode='auto', Num_ptcl_requirement=sim_defaults.Num_ptcl_requirement, prim_haloprop_key=model_defaults.prim_haloprop_key, prim_haloprop_bins=100, sec_haloprop_key=model_defaults.sec_haloprop_key, sec_haloprop_percentile_bins=None, sats_per_prim_haloprop=3e-12, downsample=1.0, verbose=False, redshift_space_distortions=True, cens_prof_model=None, sats_prof_model=None, project_xyz=False, cosmology_obs=None, num_threads=1, **tpcf_kwargs): """ Tabulates correlation functions for halos such that galaxy correlation functions can be calculated rapidly. Parameters ---------- halocat : object Either an instance of `halotools.sim_manager.CachedHaloCatalog` or `halotools.sim_manager.UserSuppliedHaloCatalog`. This halo catalog is used to tabubulate correlation functions. tpcf : function The halotools correlation function for which values are tabulated. Positional arguments should be passed after this function. Additional keyword arguments for the correlation function are also passed through this function. *tpcf_args : tuple, optional Positional arguments passed to the ``tpcf`` function. mode : string, optional String describing whether an auto- ('auto') or a cross-correlation ('cross') function is going to be tabulated. Num_ptcl_requirement : int, optional Requirement on the number of dark matter particles in the halo catalog. The column defined by the ``prim_haloprop_key`` string will have a cut placed on it: all halos with halocat.halo_table[prim_haloprop_key] < Num_ptcl_requirement*halocat.particle_mass will be thrown out immediately after reading the original halo catalog in memory. Default value is set in `~halotools.sim_defaults.Num_ptcl_requirement`. prim_haloprop_key : string, optional String giving the column name of the primary halo property governing the occupation statistics of gal_type galaxies. Default value is specified in the model_defaults module. prim_haloprop_bins : int or list, optional Integer determining how many (logarithmic) bins in primary halo property will be used. If a list or numpy array is provided, these will be used as bins directly. sec_haloprop_key : string, optional String giving the column name of the secondary halo property governing the assembly bias. Must be a key in the table passed to the methods of `HeavisideAssembiasComponent`. Default value is specified in the `~halotools.empirical_models.model_defaults` module. sec_haloprop_percentile_bins : int, float or None, optional If an integer, it determines how many evenly spaced bins in the secondary halo property percentiles are going to be used. If a float between 0 and 1, it determines the split. If None is provided, no binning is applied. sats_per_prim_haloprop : float, optional Float determing how many satellites sample each halo. For each halo, the number is drawn from a Poisson distribution with an expectation value of ``sats_per_prim_haloprop`` times the primary halo property. downsample : float or function, optional Fraction between 0 and 1 used to downsample the total sample used to tabulate correlation functions. Values below unity can be used to reduce the computation time. It should not result in biases but the resulting correlation functions will be less accurate. If float, the same value is applied to all halos. If function, it should return the fraction is a function of the primary halo property. verbose : boolean, optional Boolean determing whether the progress should be displayed. redshift_space_distortions : boolean, optional Boolean determining whether redshift space distortions should be applied to halos/galaxies. cens_prof_model : object, optional Instance of `halotools.empirical_models.MonteCarloGalProf` that determines the phase space coordinates of centrals. If none is provided, `halotools.empirical_models.TrivialPhaseSpace` will be used. sats_prof_model : object, optional Instance of `halotools.empirical_models.MonteCarloGalProf` that determines the phase space coordinates of satellites. If none is provided, `halotools.empirical_models.NFWPhaseSpace` will be used. project_xyz : bool, optional If True, the coordinates will be projected along all three spatial axes. By default, only the projection onto the z-axis is used. cosmology_obs : object, optional Instance of an astropy `~astropy.cosmology`. This can be used to correct coordinates in the simulation for the Alcock-Paczynski (AP) effect, i.e. a mismatch between the cosmology of the model (simulation) and the cosmology used to interpret observations. Note that the cosmology of the simulation is part of the halocat object. If None, no correction for the AP effect is applied. Also, a correction for the AP effect is only applied for auto-correlation functions. num_threads : int, optional How many threads to use for the tabulation. **tpcf_kwargs : dict, optional Keyword arguments passed to the ``tpcf`` function. Returns ------- halotab : TabCorr Object containing all necessary information to calculate correlation functions for arbitrary galaxy models. """ if 'period' in tpcf_kwargs: print('Warning: TabCorr will pass the keyword argument "period" ' + 'to {} based on the Lbox argument of'.format(tpcf.__name__) + ' the halo catalog. The value you provided will be ignored.') del tpcf_kwargs['period'] halotab = cls() if cosmology_obs is not None and mode == 'auto': rp_stretch = ( (cosmology_obs.comoving_distance(halocat.redshift) * cosmology_obs.H0) / (halocat.cosmology.comoving_distance(halocat.redshift) * halocat.cosmology.H0)) pi_stretch = (halocat.cosmology.efunc(halocat.redshift) / cosmology_obs.efunc(halocat.redshift)) lbox_stretch = np.array([rp_stretch, rp_stretch, pi_stretch]) else: lbox_stretch = np.ones(3) # First, we tabulate the halo number densities. halos = halocat.halo_table halos = halos[halos['halo_pid'] == -1] halos = halos[halos[prim_haloprop_key] >= (Num_ptcl_requirement + 0.5) * halocat.particle_mass] if isinstance(prim_haloprop_bins, int): prim_haloprop_bins = np.linspace( np.log10(np.amin(halos[prim_haloprop_key])) - 1e-3, np.log10(np.amax(halos[prim_haloprop_key])) + 1e-3, prim_haloprop_bins + 1) elif isinstance(prim_haloprop_bins, (list, np.ndarray)): pass else: raise ValueError('prim_haloprop_bins must be an int, list or ' + 'numpy array.') if sec_haloprop_percentile_bins is None: sec_haloprop_percentile_bins = np.array([-1e-3, 1 + 1e-3]) elif isinstance(sec_haloprop_percentile_bins, float): if not (0 < sec_haloprop_percentile_bins and sec_haloprop_percentile_bins < 1): raise ValueError('sec_haloprop_percentile_bins must be ' + 'between 0 and 1.') sec_haloprop_percentile_bins = np.array( [-1e-3, sec_haloprop_percentile_bins, 1 + 1e-3]) elif isinstance(sec_haloprop_percentile_bins, int): sec_haloprop_percentile_bins = np.linspace( -1e-3, 1 + 1e-3, sec_haloprop_percentile_bins + 1) else: raise ValueError('sec_haloprop_percentile_bins must be an int, ' + 'float, list or numpy array.') halos[sec_haloprop_key + '_percentile'] = (compute_conditional_percentiles( table=halos, prim_haloprop_key=prim_haloprop_key, sec_haloprop_key=sec_haloprop_key)) halotab.gal_type = Table() n_h, prim_haloprop_bins, sec_haloprop_percentile_bins = ( np.histogram2d( np.log10(halos[prim_haloprop_key]), halos[sec_haloprop_key + '_percentile'], bins=[prim_haloprop_bins, sec_haloprop_percentile_bins])) halotab.gal_type['n_h'] = n_h.ravel(order='F') grid = np.meshgrid(prim_haloprop_bins, sec_haloprop_percentile_bins) halotab.gal_type['log_prim_haloprop_min'] = grid[0][:-1, :-1].ravel() halotab.gal_type['log_prim_haloprop_max'] = grid[0][:-1, 1:].ravel() halotab.gal_type['sec_haloprop_percentile_min'] = ( grid[1][:-1, :-1].ravel()) halotab.gal_type['sec_haloprop_percentile_max'] = ( grid[1][1:, :-1].ravel()) halotab.gal_type = vstack([halotab.gal_type, halotab.gal_type]) halotab.gal_type['gal_type'] = np.concatenate( (np.repeat('centrals'.encode('utf8'), len(halotab.gal_type) // 2), np.repeat('satellites'.encode('utf8'), len(halotab.gal_type) // 2))) halotab.gal_type['prim_haloprop'] = 10**( 0.5 * (halotab.gal_type['log_prim_haloprop_min'] + halotab.gal_type['log_prim_haloprop_max'])) halotab.gal_type['sec_haloprop_percentile'] = ( 0.5 * (halotab.gal_type['sec_haloprop_percentile_min'] + halotab.gal_type['sec_haloprop_percentile_max'])) # Now, we tabulate the correlation functions. cens_occ_model = Zheng07Cens(prim_haloprop_key=prim_haloprop_key) if cens_prof_model is None: cens_prof_model = TrivialPhaseSpace(redshift=halocat.redshift) sats_occ_model = Zheng07Sats(prim_haloprop_key=prim_haloprop_key) if sats_prof_model is None: sats_prof_model = NFWPhaseSpace(redshift=halocat.redshift) model = HodModelFactory(centrals_occupation=cens_occ_model, centrals_profile=cens_prof_model, satellites_occupation=sats_occ_model, satellites_profile=sats_prof_model) model.param_dict['logMmin'] = 0 model.param_dict['sigma_logM'] = 0.1 model.param_dict['alpha'] = 1.0 model.param_dict['logM0'] = 0 model.param_dict['logM1'] = -np.log10(sats_per_prim_haloprop) model.populate_mock(halocat, Num_ptcl_requirement=Num_ptcl_requirement) gals = model.mock.galaxy_table idx_gals, idx_halos = crossmatch(gals['halo_id'], halos['halo_id']) assert np.all(gals['halo_id'][idx_gals] == halos['halo_id'][idx_halos]) gals[sec_haloprop_key + '_percentile'] = np.zeros(len(gals)) gals[sec_haloprop_key + '_percentile'][idx_gals] = (halos[sec_haloprop_key + '_percentile'][idx_halos]) if verbose: print("Number of tracer particles: {0}".format(len(gals))) for xyz in ['xyz', 'yzx', 'zxy']: if verbose and project_xyz: print("Projecting onto {0}-axis...".format(xyz[2])) pos_all = (return_xyz_formatted_array( x=gals[xyz[0]], y=gals[xyz[1]], z=gals[xyz[2]], velocity=gals['v' + xyz[2]] if redshift_space_distortions else 0, velocity_distortion_dimension='z', period=halocat.Lbox, redshift=halocat.redshift, cosmology=halocat.cosmology) * lbox_stretch) period = halocat.Lbox * lbox_stretch # Get a list of the positions of each sub-population. i_prim = np.digitize(np.log10(gals[prim_haloprop_key]), bins=prim_haloprop_bins, right=False) - 1 mask = (i_prim < 0) | (i_prim >= len(prim_haloprop_bins)) i_sec = np.digitize(gals[sec_haloprop_key + '_percentile'], bins=sec_haloprop_percentile_bins, right=False) - 1 i_type = np.where(gals['gal_type'] == 'centrals', 0, 1) # Throw out those that don't fall into any bin. pos_all = pos_all[~mask] i = (i_prim + i_sec * (len(prim_haloprop_bins) - 1) + i_type * ((len(prim_haloprop_bins) - 1) * (len(sec_haloprop_percentile_bins) - 1))) pos_all = pos_all[np.argsort(i)] counts = np.bincount(i, minlength=len(halotab.gal_type)) assert len(counts) == len(halotab.gal_type) pos_bin = [] for i in range(len(halotab.gal_type)): pos = pos_all[np.sum(counts[:i]):np.sum(counts[:i + 1]), :] if halotab.gal_type['gal_type'][i] == 'centrals': # Make sure the number of halos are consistent. try: assert len(pos) == int(halotab.gal_type['n_h'][i]) except AssertionError: raise RuntimeError('There was an internal error in ' + 'TabCorr. If possible, please ' + 'report this bug in the TabCorr ' + 'GitHub repository.') else: if len(pos) == 0 and halotab.gal_type['n_h'][i] != 0: raise RuntimeError( 'There was at least one bin without satellite ' + 'tracers. Increase sats_per_prim_haloprop.') if len(pos) > 0: if isinstance(downsample, float): use = np.random.random(len(pos)) < downsample else: use = (np.random.random(len(pos)) < downsample( halotab.gal_type['prim_haloprop'][i])) # If the down-sampling reduced the number of tracers to at # or below one, force at least 2 tracers to not bias the # clustering estimates. if np.sum(use) <= 1 and len(pos) > 1: use = np.zeros(len(pos), dtype=bool) use[np.random.choice(len(pos), size=2)] = True pos = pos[use] pos_bin.append(pos) if mode == 'auto': combinations = itertools.combinations_with_replacement( range(len(halotab.gal_type)), 2) else: combinations = range(len(halotab.gal_type)) if xyz == 'xyz': tpcf_matrix, tpcf_shape = compute_tpcf_matrix( mode, pos_bin, tpcf, period, tpcf_args, tpcf_kwargs, combinations, num_threads=num_threads, verbose=verbose) if not project_xyz or mode == 'cross': break elif xyz != 'xyz': tpcf_matrix += compute_tpcf_matrix(mode, pos_bin, tpcf, period, tpcf_args, tpcf_kwargs, combinations, num_threads=num_threads, verbose=verbose)[0] if project_xyz and mode == 'auto': tpcf_matrix /= 3.0 if mode == 'auto': tpcf_matrix_flat = [] for i in range(tpcf_matrix.shape[0]): tpcf_matrix_flat.append( symmetric_matrix_to_array(tpcf_matrix[i])) tpcf_matrix = np.array(tpcf_matrix_flat) # Remove entries that don't have any halos. use = halotab.gal_type['n_h'] != 0 halotab.gal_type = halotab.gal_type[use] if mode == 'auto': use = symmetric_matrix_to_array(np.outer(use, use)) tpcf_matrix = tpcf_matrix[:, use] halotab.gal_type['n_h'] /= np.prod(halocat.Lbox * lbox_stretch) halotab.attrs = {} halotab.attrs['tpcf'] = tpcf.__name__ halotab.attrs['mode'] = mode halotab.attrs['simname'] = halocat.simname halotab.attrs['redshift'] = halocat.redshift halotab.attrs['Num_ptcl_requirement'] = Num_ptcl_requirement halotab.attrs['prim_haloprop_key'] = prim_haloprop_key halotab.attrs['sec_haloprop_key'] = sec_haloprop_key halotab.tpcf_args = tpcf_args halotab.tpcf_kwargs = tpcf_kwargs halotab.tpcf_shape = tpcf_shape halotab.tpcf_matrix = tpcf_matrix halotab.init = True return halotab
def tabulate(cls, halocat, tpcf, *tpcf_args, mode='auto', Num_ptcl_requirement=sim_defaults.Num_ptcl_requirement, cosmology=sim_defaults.default_cosmology, prim_haloprop_key=model_defaults.prim_haloprop_key, prim_haloprop_bins=100, sec_haloprop_key=model_defaults.sec_haloprop_key, sec_haloprop_percentile_bins=None, sats_per_prim_haloprop=3e-12, downsample=1.0, verbose=False, redshift_space_distortions=True, cens_prof_model=None, sats_prof_model=None, project_xyz=False, cosmology_ref=None, comm=None, **tpcf_kwargs): """ Tabulates correlation functions for halos such that galaxy correlation functions can be calculated rapidly. Parameters ---------- halocat : object Either an instance of `halotools.sim_manager.CachedHaloCatalog` or `halotools.sim_manager.UserSuppliedHaloCatalog`. This halo catalog is used to tabubulate correlation functions. tpcf : function The halotools correlation function for which values are tabulated. Positional arguments should be passed after this function. Additional keyword arguments for the correlation function are also passed through this function. *tpcf_args : tuple, optional Positional arguments passed to the ``tpcf`` function. mode : string, optional String describing whether an auto- ('auto') or a cross-correlation ('cross') function is going to be tabulated. Num_ptcl_requirement : int, optional Requirement on the number of dark matter particles in the halo catalog. The column defined by the ``prim_haloprop_key`` string will have a cut placed on it: all halos with halocat.halo_table[prim_haloprop_key] < Num_ptcl_requirement*halocat.particle_mass will be thrown out immediately after reading the original halo catalog in memory. Default value is set in `~halotools.sim_defaults.Num_ptcl_requirement`. cosmology : object, optional Instance of an astropy `~astropy.cosmology`. Default cosmology is set in `~halotools.sim_manager.sim_defaults`. This might be used to calculate phase-space distributions and redshift space distortions. prim_haloprop_key : string, optional String giving the column name of the primary halo property governing the occupation statistics of gal_type galaxies. Default value is specified in the model_defaults module. prim_haloprop_bins : int or list, optional Integer determining how many (logarithmic) bins in primary halo property will be used. If a list or numpy array is provided, these will be used as bins directly. sec_haloprop_key : string, optional String giving the column name of the secondary halo property governing the assembly bias. Must be a key in the table passed to the methods of `HeavisideAssembiasComponent`. Default value is specified in the `~halotools.empirical_models.model_defaults` module. sec_haloprop_percentile_bins : int, float, list or None, optional If an integer, it determines how many evenly spaced bins in the secondary halo property percentiles are going to be used. If a float between 0 and 1, it determines the split. Finally, if a list or numpy array, it directly describes the bins that are going to be used. If None is provided, no binning is applied. sats_per_prim_haloprop : float, optional Float determing how many satellites sample each halo. For each halo, the number is drawn from a Poisson distribution with an expectation value of ``sats_per_prim_haloprop`` times the primary halo property. downsample : float, optional Fraction between 0 and 1 used to downsample the total sample used to tabulate correlation functions. Values below unity can be used to reduce the computation time. It should not result in biases but the resulting correlation functions will be less accurate. verbose : boolean, optional Boolean determing whether the progress should be displayed. redshift_space_distortions : boolean, optional Boolean determining whether redshift space distortions should be applied to halos/galaxies. cens_prof_model : object, optional Instance of `halotools.empirical_models.MonteCarloGalProf` that determines the phase space coordinates of centrals. If none is provided, `halotools.empirical_models.TrivialPhaseSpace` will be used. sats_prof_model : object, optional Instance of `halotools.empirical_models.MonteCarloGalProf` that determines the phase space coordinates of satellites. If none is provided, `halotools.empirical_models.NFWPhaseSpace` will be used. project_xyz : bool, optional If True, the coordinates will be projected along all three spatial axes. By default, only the projection onto the z-axis is used. comm : MPI communicator If not None, then will distribute calculation via MPI **tpcf_kwargs : dict, optional Keyword arguments passed to the ``tpcf`` function. Returns ------- halotab : TabCorr Object containing all necessary information to calculate correlation functions for arbitrary galaxy models. """ if sec_haloprop_percentile_bins is None: sec_haloprop_percentile_bins = np.array([0, 1]) elif isinstance(sec_haloprop_percentile_bins, float): sec_haloprop_percentile_bins = np.array( [0, sec_haloprop_percentile_bins, 1]) if 'period' in tpcf_kwargs: print('Warning: TabCorr will pass the keyword argument "period" ' + 'to {} based on the Lbox argument of'.format(tpcf.__name__) + ' the halo catalog. The value you provided will be ignored.') del tpcf_kwargs['period'] halotab = cls() if cosmology_ref is not None and mode == 'auto': rp_stretch = ( (cosmology_ref.comoving_distance(halocat.redshift) * cosmology_ref.H0) / (cosmology.comoving_distance(halocat.redshift) * cosmology.H0)) pi_stretch = (cosmology.efunc(halocat.redshift) / cosmology_ref.efunc(halocat.redshift)) lbox_stretch = np.array([rp_stretch, rp_stretch, pi_stretch]) else: lbox_stretch = np.ones(3) # First, we tabulate the halo number densities. halos = halocat.halo_table halos = halos[halos['halo_pid'] == -1] halos = halos[halos[prim_haloprop_key] >= (Num_ptcl_requirement - 0.5) * halocat.particle_mass] if isinstance(prim_haloprop_bins, int): prim_haloprop_bins = np.linspace( np.log10(np.amin(halos[prim_haloprop_key])) - 1e-3, np.log10(np.amax(halos[prim_haloprop_key])) + 1e-3, prim_haloprop_bins + 1) elif not isinstance(prim_haloprop_bins, (list, np.ndarray)): raise ValueError('prim_haloprop_bins must be an int, list or ' + 'numpy array.') halos[sec_haloprop_key + '_percentile'] = (compute_conditional_percentiles( table=halos, prim_haloprop_key=prim_haloprop_key, sec_haloprop_key=sec_haloprop_key)) halotab.gal_type = Table() n_h, prim_haloprop_bins, sec_haloprop_percentile_bins = ( np.histogram2d( np.log10(halos[prim_haloprop_key]), halos[sec_haloprop_key + '_percentile'], bins=[prim_haloprop_bins, sec_haloprop_percentile_bins])) halotab.gal_type['n_h'] = n_h.ravel(order='F') / np.prod( halocat.Lbox * lbox_stretch) grid = np.meshgrid(prim_haloprop_bins, sec_haloprop_percentile_bins) halotab.gal_type['log_prim_haloprop_min'] = grid[0][:-1, :-1].ravel() halotab.gal_type['log_prim_haloprop_max'] = grid[0][:-1, 1:].ravel() halotab.gal_type['sec_haloprop_percentile_min'] = ( grid[1][:-1, :-1].ravel()) halotab.gal_type['sec_haloprop_percentile_max'] = ( grid[1][1:, :-1].ravel()) halotab.gal_type = vstack([halotab.gal_type, halotab.gal_type]) halotab.gal_type['gal_type'] = np.concatenate( (np.repeat('centrals'.encode('utf8'), len(halotab.gal_type) // 2), np.repeat('satellites'.encode('utf8'), len(halotab.gal_type) // 2))) halotab.gal_type['prim_haloprop'] = 10**( 0.5 * (halotab.gal_type['log_prim_haloprop_min'] + halotab.gal_type['log_prim_haloprop_max'])) halotab.gal_type['sec_haloprop_percentile'] = ( 0.5 * (halotab.gal_type['sec_haloprop_percentile_min'] + halotab.gal_type['sec_haloprop_percentile_max'])) # Now, we tabulate the correlation functions. cens_occ_model = Zheng07Cens(prim_haloprop_key=prim_haloprop_key) if cens_prof_model is None: cens_prof_model = TrivialPhaseSpace(redshift=halocat.redshift) sats_occ_model = Zheng07Sats(prim_haloprop_key=prim_haloprop_key) if sats_prof_model is None: sats_prof_model = NFWPhaseSpace(redshift=halocat.redshift) model = HodModelFactory(centrals_occupation=cens_occ_model, centrals_profile=cens_prof_model, satellites_occupation=sats_occ_model, satellites_profile=sats_prof_model) model.param_dict['logMmin'] = 0 model.param_dict['sigma_logM'] = 0.1 model.param_dict['alpha'] = 1.0 model.param_dict['logM0'] = 0 model.param_dict['logM1'] = -np.log10(sats_per_prim_haloprop) model.populate_mock(halocat, Num_ptcl_requirement=Num_ptcl_requirement) gals = model.mock.galaxy_table gals = gals[np.random.random(len(gals)) < downsample] idx_gals, idx_halos = crossmatch(gals['halo_id'], halos['halo_id']) assert np.all(gals['halo_id'][idx_gals] == halos['halo_id'][idx_halos]) gals[sec_haloprop_key + '_percentile'] = np.zeros(len(gals)) gals[sec_haloprop_key + '_percentile'][idx_gals] = (halos[sec_haloprop_key + '_percentile'][idx_halos]) if verbose: print("Number of tracer particles: {0}".format(len(gals))) for xyz in ['xyz', 'yzx', 'zxy']: pos_all = return_xyz_formatted_array( x=gals[xyz[0]], y=gals[xyz[1]], z=gals[xyz[2]], velocity=gals['v' + xyz[2]] if redshift_space_distortions else 0, velocity_distortion_dimension='z', period=halocat.Lbox, redshift=halocat.redshift, cosmology=cosmology) * lbox_stretch pos = [] n_gals = [] for i in range(len(halotab.gal_type)): mask = ((10**(halotab.gal_type['log_prim_haloprop_min'][i]) < gals[prim_haloprop_key]) & (10**(halotab.gal_type['log_prim_haloprop_max'][i]) >= gals[prim_haloprop_key]) & (halotab.gal_type['sec_haloprop_percentile_min'][i] < gals[sec_haloprop_key + '_percentile']) & (halotab.gal_type['sec_haloprop_percentile_max'][i] >= gals[sec_haloprop_key + '_percentile']) & (halotab.gal_type['gal_type'][i] == gals['gal_type'])) pos.append(pos_all[mask]) n_gals.append(np.sum(mask)) n_gals = np.array(n_gals) n_done = 0 if verbose: print("Projecting onto {0}-axis...".format(xyz[2])) gal_type_index = np.arange(len(halotab.gal_type)) if (comm is not None) & (has_mpi): size = comm.size rank = comm.rank gal_type_index = gal_type_index[rank::size] print('{}: len(gal_type_index)={}'.format( rank, len(gal_type_index))) elif (comm is not None) & (not has_mpi): raise (ImportError( "You passed something to the comm argument, but I couldn't import mpi4py" )) for i in gal_type_index: if mode == 'auto': for k in np.arange(i, len(halotab.gal_type)): if len(pos[i]) * len(pos[k]) > 0: if verbose: if comm: if comm.rank == 0: n_done += (n_gals[i] * n_gals[k] * (2 if k != i else 1)) print_progress(n_done / np.sum(n_gals)**2) else: n_done += (n_gals[i] * n_gals[k] * (2 if k != i else 1)) print_progress(n_done / np.sum(n_gals)**2) if i == k: xi = tpcf(pos[i], *tpcf_args, sample2=pos[k] if k != i else None, do_auto=True, do_cross=False, period=halocat.Lbox * lbox_stretch, **tpcf_kwargs) else: xi = tpcf(pos[i], *tpcf_args, sample2=pos[k] if k != i else None, do_auto=False, do_cross=True, period=halocat.Lbox * lbox_stretch, **tpcf_kwargs) if 'tpcf_matrix' not in locals(): tpcf_matrix = np.zeros( (len(xi.ravel()), len(halotab.gal_type), len(halotab.gal_type))) tpcf_shape = xi.shape tpcf_matrix[:, i, k] += xi.ravel() tpcf_matrix[:, k, i] = tpcf_matrix[:, i, k] elif mode == 'cross': if len(pos[i]) > 0: if verbose: n_done += n_gals[i] print_progress(n_done / np.sum(n_gals)) xi = tpcf(pos[i], *tpcf_args, **tpcf_kwargs, period=halocat.Lbox * lbox_stretch) if tpcf.__name__ == 'delta_sigma': xi = xi[1] if 'tpcf_matrix' not in locals(): tpcf_matrix = np.zeros( (len(xi.ravel()), len(halotab.gal_type))) tpcf_shape = xi.shape tpcf_matrix[:, i] = xi.ravel() if not project_xyz or mode == 'cross': break if comm: tpcf_matrix = comm.allreduce(tpcf_matrix, op=MPI.SUM) if project_xyz and mode == 'auto': tpcf_matrix /= 3.0 if mode == 'auto': tpcf_matrix_flat = [] for i in range(tpcf_matrix.shape[0]): tpcf_matrix_flat.append( symmetric_matrix_to_array(tpcf_matrix[i])) tpcf_matrix = np.array(tpcf_matrix_flat) halotab.attrs = {} halotab.attrs['tpcf'] = tpcf.__name__ halotab.attrs['mode'] = mode halotab.attrs['simname'] = halocat.simname halotab.attrs['redshift'] = halocat.redshift halotab.attrs['Num_ptcl_requirement'] = Num_ptcl_requirement halotab.attrs['prim_haloprop_key'] = prim_haloprop_key halotab.attrs['sec_haloprop_key'] = sec_haloprop_key halotab.tpcf_args = tpcf_args halotab.tpcf_kwargs = tpcf_kwargs halotab.tpcf_shape = tpcf_shape halotab.tpcf_matrix = tpcf_matrix halotab.init = True return halotab
def main(): # get simulation information if len(sys.argv)>1: sim_name = sys.argv[1] snapnum = int(sys.argv[2]) shape_type = sys.argv[3] sample_name = sys.argv[4] else: sim_name = 'TNG300-1' # full physics high-res run snapnum = 99 # z=0 shape_type = 'reduced' # non-reduced, reduced, iterative sample_name = 'sample_3' # load a test halo catalog from halotools.sim_manager import CachedHaloCatalog halocat = CachedHaloCatalog(simname='bolplanck', halo_finder='rockstar', redshift=0.0, dz_tol=0.1, version_name='halotools_v0p4') from halotools.empirical_models import HodModelFactory # define the central occupatoion model from halotools.empirical_models import TrivialPhaseSpace, Zheng07Cens cens_occ_model = Zheng07Cens() cens_prof_model = TrivialPhaseSpace() # define the satellite occupation model from halotools.empirical_models import Zheng07Sats from halotools.empirical_models import NFWPhaseSpace, SubhaloPhaseSpace from intrinsic_alignments.ia_models.anisotropic_nfw_phase_space import AnisotropicNFWPhaseSpace sats_occ_model = Zheng07Sats() #sats_prof_model = AnisotropicNFWPhaseSpace() sats_prof_model = SubhaloPhaseSpace('satellites', np.logspace(10.5, 15.2, 15)) # define the alignment models from intrinsic_alignments.ia_models.ia_model_components import CentralAlignment,\ RadialSatelliteAlignment, MajorAxisSatelliteAlignment, HybridSatelliteAlignment central_orientation_model = CentralAlignment() satellite_orientation_model = RadialSatelliteAlignment() if sample_name == 'sample_1': cens_occ_model.param_dict['logMmin'] = 12.54 cens_occ_model.param_dict['sigma_logM'] = 0.26 sats_occ_model.param_dict['alpha'] = 1.0 sats_occ_model.param_dict['logM0'] = 12.68 sats_occ_model.param_dict['logM1'] = 13.48 central_orientation_model.param_dict['central_alignment_strength'] = 0.755 satellite_orientation_model.param_dict['satellite_alignment_strength'] = 0.279 elif sample_name == 'sample_2': cens_occ_model.param_dict['logMmin'] = 11.93 cens_occ_model.param_dict['sigma_logM'] = 0.26 sats_occ_model.param_dict['alpha'] = 1.0 sats_occ_model.param_dict['logM0'] = 12.05 sats_occ_model.param_dict['logM1'] = 12.85 central_orientation_model.param_dict['central_alignment_strength'] = 0.64 satellite_orientation_model.param_dict['satellite_alignment_strength'] = 0.084 elif sample_name =='sample_3': cens_occ_model.param_dict['logMmin'] = 11.61 cens_occ_model.param_dict['sigma_logM'] = 0.26 sats_occ_model.param_dict['alpha'] = 1.0 sats_occ_model.param_dict['logM0'] = 11.8 sats_occ_model.param_dict['logM1'] = 12.6 central_orientation_model.param_dict['central_alignment_strength'] = 0.57172919 satellite_orientation_model.param_dict['satellite_alignment_strength'] = 0.01995 # combine model components model_instance = HodModelFactory(centrals_occupation = cens_occ_model, centrals_profile = cens_prof_model, satellites_occupation = sats_occ_model, satellites_profile = sats_prof_model, centrals_orientation = central_orientation_model, satellites_orientation = satellite_orientation_model, model_feature_calling_sequence = ( 'centrals_occupation', 'centrals_profile', 'satellites_occupation', 'satellites_profile', 'centrals_orientation', 'satellites_orientation') ) # populate mock catalog model_instance.populate_mock(halocat) print("number of galaxies: ", len(model_instance.mock.galaxy_table)) mock = model_instance.mock.galaxy_table # galaxy coordinates and orientations coords = np.vstack((mock['x'], mock['y'], mock['z'])).T orientations = np.vstack((mock['galaxy_axisA_x'], mock['galaxy_axisA_y'], mock['galaxy_axisA_z'])).T from halotools.mock_observables import tpcf, tpcf_jackknife rbins = np.logspace(-1,1.5,15) rbin_centers = (rbins[:-1]+rbins[1:])/2.0 xi = tpcf(coords, rbins, period=halocat.Lbox) err=np.zeros(len(xi)) # save measurements fpath = fpath = PROJECT_DIRECTORY + 'modelling_illustris/data/' fname = sim_name + '_' + str(snapnum) + '-' + sample_name +'_model_xi.dat' ascii.write([rbin_centers, xi, err], fpath+fname, names=['r','xi','err'], overwrite=True)
# 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) ################################################################################ # Initially populate both models halocat = CachedHaloCatalog(simname='bolplanck') __ = halocat.halo_table['halo_x'] std_model.populate_mock(halocat) ab_model.populate_mock(halocat) ################################################################################ np.seterr(divide='ignore', invalid='ignore') # ignore divide by zero in e.g. DD/RR def calculate_hod(halo_table, galaxy_table):
def main(): nu_cens = np.linspace(0,1,2) nu_sats = np.linspace(-0.3,0.8, 2) # get simulation information if len(sys.argv)>1: sim_name = sys.argv[1] snapnum = int(sys.argv[2]) shape_type = sys.argv[3] sample_name = sys.argv[4] else: sim_name = 'TNG300-1' # full physics high-res run snapnum = 99 # z=0 shape_type = 'reduced' # non-reduced, reduced, iterative sample_name = 'sample_3' # load a test halo catalog from halotools.sim_manager import CachedHaloCatalog halocat = CachedHaloCatalog(simname='bolplanck', halo_finder='rockstar', redshift=0.0, dz_tol=0.1, version_name='halotools_v0p4') from halotools.empirical_models import HodModelFactory # define the central occupatoion model from halotools.empirical_models import TrivialPhaseSpace, Zheng07Cens cens_occ_model = Zheng07Cens() cens_prof_model = TrivialPhaseSpace() # define the satellite occupation model from halotools.empirical_models import Zheng07Sats from halotools.empirical_models import NFWPhaseSpace, SubhaloPhaseSpace from intrinsic_alignments.ia_models.anisotropic_nfw_phase_space import AnisotropicNFWPhaseSpace sats_occ_model = Zheng07Sats() #sats_prof_model = AnisotropicNFWPhaseSpace() sats_prof_model = SubhaloPhaseSpace('satellites', np.logspace(10.5, 15.2, 15)) # define the alignment models from intrinsic_alignments.ia_models.ia_model_components import CentralAlignment,\ RadialSatelliteAlignment, MajorAxisSatelliteAlignment, HybridSatelliteAlignment central_orientation_model = CentralAlignment() satellite_orientation_model = RadialSatelliteAlignment() if sample_name == 'sample_1': cens_occ_model.param_dict['logMmin'] = 12.54 cens_occ_model.param_dict['sigma_logM'] = 0.26 sats_occ_model.param_dict['alpha'] = 1.0 sats_occ_model.param_dict['logM0'] = 12.68 sats_occ_model.param_dict['logM1'] = 13.48 central_orientation_model.param_dict['central_alignment_strength'] = 0.755 satellite_orientation_model.param_dict['satellite_alignment_strength'] = 0.279 elif sample_name == 'sample_2': cens_occ_model.param_dict['logMmin'] = 11.93 cens_occ_model.param_dict['sigma_logM'] = 0.26 sats_occ_model.param_dict['alpha'] = 1.0 sats_occ_model.param_dict['logM0'] = 12.05 sats_occ_model.param_dict['logM1'] = 12.85 central_orientation_model.param_dict['central_alignment_strength'] = 0.64 satellite_orientation_model.param_dict['satellite_alignment_strength'] = 0.084 elif sample_name =='sample_3': cens_occ_model.param_dict['logMmin'] = 11.61 cens_occ_model.param_dict['sigma_logM'] = 0.26 sats_occ_model.param_dict['alpha'] = 1.0 sats_occ_model.param_dict['logM0'] = 11.8 sats_occ_model.param_dict['logM1'] = 12.6 central_orientation_model.param_dict['central_alignment_strength'] = 0.57172919 satellite_orientation_model.param_dict['satellite_alignment_strength'] = 0.01995 # combine model components model_instance = HodModelFactory(centrals_occupation = cens_occ_model, centrals_profile = cens_prof_model, satellites_occupation = sats_occ_model, satellites_profile = sats_prof_model, centrals_orientation = central_orientation_model, satellites_orientation = satellite_orientation_model, model_feature_calling_sequence = ( 'centrals_occupation', 'centrals_profile', 'satellites_occupation', 'satellites_profile', 'centrals_orientation', 'satellites_orientation') ) from intrinsic_alignments.utils.jackknife_observables import jackknife_ed_3d from halotools.mock_observables.alignments import ed_3d rbins = np.logspace(-1,1.5,15) rbin_centers = (rbins[:-1]+rbins[1:])/2.0 N1 = len(nu_cens) N2 = len(nu_sats) fpath = fpath = PROJECT_DIRECTORY + 'modelling_illustris/data/' fname = sim_name + '_' + str(snapnum) + '-' + sample_name +'_model_ed_grid.dat' outF = open(fpath + fname, "w") for i in range(0,N1): for j in range(0,N2): print(i, j) # assign parameters central_orientation_model.param_dict['central_alignment_strength'] = nu_cens[i] satellite_orientation_model.param_dict['satellite_alignment_strength'] = nu_sats[j] # populate mock catalog start = time.time() model_instance.populate_mock(halocat) print("time to populate mock: ", time.time() - start) mock = model_instance.mock.galaxy_table # galaxy coordinates and orientations coords = np.vstack((mock['x'], mock['y'], mock['z'])).T orientations = np.vstack((mock['galaxy_axisA_x'], mock['galaxy_axisA_y'], mock['galaxy_axisA_z'])).T # calculate ED start = time.time() ed = ed_3d(coords, orientations,coords, rbins, period=halocat.Lbox, num_threads=4) print("time to calculate ED stat: ", time.time() - start) # calculate EE start = time.time() ee = ee_3d(coords, orientations, coords, orientations, rbins, period=halocat.Lbox, num_threads=4) print("time to calculate EE stat: ", time.time() - start) s = str(nu_cens[i]) + ' ' + str(nu_sats[j]) + ' ' + np.array_str(ed)[1:-1] + ' ' + np.array_str(ee)[1:-1] outF.write(s) outF.write("\n") outF.close()
def to_halotools(cosmo, redshift, mdef, concentration_key=None, **kwargs): """ Return the Zheng 07 HOD model. See :func:`halotools.empirical_models.zheng07_model_dictionary`. 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 Zheng07Sats, Zheng07Cens, NFWPhaseSpace, TrivialPhaseSpace from halotools.empirical_models import HodModelFactory 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 # occupation functions cenocc = Zheng07Cens(prim_haloprop_key=mass_key, **kwargs) satocc = Zheng07Sats(prim_haloprop_key=mass_key, cenocc_model=cenocc, **kwargs) satocc._suppress_repeated_param_warning = True # profile functions kwargs.update({'cosmology': cosmo, 'redshift': redshift, 'mdef': mdef}) censprof = TrivialPhaseSpace(**kwargs) satsprof = NFWPhaseSpace(conc_mass_model=conc_mass_model, **kwargs) # make the model model = {} model['centrals_occupation'] = cenocc model['centrals_profile'] = censprof model['satellites_occupation'] = satocc model['satellites_profile'] = satsprof return HodModelFactory(**model)
1.88033657e+00, 2.33929965e+00, 2.93594021e+00, 3.46849456e+00, 4.26576964e+00, 5.18755609e+00, 6.10833984e+00, 7.04389976e+00, 7.09565921e+00 ]]) err = np.sqrt(np.array([cov[i, i] for i in range(len(cov))])) bin_cen = (bin_edges[1:] + bin_edges[:-1]) / 2. cens_occ_model = Zheng07Cens(prim_haloprop_key='halo_vmax') cens_prof_model = TrivialPhaseSpace() sats_occ_model = Zheng07Sats(prim_haloprop_key='halo_vmax') sats_prof_model = NFWPhaseSpace() model_instance = HodModelFactory(centrals_occupation=cens_occ_model, centrals_profile=cens_prof_model, satellites_occupation=sats_occ_model, satellites_profile=sats_prof_model) halocat = CachedHaloCatalog(simname='bolplanck', redshift=0.0) model_instance.populate_mock(halocat) #log liklihood def lnlike(theta): #, wp_val, wperr, model_instance): logMmin, sigma_logM, alpha, logM0, logM1 = theta model_instance.param_dict['logMmin'] = logMmin model_instance.param_dict['sigma_logM'] = sigma_logM model_instance.param_dict['alpha'] = alpha model_instance.param_dict['logM0'] = logM0 model_instance.param_dict['logM1'] = logM1 model_instance.mock.populate()
lower_assembias_bound = 0, upper_assembias_bound = np.inf, **kwargs) cens_occ_model = Zheng07Cens(threshold = -21) cens_prof_model = TrivialPhaseSpace() from halotools.empirical_models import NFWPhaseSpace sats_occ_model = AssembiasZheng07Sats() sats_prof_model = NFWPhaseSpace() model_instance = HodModelFactory( centrals_occupation = cens_occ_model, centrals_profile = cens_prof_model, satellites_occupation = sats_occ_model, satellites_profile = sats_prof_model) model_instance.param_dict['mean_occupation_satellites_assembias_param1'] = -1. model_instance.populate_mock(simname = 'multidark') x = model_instance.mock.galaxy_table['x'] y = model_instance.mock.galaxy_table['y'] z = model_instance.mock.galaxy_table['z'] vz = model_instance.mock.galaxy_table['vz'] pos = return_xyz_formatted_array(x, y, z, velocity = vz, velocity_distortion_dimension = 'z')