def correlate_info(data1,data2, NBINS = NBINS, RMIN=1, RMAX=2, BOXSIZE = BOXSIZE, WRAP = WRAP): if data1 is not None: if RMAX is None: RMAX = BOXSIZE if WRAP: wrap_length = BOXSIZE else: wrap_length = None dataset1 = correlate.points(data1, boxsize = wrap_length) dataset2 = correlate.points(data2, boxsize = wrap_length) binning = correlate.RBinning(np.logspace(np.log10(RMIN),np.log10(RMAX),NBINS+1)) DD = correlate.paircount(dataset1,dataset2, binning, np=0) DD = DD.sum1 N=len(dataset1)-1 # if (sum(DD)!=N): # print data1,data2 return DD,N else: return None, None,None
def correlate_info(data, NBINS=NBINS, RMIN=RMIN, RMAX=RMAX, BOXSIZE=BOXSIZE, WRAP=WRAP): if data is not None: if RMAX is None: RMAX = BOXSIZE if WRAP: wrap_length = BOXSIZE else: wrap_length = None dataset = correlate.points(data, boxsize=wrap_length) binning = correlate.RBinning( np.logspace(np.log10(RMIN), np.log10(RMAX), NBINS + 1)) # RR=N**2*numpy.asarray([poiss(rbin[i],rbin[i+1]) for i in range(0,nbins)]) DD = correlate.paircount(dataset, dataset, binning, np=16) DD = DD.sum1 # print 'Done correlating' r = binning.centers return r, DD else: return None, None
def test_unweighted(): numpy.random.seed(1234) pos = numpy.random.uniform(size=(1000, 3)) pos1 = pos[:, None, :] pos2 = pos[None, :, :] dist = pos1 - pos2 dist[dist > 0.5] -= 1.0 dist[dist < -0.5] += 1.0 dist = numpy.einsum('ijk,ijk->ij', dist, dist)**0.5 dataset = correlate.points(pos, boxsize=1.0) # use the python point point counting binning = correlate.RBinning(numpy.linspace(0, 0.5, 10)) # use the C node node counting binning1 = correlate.FastRBinning(numpy.linspace(0, 0.5, 10)) dig = binning.edges.searchsorted(dist.flat, side='left') truth = numpy.bincount(dig) r = correlate.paircount(dataset, dataset, binning, np=0) assert_equal(r.sum1, truth[1:-1]) r1 = correlate.paircount(dataset, dataset, binning1, np=0) assert_equal(r1.sum1, truth[1:-1])
def test_cluster(): numpy.random.seed(1234) dec = numpy.arcsin(numpy.random.uniform(-1, 1, size=100000)) / numpy.pi * 180 ra = numpy.random.uniform(0, 2 * numpy.pi, size=100000) / numpy.pi * 180 # testing bootstrap for area, rand, in sphere.bootstrap(4, (ra, dec), 41252.96 / len(dec)): pass dataset = sphere.points(ra, dec) r = cluster.fof(dataset, 0.00001, np=None) assert r.N == len(dataset) binning = sphere.AngularBinning(numpy.linspace(0, 1.0, 10)) binningR = correlate.RBinning(binning.edges) r = correlate.paircount(dataset, dataset, binning=binning, usefast=True) r1 = correlate.paircount(dataset, dataset, binning=binning, usefast=False) r2 = correlate.paircount(dataset, dataset, binning=binningR, usefast=True) assert_equal(r1.sum1, r2.sum1) assert_equal(r1.sum1, r.sum1) assert_allclose( r.sum1, numpy.diff(2 * numpy.pi * (1 - numpy.cos(numpy.radians(binning.angular_edges)))) / ( 4 * numpy.pi) * len(ra) ** 2, rtol=10e-2)
def test_simple(): numpy.random.seed(1234) pos = numpy.random.uniform(size=(10, 3)) dataset = correlate.points(pos, boxsize=1.0) binning = correlate.RBinning(numpy.linspace(0.5, 10)) r = correlate.paircount(dataset, dataset, binning, np=0) r1 = correlate.paircount(dataset, dataset, binning, usefast=True, np=0) assert_equal( r.sum1, r1.sum1)
def test_field(): numpy.random.seed(1234) pos = numpy.random.uniform(size=(1000, 3)) dataset = correlate.field(pos, value=numpy.ones(len(pos)), boxsize=1.0, weights=numpy.ones(len(pos))) binning = correlate.RBinning(numpy.linspace(0, 0.5, 10)) r = correlate.paircount(dataset, dataset, binning, np=0) assert_allclose(r.sum1, r.sum2)
def test_weighted(): numpy.random.seed(1234) pos = numpy.random.uniform(size=(1000, 3)) datasetw = correlate.points(pos, boxsize=1.0, weights=numpy.ones(len(pos))) dataset = correlate.points(pos, boxsize=1.0) binning = correlate.RBinning(numpy.linspace(0, 0.5, 10)) r = correlate.paircount(datasetw, datasetw, binning, np=0) r1 = correlate.paircount(dataset, dataset, binning, np=0) assert_equal(r.sum1, r1.sum1)
def reference_2pcf_s(sedges,position1,weight1,position2=None,weight2=None): """Reference pair counting via kdcount""" tree1 = correlate.points(position1,boxsize=None,weights=weight1) factor = 1. if position2 is None: tree2 = tree1 factor = 1./2. else: tree2 = correlate.points(position2,boxsize=None,weights=weight2) bins = correlate.RBinning(np.asarray(sedges)) pc = correlate.paircount(tree1,tree2,bins,np=0,usefast=False,compute_mean_coords=True) return factor*pc.sum1
def test_simple(): numpy.random.seed(1234) pos = numpy.random.uniform(size=(10, 3)) dataset = correlate.points(pos, boxsize=1.0) # use the python point point counting binning = correlate.RBinning(numpy.linspace(0, 0.5, 10)) # use the C node node counting binning1 = correlate.FastRBinning(numpy.linspace(0, 0.5, 10)) r = correlate.paircount(dataset, dataset, binning, np=0) r1 = correlate.paircount(dataset, dataset, binning1, np=0) assert_equal(r.sum1, r1.sum1)
def test_cross(): numpy.random.seed(1234) pos1 = numpy.random.uniform(size=(10000, 2)) pos2 = numpy.random.uniform(size=(10000, 2)) * 0.3 dataset1 = correlate.points(pos1, boxsize=None) dataset2 = correlate.points(pos2, boxsize=None) binning = correlate.RBinning(numpy.linspace(0, 0.1, 10)) r1 = correlate.paircount(dataset1, dataset2, binning, np=0, usefast=False) r2 = correlate.paircount(dataset1, dataset2, binning, np=0, usefast=True) assert_equal(r1.sum1, r2.sum1) r3 = correlate.paircount(dataset1, dataset2, binning, np=4, usefast=False) assert_equal(r1.sum1, r3.sum1) r4 = correlate.paircount(dataset1, dataset2, binning, np=4, usefast=True) assert_equal(r1.sum1, r4.sum1)
def test_paircount(): numpy.random.seed(1234) data = 1.0 * ((-numpy.arange(4).reshape(-1, 1)) % 2) data = correlate.points(data) bsfun = lambda x: numpy.int32(x.pos[:, 0]) policy = bootstrap.policy(bsfun, data) binning=correlate.RBinning(numpy.linspace(0, 100, 2, endpoint=True)) def estimator( x, y): r = correlate.paircount(x, y, binning, np=0) return r.fullsum1 result = policy.run(estimator, data, data) L, R = policy.resample(result, numpy.arange(2)) assert_array_equal(L, (4, 4)) assert_array_equal(R, (8, 8, 0))
def reference_paircount(pos1, w1, redges, boxsize, pos2=None, w2=None, los=2): """Reference pair counting via kdcount""" # make the trees tree1 = correlate.points(pos1, boxsize=boxsize, weights=w1) if pos2 is None: tree2 = tree1 else: tree2 = correlate.points(pos2, boxsize=boxsize, weights=w2) # do the paircount bins = correlate.RBinning(redges) pc = correlate.paircount(tree1, tree2, bins, np=0, compute_mean_coords=True) return numpy.nan_to_num(pc.pair_counts), numpy.nan_to_num( pc.mean_centers), pc.sum1
def test_channels(): numpy.random.seed(1234) pos = numpy.random.uniform(size=(1000, 3)) datasetw = correlate.points(pos, boxsize=1.0, weights=numpy.ones(len(pos))) dataset = correlate.points(pos, boxsize=1.0) binning_mc1 = correlate.FlatSkyMultipoleBinning(numpy.linspace(0, 0.5, 10), ells=[0, 0, 0], los=0) binning_mc2 = correlate.MultipoleBinning(numpy.linspace(0, 0.5, 10), ells=[0, 0, 0]) binning = correlate.RBinning(numpy.linspace(0, 0.5, 10)) r_mc1 = correlate.paircount(datasetw, datasetw, binning_mc1, np=0) r_mc2 = correlate.paircount(datasetw, datasetw, binning_mc2, np=0) r1 = correlate.paircount(dataset, dataset, binning, np=0) assert_equal(r_mc1.sum1[0], r1.sum1) assert_equal(r_mc2.sum1[0], r1.sum1)
def test_cross(): numpy.random.seed(1234) pos1 = numpy.random.uniform(size=(10000, 2)) pos2 = numpy.random.uniform(size=(10000, 2)) * 0.3 dataset1 = correlate.points(pos1, boxsize=None) dataset2 = correlate.points(pos2, boxsize=None) # use the python point point counting binning = correlate.RBinning(numpy.linspace(0, 0.5, 10)) # use the C node node counting binning1 = correlate.FastRBinning(numpy.linspace(0, 0.5, 10)) r1 = correlate.paircount(dataset1, dataset2, binning, np=0) r2 = correlate.paircount(dataset1, dataset2, binning1, np=0) assert_equal(r1.sum1, r2.sum1) r3 = correlate.paircount(dataset1, dataset2, binning, np=4) assert_equal(r1.sum1, r3.sum1) r4 = correlate.paircount(dataset1, dataset2, binning1, np=4) assert_equal(r1.sum1, r4.sum1)
def test_cluster(): numpy.random.seed(1234) dec = numpy.arcsin(numpy.random.uniform(-1, 1, size=100000)) / numpy.pi * 180 ra = numpy.random.uniform(0, 2 * numpy.pi, size=100000) / numpy.pi * 180 # testing bootstrap for area, rand, in sphere.bootstrap(4, (ra, dec), 41252.96 / len(dec)): pass dataset = sphere.points(ra, dec) r = cluster.fof(dataset, 0.00001, np=None) assert r.N == len(dataset) binning = sphere.FastAngularBinning(numpy.linspace(0, 1.0, 10)) binning1 = sphere.AngularBinning(numpy.linspace(0, 1.0, 10)) binningR = correlate.RBinning(binning.edges) r = correlate.paircount(dataset, dataset, binning=binning) r1 = correlate.paircount(dataset, dataset, binning=binning1, compute_mean_coords=True) r2 = correlate.paircount(dataset, dataset, binning=binningR) # make sure mean_centers compute angular centers for i, val in enumerate(r1.mean_centers): assert binning.angular_edges[i] < val < binning.angular_edges[i + 1] assert_equal(r1.sum1, r2.sum1) assert_equal(r1.sum1, r.sum1) assert_allclose( r.sum1, numpy.diff(2 * numpy.pi * (1 - numpy.cos(numpy.radians(binning.angular_edges)))) / (4 * numpy.pi) * len(ra)**2, rtol=10e-2)
def main(): comm = MPI.COMM_WORLD SNAP, LABEL = None, None if comm.rank == 0: SNAP = files.Snapshot(ns.snapfilename, files.TPMSnapshotFile) LABEL = files.Snapshot(ns.halolabel, files.HaloLabelFile) SNAP = comm.bcast(SNAP) LABEL = comm.bcast(LABEL) Ntot = sum(SNAP.npart) assert Ntot == sum(LABEL.npart) h = files.HaloFile(ns.halocatalogue) N = h.read_mass() N0 = Ntot - sum(N[1:]) # halos are assigned to ranks 0, 1, 2, 3 ... halorank = numpy.arange(len(N)) % comm.size # but non halos are special we will fix it later. halorank[0] = -1 NonhaloStart = comm.rank * int(N0) // comm.size NonhaloEnd = (comm.rank + 1) * int(N0) // comm.size myNtotal = numpy.sum(N[halorank == comm.rank], dtype='i8') + (NonhaloEnd - NonhaloStart) print("Rank %d NonhaloStart %d NonhaloEnd %d myNtotal %d" % (comm.rank, NonhaloStart, NonhaloEnd, myNtotal)) data = numpy.empty(myNtotal, dtype=[ ('Position', ('f4', 3)), ('Label', ('i4')), ('Rank', ('i4')), ]) allNtotal = comm.allgather(myNtotal) start = sum(allNtotal[:comm.rank]) end = sum(allNtotal[:comm.rank + 1]) data['Position'] = SNAP.read("Position", start, end) data['Label'] = LABEL.read("Label", start, end) data['Rank'] = halorank[data['Label']] # now assign ranks to nonhalo particles nonhalomask = (data['Label'] == 0) nonhalocount = comm.allgather(nonhalomask.sum()) data['Rank'][nonhalomask] = (sum(nonhalocount[:comm.rank]) + numpy.arange(nonhalomask.sum())) % comm.size mpsort.sort(data, orderby='Rank') arg = data['Label'].argsort() data = data[arg] ul = numpy.unique(data['Label']) bins = correlate.RBinning(40. / ns.boxsize, Nbins=ns.Nmesh) sum1 = numpy.zeros(len(bins.centers)) for l in ul: if l == 0: continue start = data['Label'].searchsorted(l, side='left') end = data['Label'].searchsorted(l, side='right') pos = data['Position'][start:end] dataset = correlate.points(pos, boxsize=1.0) result = correlate.paircount(dataset, dataset, bins, np=0) sum1 += result.sum1 if l % 1000 == 0: print l sum1 = comm.allreduce(sum1, MPI.SUM) Ntot = sum(SNAP.npart) RR = 4. / 3 * numpy.pi * numpy.diff(bins.edges**3) * (1.0 * Ntot * Ntot) k = numpy.arange(ns.Nmesh // 2) * 2 * numpy.pi / ns.boxsize # asymtotically zero at r. The mean doesn't matter as # we don't use zero k mode anyways. k, p = corrfrompower(bins.centers * ns.boxsize, sum1 / RR, R=k) # inverse FT factor p *= (2 * numpy.pi)**3 if comm.rank == 0: if ns.output != '-': ff = open(ns.output, 'w') ff2 = open(ns.output + '.xi', 'w') with ff2: numpy.savetxt(ff2, zip(bins.centers, sum1 / RR - 1.0)) else: ff = stdout with ff: # numpy.savetxt(ff, zip(bins.centers, sum1 / RR - 1.0)) numpy.savetxt(ff, zip(k, p))
def compute_brutal_corr(datasources, redges, Nmu=0, comm=None, subsample=1, los='z', poles=[]): r""" Compute the correlation function by direct pair summation, either as a function of separation (`R`) or as a function of separation and line-of-sight angle (`R`, `mu`) The estimator used to compute the correlation function is: .. math:: \xi(r, \mu) = DD(r, \mu) / RR(r, \mu) - 1. where `DD` is the number of data-data pairs, and `RR` is the number of random-random pairs, which is determined solely by the binning used, assuming a constant number density Parameters ---------- datasources : list of DataSource objects the list of data instances from which the 3D correlation will be computed redges : array_like the bin edges for the `R` variable Nmu : int, optional the number of desired `mu` bins, where `mu` is the cosine of the angle from the line-of-sight. Default is `0`, in which case the correlation function is binned as a function of `R` only comm : MPI.Communicator, optional the communicator to pass to the ``ParticleMesh`` object. If not provided, ``MPI.COMM_WORLD`` is used subsample : int, optional downsample the input datasources by choosing 1 out of every `N` points. Default is `1` (no subsampling). los : str, {'x', 'y', 'z'}, optional the dimension to treat as the line-of-sight; default is 'z'. poles : list of int, optional integers specifying the multipoles to compute from the 2D correlation function Returns ------- pc : :class:`kdcount.correlate.paircount` the pair counting instance xi : array_like the correlation function result; if `poles` supplied, the shape is `(len(redges)-1, len(poles))`, otherwise, the shape is either `(len(redges)-1, )` or `(len(redges)-1, Nmu)` RR : array_like the number of random-random pairs (used as normalization of the data-data pairs) """ from pmesh.domain import GridND from kdcount import correlate # some setup if los not in "xyz": raise ValueError("`los` must be `x`, `y`, or `z`") los = "xyz".index(los) poles = numpy.array(poles) Rmax = redges[-1] if comm is None: comm = MPI.COMM_WORLD # determine processor division for domain decomposition for Nx in range(int(comm.size**0.3333) + 1, 0, -1): if comm.size % Nx == 0: break else: Nx = 1 for Ny in range(int(comm.size**0.5) + 1, 0, -1): if (comm.size // Nx) % Ny == 0: break else: Ny = 1 Nz = comm.size // Nx // Ny Nproc = [Nx, Ny, Nz] # log some info if comm.rank == 0: logger.info('Nproc = %s' % str(Nproc)) logger.info('Rmax = %g' % Rmax) # domain decomposition grid = [ numpy.linspace(0, datasources[0].BoxSize[i], Nproc[i] + 1, endpoint=True) for i in range(3) ] domain = GridND(grid, comm=comm) # read position for field #1 with datasources[0].open() as stream: [[pos1]] = stream.read(['Position'], full=True) pos1 = pos1[comm.rank * subsample // comm.size::subsample] N1 = comm.allreduce(len(pos1)) # read position for field #2 if len(datasources) > 1: with datasources[1].open() as stream: [[pos2]] = stream.read(['Position'], full=True) pos2 = pos2[comm.rank * subsample // comm.size::subsample] N2 = comm.allreduce(len(pos2)) else: pos2 = pos1 N2 = N1 # exchange field #1 positions layout = domain.decompose(pos1, smoothing=0) pos1 = layout.exchange(pos1) if comm.rank == 0: logger.info('exchange pos1') # exchange field #2 positions if Rmax > datasources[0].BoxSize[0] * 0.25: pos2 = numpy.concatenate(comm.allgather(pos2), axis=0) else: layout = domain.decompose(pos2, smoothing=Rmax) pos2 = layout.exchange(pos2) if comm.rank == 0: logger.info('exchange pos2') # initialize the trees to hold the field points tree1 = correlate.points(pos1, boxsize=datasources[0].BoxSize) tree2 = correlate.points(pos2, boxsize=datasources[0].BoxSize) # log the sizes of the trees logger.info('rank %d correlating %d x %d' % (comm.rank, len(tree1), len(tree2))) if comm.rank == 0: logger.info('all correlating %d x %d' % (N1, N2)) # use multipole binning if len(poles): bins = correlate.FlatSkyMultipoleBinning(redges, poles, los, compute_mean_coords=True) # use (R, mu) binning elif Nmu > 0: bins = correlate.FlatSkyBinning(redges, Nmu, los, compute_mean_coords=True) # use R binning else: bins = correlate.RBinning(redges, compute_mean_coords=True) # do the pair counting # have to set usefast = False to get mean centers, or exception thrown pc = correlate.paircount(tree2, tree1, bins, np=0, usefast=False) pc.sum1[:] = comm.allreduce(pc.sum1) # get the mean bin values, reducing from all ranks pc.pair_counts[:] = comm.allreduce(pc.pair_counts) with numpy.errstate(invalid='ignore'): if bins.Ndim > 1: for i in range(bins.Ndim): pc.mean_centers[i][:] = comm.allreduce( pc.mean_centers_sum[i]) / pc.pair_counts else: pc.mean_centers[:] = comm.allreduce( pc.mean_centers_sum[0]) / pc.pair_counts # compute the random pairs from the fractional volume RR = 1. * N1 * N2 / datasources[0].BoxSize.prod() if Nmu > 0: dr3 = numpy.diff(pc.edges[0]**3) dmu = numpy.diff(pc.edges[1]) RR *= 2. / 3. * numpy.pi * dr3[:, None] * dmu[None, :] else: RR *= 4. / 3. * numpy.pi * numpy.diff(pc.edges**3) # return the correlation and the pair count object xi = (1. * pc.sum1 / RR) - 1.0 if len(poles): xi = xi.T # makes ell the second axis xi[:, poles != 0] += 1.0 # only monopole gets the minus one return pc, xi, RR
HM = galaxy.open('galaxy_host_mass')[:] hostid = galaxy.open('galaxy_host_id')[:] tag = galaxy.open('central_satellite_tag')[:] galaxy_positions = galaxy.open('galaxy_center_of_mass')[:] lcuts = numpy.array([7.5, 8.0, 8.5, 9.0, 9.5, 10.0, 10.5]) lcuts += 0.25 for lcut in reversed(lcuts): mask = SM > 10**lcut data_s = galaxy_positions[mask] N = len(data_s) r, DD = correlate_info(data_s) binning = correlate.RBinning( np.logspace(np.log10(RMIN), np.log10(RMAX), NBINS + 1)) rbin = binning.edges RR = (N**2 - N) * np.asarray( [poiss(rbin[i], rbin[i + 1]) for i in range(0, NBINS)]) xi = DD / RR - 1 dxi = np.sqrt(DD) / RR r = binning.centers label_DD = './galaxy_correlation_functions/DD_z-%.1f_SM_cut_galaxy_COM.pickle' % ( z) label_xi = './galaxy_correlation_functions/xi_z%.1f_%.1f_SM_cut_galaxy_COM.pickle' % ( z, lcut) pickle.dump([r, DD], open(label_DD, 'w')) pickle.dump([r, xi, dxi, N], open(label_xi, 'w'))
def get_halo_density_profile(output_path, p_type, desired_redshift_of_selected_halo, index_of_selected_halo, min_edge, max_edge, Nbins, CENTER_AROUND='POTENTIAL_MINIMUM', p_id=0): from kdcount import correlate def min_dis(median_position, position, box_size): pos_1 = position - median_position pos_2 = position - median_position + boxsize pos_3 = position - median_position - boxsize new_position_options = numpy.array([pos_1, pos_2, pos_3]) get_minimum_distance = numpy.argmin(numpy.abs(new_position_options)) return new_position_options[get_minimum_distance] boxsize = get_box_size(output_path) particle_property = 'Position' group_positions, output_redshift = get_particle_property_within_groups( output_path, particle_property, p_type, desired_redshift_of_selected_halo, index_of_selected_halo) particle_property = 'Mass' group_mass, output_redshift = get_particle_property_within_groups( output_path, particle_property, p_type, desired_redshift_of_selected_halo, index_of_selected_halo) particle_property = 'Potential' group_potential, output_redshift = get_particle_property_within_groups( output_path, particle_property, p_type, desired_redshift_of_selected_halo, index_of_selected_halo) if (CENTER_AROUND == 'MOST_MASSIVE_BLACKHOLE'): particle_property = 'ID' bh_IDs, output_redshift = get_particle_property_within_groups( output_path, particle_property, 5, desired_redshift_of_selected_halo, index_of_selected_halo) particle_property = 'Position' bh_positions, output_redshift = get_particle_property_within_groups( output_path, particle_property, 5, desired_redshift_of_selected_halo, index_of_selected_halo) particle_property = 'BlackholeMass' bh_masses, output_redshift = get_particle_property_within_groups( output_path, particle_property, 5, desired_redshift_of_selected_halo, index_of_selected_halo) print("Calculating density around BH with ID:", (bh_IDs[bh_masses == numpy.amax(bh_masses)])[0]) center = (bh_positions[bh_masses == numpy.amax(bh_masses)])[0] if (CENTER_AROUND == 'POTENTIAL_MINIMUM'): center = ( group_positions[group_potential == numpy.amin(group_potential)])[0] transposed_group_positions = numpy.transpose(group_positions) vectorized_min_dis = numpy.vectorize(min_dis) x_dis = vectorized_min_dis(center[0], transposed_group_positions[0], boxsize) y_dis = vectorized_min_dis(center[1], transposed_group_positions[1], boxsize) z_dis = vectorized_min_dis(center[2], transposed_group_positions[2], boxsize) log_distances = numpy.log10(numpy.sqrt(x_dis**2 + y_dis**2 + z_dis**2)) log_distance_bins = numpy.linspace(min_edge, max_edge, Nbins) binning = correlate.RBinning(log_distance_bins) bin_edges = binning.edges bin_centers = binning.centers mass_distribution = [] for i in range(0, len(bin_edges) - 1): left = bin_edges[i] right = bin_edges[i + 1] mask = (log_distances > left) & (log_distances < right) mass_inside_bin = numpy.sum(group_mass[mask]) mass_distribution.append(mass_inside_bin) mass_distribution = numpy.array(mass_distribution) mass_density = mass_distribution / 4. / 3.14 / (10**bin_centers)**3 / ( (numpy.diff(bin_centers))[0]) / numpy.log(10) return bin_centers, mass_distribution, mass_density
def poiss(rmin,rmax): p=4./3*scipy.pi*(rmax**3-rmin**3)/BOXSIZE**3 return p rho_crit=2.775e11 mids=[12.5,12.0,11.5,11.0] lcuts=[41,41.5,42,42.5,43,43.5,44,44.5] width=0.25 for snapshot in reversed(snapshots): for mid in mids: for lcut in lcuts: rvir=(10**mid/(4./3*3.14*200*rho_crit*0.2814))**(1./3) DD,N=construct_halo_mass_bin(snapshot) y_cen=correlate.RBinning(y_space).centers dy=y_cen*numpy.diff(numpy.log(y_cen))[0] dr=rvir*dy r_cen=rvir*y_cen pre_factor=4.*3.14 # print da # print sum(no_of_sat) density=DD/dr/r_cen**2/pre_factor density_err=numpy.sqrt(DD)/dr/r_cen**2/pre_factor pickle.dump([y_cen,r_cen,DD,density,density_err,Nhalo],open('raw_satellite_histograms_z_%.2f_mid_%.1f_lcut_%.1f.pickle'%(z,mid,lcut),'w'))