def mk_mock_srch(radecfile, nzdictfile, Nsph, simul_cosmo): if simul_cosmo == "Planck": # First make h free Planck13.__init__(100.0, Planck13.Om0) cosmo = Planck13 elif simul_cosmo == "WMAP": WMAP5.__init__(100.0, WMAP5.Om0) cosmo = WMAP5 comv = cosmo.comoving_distance radecarr = h5_arr(radecfile, "good_pts") nzdict = json.load(open(nzdictfile)) Nrands = radecarr.shape[0] Narrs = Nsph / Nrands remain = Nsph % Nrands radecz = np.zeros((Nsph, 3)) for i in range(Narrs): start = Nrands * i stop = Nrands * (i + 1) radecz[start:stop, :2] = radecarr[:, :] endchunk = Nrands * (Narrs) radecz[endchunk:, :2] = radecarr[:remain, :] rad = np.arange(1.0, 67.0, 5.0) zlo = nzdict["zlo"] zhi = nzdict["zhi"] radeczlist = len(rad) * [radecz] for r_i, r in enumerate(rad): dis_near = Distance(comv(zlo).value + r, u.Mpc) dis_far = Distance(comv(zhi).value - r, u.Mpc) z_a = dis_near.compute_z(cosmology=cosmo) z_b = dis_far.compute_z(cosmology=cosmo) randz = (z_a ** 3 + \ (z_b ** 3 - z_a ** 3) * np.random.rand(Nsph)) ** (1. / 3.) radeczlist[r_i][:, 2] = randz[:] arr2h5( radeczlist[r_i], "{0}/{1}/mocks/mock_srch_pts.hdf5".format( os.path.dirname(radecfile), simul_cosmo), "radecz_{0}".format(str(r_i * 5 + 1)))
def __Redshift__(self, verbose=False): ZType = 0 # Scrapping the redshift for line in self.gcn[5:]: try: tempZ = re.findall("(z\s?=|redshift.of.about)\s?([0-9.]+)\s?\+?\/?\-?\s?([0-9.]+)?", line)[0][1:] if "mag" not in line: ZType = 1 if verbose==3: print("Redshift is adopted from \n'{}'".format(line)) except: try: tempZ = re.findall("estimate is ([0-9.]+)\s?\+?\/?\-?\s?([0-9.]+)?\s?(Mpc|kpc)", line)[0] ZType = 2 if verbose==3: print("Redshift is adopted from \n'{}'".format(line)) except: pass # Rearrange the redshift if ZType == 1: if tempZ[0][-1] == ".": z = tempZ[0][:-1] else: z = tempZ[0] if tempZ[1] == "": zerr = 1/10**len(str(tempZ[0]).split(".")[1]) elif tempZ[1][-1] == ".": zerr = tempZ[1][:-1] else: zerr = tempZ[1] self.Redshift = ['{:.4f}'.format(float(z)), float(zerr)] elif ZType == 2: if tempZ[2] == 'Mpc': unit = u.Mpc elif tempZ[2] == 'kpc': unit = u.kpc d0 = Distance(float(tempZ[0]), unit=unit) z0 = d0.compute_z() derr1 = Distance(float(tempZ[0])+float(tempZ[1]), unit=unit) zerr1 = derr1.compute_z() derr2 = Distance(float(tempZ[0])-float(tempZ[1]), unit=unit) zerr2 = derr2.compute_z() zerr = max(abs(zerr1-z0), abs(z0-zerr2)) self.Redshift = ['{:.4f}'.format(z0), zerr]
def mk_mock_srch(radecfile, nzdictfile, Nsph, simul_cosmo): if simul_cosmo == "Planck": # First make h free Planck13.__init__(100.0, Planck13.Om0) cosmo = Planck13 elif simul_cosmo == "WMAP": WMAP5.__init__(100.0, WMAP5.Om0) cosmo = WMAP5 comv = cosmo.comoving_distance radecarr = h5_arr(radecfile, "good_pts") nzdict = json.load(open(nzdictfile)) Nrands = radecarr.shape[0] Narrs = Nsph / Nrands remain = Nsph % Nrands radecz = np.zeros((Nsph, 3)) for i in range(Narrs): start = Nrands * i stop = Nrands * (i + 1) radecz[start:stop, :2] = radecarr[:, :] endchunk = Nrands * (Narrs) radecz[endchunk:, :2] = radecarr[:remain, :] rad = np.arange(1.0, 67.0, 5.0) zlo = nzdict["zlo"] zhi = nzdict["zhi"] radeczlist = len(rad) * [radecz] for r_i, r in enumerate(rad): dis_near = Distance(comv(zlo) + r, u.Mpc) dis_far = Distance(comv(zhi) - r, u.Mpc) z_a = dis_near.compute_z(cosmology=cosmo) z_b = dis_far.compute_z(cosmology=cosmo) randz = (z_a ** 3 + \ (z_b ** 3 - z_a ** 3) * np.random.rand(Nsph)) ** (1. / 3.) radeczlist[r_i][:, 2] = randz[:] arr2h5(radeczlist[r_i], "{0}/{1}/mocks/mock_srch_pts.hdf5".format(os.path.dirname(radecfile), simul_cosmo), "radecz_{0}".format(str(r_i * 5 + 1)))
def get_pc_per_arcsec(distance, cosmo=WMAP9): """ Args: distance: float Distance in Mpc cosmo: astropy.cosmology Cosmology. Default is None: will then use the default_cosmology from astropy Returns: pc_per_arcsec: float Conversion parsec per arcsecond """ from astropy.cosmology import default_cosmology from astropy.coordinates import Distance from astropy import units as u # Use default cosmology from astropy if cosmo is None: cosmo = default_cosmology.get() # Use astropy units dist = Distance(distance, u.Mpc) # get the corresponding redshift redshift = dist.compute_z(cosmo) # And nore the proper conversion kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(redshift) return kpc_per_arcmin.to(u.pc / u.arcsec)
def test_distances_scipy(): """ The distance-related tests that require scipy due to the cosmology module needing scipy integration routines """ from astropy.cosmology import WMAP5 # try different ways to initialize a Distance d4 = Distance(z=0.23) # uses default cosmology - as of writing, WMAP7 npt.assert_allclose(d4.z, 0.23, rtol=1e-8) d5 = Distance(z=0.23, cosmology=WMAP5) npt.assert_allclose(d5.compute_z(WMAP5), 0.23, rtol=1e-8) d6 = Distance(z=0.23, cosmology=WMAP5, unit=u.km) npt.assert_allclose(d6.value, 3.5417046898762366e+22) with pytest.raises(ValueError): Distance(cosmology=WMAP5, unit=u.km) with pytest.raises(ValueError): Distance() # vectors! regression test for #11949 d4 = Distance(z=[0.23, 0.45]) # as of writing, Planck18 npt.assert_allclose(d4.z, [0.23, 0.45], rtol=1e-8)
def dist_to_z(D): return Distance.compute_z(D, cosmo)
def main(self): is_error = False # Parameter checks if self.options.gw_id == "": is_error = True print("GWID is required.") if self.options.healpix_file == "": is_error = True print("Healpix file is required.") if is_error: print("Exiting...") return 1 formatted_healpix_dir = self.options.healpix_dir if "{GWID}" in formatted_healpix_dir: formatted_healpix_dir = formatted_healpix_dir.replace( "{GWID}", self.options.gw_id) formatted_model_output_dir = self.options.model_output_dir if "{GWID}" in formatted_model_output_dir: formatted_model_output_dir = formatted_model_output_dir.replace( "{GWID}", self.options.gw_id) hpx_path = "%s/%s" % (formatted_healpix_dir, self.options.healpix_file) model_path = "../Models" model_files = [] for file in os.listdir(model_path): if file.endswith(".dat"): model_files.append("%s/%s" % (model_path, file)) if len(model_files) <= 0: is_error = True print("There are no models to process.") # Check if the above files exist... if not os.path.exists(hpx_path): is_error = True print("Healpix file `%s` does not exist." % hpx_path) if is_error: print("Exiting...") return 1 # CONVENIENCE DICTIONARIES # Band abbreviation, band_id mapping band_mapping_new = { "sdss_g": "SDSS g", "sdss_r": "SDSS r", "sdss_i": "SDSS i", "Clear": "Clear" } reverse_band_mapping_new = { "SDSS g": "sdss_g", "SDSS r": "sdss_r", "SDSS i": "sdss_i", "Clear": "Clear" } detector_mapping = { "s": "SWOPE", "t": "THACHER", "a": "ANDICAM", "n": "NICKEL", "m": "MOSFIRE", "k": "KAIT", "si": "SINISTRO" } # LOADING NSIDE 128 SKY PIXELS AND EBV INFORMATION print("\nLoading NSIDE 128 pixels...") nside128 = 128 N128_dict = None with open('N128_dict.pkl', 'rb') as handle: N128_dict = pickle.load(handle) del handle print("\nLoading existing EBV...") ebv = None with open('ebv.pkl', 'rb') as handle: ebv = pickle.load(handle) models = {} for mf in model_files: model_table = Table.read(mf, format='ascii.ecsv') mask = model_table['time'] > 0.0 time = np.asarray(model_table['time'][mask]) g = np.asarray(model_table['sdss_g'][mask]) r = np.asarray(model_table['sdss_r'][mask]) i = np.asarray(model_table['sdss_i'][mask]) clear = np.asarray(model_table['Clear'][mask]) model_props = model_table.meta['comment'] mass = float(re.findall("\d+\.\d+", model_props[1])[0]) velocity = float(re.findall("\d+\.\d+", model_props[2])[0]) factor = float(re.findall("(\d+\.?\d?)[e+\-]", model_props[3])[0]) exp = float(re.findall("[e+\-](-+\d+\.?\d+)", model_props[3])[0]) Xlan = factor * 10**(exp) base_name = os.path.basename(mf) print("Loading `%s`" % base_name) models[(base_name, mass, velocity, Xlan)] = { 'time': time, 'sdss_g': g, 'sdss_r': r, 'sdss_i': i, 'Clear': clear } # Get Map ID print("\nLoading Healpix Map...") healpix_map_select = "SELECT id, NSIDE FROM HealpixMap WHERE GWID = '%s' and Filename = '%s'" healpix_map_id = int( query_db([ healpix_map_select % (self.options.gw_id, self.options.healpix_file) ])[0][0][0]) healpix_map_nside = int( query_db([ healpix_map_select % (self.options.gw_id, self.options.healpix_file) ])[0][0][1]) # Get Bands print("\nLoading Configured Bands...") band_select = "SELECT id, Name, F99_Coefficient FROM Band" bands = query_db([band_select])[0] band_dict_by_name = {} band_dict_by_id = {} for b in bands: b_id = int(b[0]) b_name = b[1] b_coeff = float(b[2]) band_dict_by_name[b_name] = (b_id, b_name, b_coeff) band_dict_by_id[b_id] = (b_id, b_name, b_coeff) print("\nRetrieving distinct, imaged map pixels") map_pixel_select = ''' SELECT DISTINCT hp.id, hp.HealpixMap_id, hp.Pixel_Index, hp.Prob, hp.Distmu, hp.Distsigma, hp.Distnorm, hp.Mean, hp.Stddev, hp.Norm, sp.Pixel_Index as N128_Pixel_Index FROM HealpixPixel hp JOIN ObservedTile_HealpixPixel ot_hp on ot_hp.HealpixPixel_id = hp.id JOIN ObservedTile ot on ot.id = ot_hp.ObservedTile_id JOIN SkyPixel sp on sp.id = hp.N128_SkyPixel_id WHERE ot.HealpixMap_id = %s and ot.Mag_Lim IS NOT NULL ''' q = map_pixel_select % healpix_map_id map_pixels = query_db([q])[0] print("Retrieved %s map pixels..." % len(map_pixels)) # Initialize map pix dict for later access map_pixel_dict_new = OrderedDict() # map_pixel_dict_old = OrderedDict() class Pixel_Synopsis(): def __init__(self, mean_dist, dist_sigma, prob_2D, pixel_index, N128_index, pix_ebv, z): self.mean_dist = mean_dist self.dist_sigma = dist_sigma self.prob_2D = prob_2D self.pixel_index = pixel_index self.N128_index = N128_index self.pix_ebv = pix_ebv self.z = z self.distance_arr = None self.distance_modulus_arr = None self.distance_probs = None # From the tiles that contain this pixel # band:value self.measured_bands = [] self.lim_mags = OrderedDict() self.delta_mjds = OrderedDict() # From the model (only select the bands that have been imaged) self.A_lambda = OrderedDict() # band:value # model:arr self.model_observer_time_arr_new = OrderedDict() # self.model_observer_time_arr_old = None # Computed based on model + tile + pixel info # band:value # self.app_mag_model = {} # x-val # self.app_mag_model_prob = {} # y-val # Final calculation # model:band:value self.best_integrated_probs = OrderedDict() def __str__(self): return str(self.__dict__) count_bad_pixels = 0 for p in map_pixels: mean_dist = float(p[7]) dist_sigma = float(p[8]) prob_2D = float(p[3]) pixel_index = int(p[2]) N128_pixel_index = int(p[10]) pix_ebv = ebv[N128_pixel_index] d = Distance(mean_dist, u.Mpc) if mean_dist == 0.0: # distance did not converge for this pixel. pass... print("Bad Index: %s" % pixel_index) count_bad_pixels += 1 continue z = d.compute_z(cosmology=cosmo) p_new = Pixel_Synopsis(mean_dist, dist_sigma, prob_2D, pixel_index, N128_pixel_index, pix_ebv, z) min_dist = mean_dist - 5.0 * dist_sigma if min_dist <= 0.0: min_dist = 0.001 max_dist = mean_dist + 5.0 * dist_sigma distance_arr = np.linspace(min_dist, max_dist, 100) distance_modulus_arr = 5.0 * np.log10(distance_arr * 1e+6) - 5.0 distance_probs = 1.0 / np.sqrt( 2.0 * np.pi * dist_sigma**2) * np.exp( -1.0 * (distance_arr - mean_dist)**2 / (2 * dist_sigma**2)) p_new.distance_arr = distance_arr p_new.distance_modulus_arr = distance_modulus_arr p_new.distance_probs = distance_probs map_pixel_dict_new[pixel_index] = p_new print("\nMap pixel dict complete. %s bad pixels." % count_bad_pixels) # Get Detectors detectors = [] print("\nLoading Swope...") detector_select = "SELECT id, Name, Deg_width, Deg_width, Deg_radius, Area, MinDec, MaxDec FROM Detector WHERE `Name`='%s'" dr = query_db([detector_select % 'SWOPE'])[0][0] swope = Detector(dr[1], float(dr[2]), float(dr[2]), detector_id=int(dr[0])) detectors.append(swope) print("\nLoading Thacher...") dr = query_db([detector_select % 'THACHER'])[0][0] thacher = Detector(dr[1], float(dr[2]), float(dr[2]), detector_id=int(dr[0])) detectors.append(thacher) print("\nLoading Nickel...") dr = query_db([detector_select % 'NICKEL'])[0][0] nickel = Detector(dr[1], float(dr[2]), float(dr[2]), detector_id=int(dr[0])) detectors.append(nickel) print("\nLoading KAIT...") dr = query_db([detector_select % 'KAIT'])[0][0] kait = Detector(dr[1], float(dr[2]), float(dr[2]), detector_id=int(dr[0])) detectors.append(kait) print("\nLoading SINISTRO...") dr = query_db([detector_select % 'SINISTRO'])[0][0] sinistro = Detector(dr[1], float(dr[2]), float(dr[2]), detector_id=int(dr[0])) detectors.append(sinistro) # Get and instantiate all observed tiles observed_tile_select = ''' SELECT id, Detector_id, FieldName, RA, _Dec, EBV, N128_SkyPixel_id, Band_id, MJD, Exp_Time, Mag_Lim, HealpixMap_id FROM ObservedTile WHERE HealpixMap_id = %s and Detector_id = %s and Mag_Lim IS NOT NULL ''' observed_tiles = [] print("\nLoading Swope's Observed Tiles...") ot_result = query_db( [observed_tile_select % (healpix_map_id, swope.id)])[0] for ot in ot_result: t = Tile(float(ot[3]), float(ot[4]), swope.deg_width, swope.deg_height, healpix_map_nside, tile_id=int(ot[0])) t.field_name = ot[2] t.mjd = float(ot[8]) t.mag_lim = float(ot[10]) t.band_id = int(ot[7]) observed_tiles.append(t) print("Loaded %s %s tiles..." % (len(ot_result), swope.name)) print("\nLoading Nickel's Observed Tiles...") ot_result = query_db( [observed_tile_select % (healpix_map_id, nickel.id)])[0] for ot in ot_result: t = Tile(float(ot[3]), float(ot[4]), nickel.deg_width, nickel.deg_height, healpix_map_nside, tile_id=int(ot[0])) t.field_name = ot[2] t.mjd = float(ot[8]) t.mag_lim = float(ot[10]) t.band_id = int(ot[7]) observed_tiles.append(t) print("Loaded %s %s tiles..." % (len(ot_result), nickel.name)) print("\nLoading Thacher's Observed Tiles...") ot_result = query_db( [observed_tile_select % (healpix_map_id, thacher.id)])[0] for ot in ot_result: t = Tile(float(ot[3]), float(ot[4]), thacher.deg_width, thacher.deg_height, healpix_map_nside, tile_id=int(ot[0])) t.field_name = ot[2] t.mjd = float(ot[8]) t.mag_lim = float(ot[10]) t.band_id = int(ot[7]) observed_tiles.append(t) print("Loaded %s %s tiles..." % (len(ot_result), thacher.name)) print("\nLoading KAIT's Observed Tiles...") ot_result = query_db( [observed_tile_select % (healpix_map_id, kait.id)])[0] for ot in ot_result: t = Tile(float(ot[3]), float(ot[4]), kait.deg_width, kait.deg_height, healpix_map_nside, tile_id=int(ot[0])) t.field_name = ot[2] t.mjd = float(ot[8]) t.mag_lim = float(ot[10]) t.band_id = int(ot[7]) observed_tiles.append(t) print("Loaded %s %s tiles..." % (len(ot_result), kait.name)) print("\nLoading SINISTRO's Observed Tiles...") ot_result = query_db( [observed_tile_select % (healpix_map_id, sinistro.id)])[0] for ot in ot_result: t = Tile(float(ot[3]), float(ot[4]), sinistro.deg_width, sinistro.deg_height, healpix_map_nside, tile_id=int(ot[0])) t.field_name = ot[2] t.mjd = float(ot[8]) t.mag_lim = float(ot[10]) t.band_id = int(ot[7]) observed_tiles.append(t) print("Loaded %s %s tiles..." % (len(ot_result), sinistro.name)) print("Getting Detector-Band pairs...") detector_band_result = query_db([ '''SELECT DISTINCT d.Name as Detector, b.Name as Band FROM Detector d JOIN ObservedTile ot on ot.Detector_id = d.id JOIN Band b on b.id = ot.Band_id WHERE ot.HealpixMap_id = %s''' % healpix_map_id ]) print("\nUpdating pixel `delta_mjds` and `lim_mags`...") # For each tile: # we want the MJD of observation, and add that to the list of a pixels' MJD collection. # we want the limiting mag, add that to the list of a pixel's lim mag collection for t in observed_tiles: pix_indices = t.enclosed_pixel_indices for i in pix_indices: # get band from id... band = band_dict_by_id[t.band_id] band_name = band[1] # Some pixels are omitted because their distance information did not converge if i not in map_pixel_dict_new: continue pix_synopsis_new = map_pixel_dict_new[i] if band_name not in pix_synopsis_new.measured_bands: pix_synopsis_new.measured_bands.append(band_name) pix_synopsis_new.delta_mjds[band_name] = {} pix_synopsis_new.lim_mags[band_name] = {} pix_synopsis_new.delta_mjds[band_name][t.mjd] = (t.mjd - GW190814_t_0) pix_synopsis_new.lim_mags[band_name][t.mjd] = (t.mag_lim) print("\nInitializing %s models..." % len(models)) print("\nUpdating pixel `A_lambda` and `model_observer_time_arr`...") # Set pixel `model_observer_time_arr` and `A_lambda` for pix_index, pix_synopsis in map_pixel_dict_new.items(): for model_param_tuple, model_dict in models.items(): for model_col in model_dict.keys(): if model_col in band_mapping_new: band = band_dict_by_name[band_mapping_new[model_col]] band_id = band[0] band_name = band[1] band_coeff = band[2] if band_name in pix_synopsis.measured_bands: if band_name not in pix_synopsis.A_lambda: pix_a_lambda = pix_synopsis.pix_ebv * band_coeff pix_synopsis.A_lambda[band_name] = pix_a_lambda time_dilation = 1.0 + pix_synopsis.z pix_synopsis.model_observer_time_arr_new[ model_param_tuple] = model_dict["time"] * time_dilation # NEW Do the calculation... print("\nIntegrating total model probs...") count = 0 for pix_index, pix_synopsis in map_pixel_dict_new.items(): for band in pix_synopsis.measured_bands: for model_param_tuple, model_dict in models.items(): model_abs_mags = model_dict[reverse_band_mapping_new[band]] pixel_delta_mjd = pix_synopsis.delta_mjds[band] for i, (mjd, delta_mjd) in enumerate(pixel_delta_mjd.items()): # get the corresponding abs mag for the time of the observation pix_abs_mag = np.interp( delta_mjd, pix_synopsis. model_observer_time_arr_new[model_param_tuple], model_abs_mags) # print("pix_abs_mag: %s" % pix_abs_mag) # compute the distribution in apparent mag pix_app_mag = np.asarray(pix_synopsis.distance_modulus_arr) + pix_abs_mag + \ pix_synopsis.A_lambda[band] # re-normalize this distribution to sum to the pixel 2D prob # SIMPS (y, x) app_mag_norm = simps(pix_synopsis.distance_probs, pix_app_mag) renorm_pix_app_mag_prob = np.asarray( (pix_synopsis.prob_2D / app_mag_norm) * pix_synopsis.distance_probs) # Integrate the app mag distribution from arbitrarily bright to the limiting magnitude f_interp = lambda x: np.interp( x, pix_app_mag, renorm_pix_app_mag_prob) lower_bound = np.min(pix_app_mag) upper_bound = pix_synopsis.lim_mags[band][mjd] if model_param_tuple not in pix_synopsis.best_integrated_probs: pix_synopsis.best_integrated_probs[ model_param_tuple] = {} try: pix_synopsis.best_integrated_probs[ model_param_tuple][band][mjd] = 0.0 except: pix_synopsis.best_integrated_probs[ model_param_tuple][band] = { mjd: 0.0 } prob_to_detect = quad(f_interp, lower_bound, upper_bound)[0] if not np.isnan( prob_to_detect) and prob_to_detect >= 0.0: pix_synopsis.best_integrated_probs[ model_param_tuple][band][mjd] = prob_to_detect count += 1 if count % 1000 == 0: print("Processed: %s" % count) # NEW # Finally, get the highest valued integration, and sum running_sums = {} # model:band:value # pixels_to_plot = {} # model:band:pixel for pix_index, pix_synopsis in map_pixel_dict_new.items(): for band in pix_synopsis.measured_bands: for model_param_tuple, model_dict in models.items(): pix_max = 0.0 if model_param_tuple not in running_sums: running_sums[model_param_tuple] = {} try: t = running_sums[model_param_tuple][band] except: running_sums[model_param_tuple][band] = 0.0 probs = [] for mjd, integrated_prob in pix_synopsis.best_integrated_probs[ model_param_tuple][band].items(): probs.append(integrated_prob) pix_max = np.max(probs) running_sums[model_param_tuple][band] += pix_max # pixels_to_plot[] append(Pixel_Element(pix_index, healpix_map_nside, pix_max)) for model_param_tuple, band_dict in running_sums.items(): print( "\nIntegrated prob to detect model by band `%s` (%s, %s, %s)" % model_param_tuple) for band, running_sum in band_dict.items(): print("\t%s: %s" % (band, running_sum)) ## Additional calculation -- for every pixel, just get the highest prob running_sums2 = {} for model_param_tuple, model_dict in models.items(): running_sums2[model_param_tuple] = 0.0 for pix_index, pix_synopsis in map_pixel_dict_new.items(): pix_max = 0.0 probs = [] for band in pix_synopsis.measured_bands: for mjd, integrated_prob in pix_synopsis.best_integrated_probs[ model_param_tuple][band].items(): probs.append(integrated_prob) pix_max = np.max(probs) running_sums2[model_param_tuple] += pix_max # Build ascii.ecsv formatted output cols = ['Model', 'Mass', 'Velocity', 'X_lan', 'Prob'] dtype = ['S40', 'f8', 'f8', 'f8', 'f8'] meta = [ '{key} = {value}'.format(key=db[0], value=db[1]) for db in detector_band_result[0] ] result_table = Table(dtype=dtype, names=cols) result_table.meta['comment'] = meta for model_param_tuple, prob in running_sums2.items(): print( "\nCombined Integrated prob to detect model `%s` (%s, %s, %s)" % model_param_tuple) print("\t%s" % prob) result_table.add_row([ model_param_tuple[0], model_param_tuple[1], model_param_tuple[2], model_param_tuple[3], prob ]) result_table.write("%s/Detection_Results.prob" % formatted_model_output_dir, overwrite=True, format='ascii.ecsv')
def dist_to_z(D): return Distance.compute_z(D,cosmo)
def vpf(dat_dir, Nsph, simul_cosmo, rad): # Grab the data coordinates gals = h5_arr("./dat/out/{0}/{1}/gals_cart_coords.hdf5". format(dat_dir, simul_cosmo), "cart_pts") # Get details about the redshift interval being considered nbar_dict = json.load(open("./dat/out/{0}/{1}/nbar_zrange.json". format(dat_dir, simul_cosmo))) zlo = nbar_dict["zlo"] zhi = nbar_dict["zhi"] # Get the search points good_pts = h5_arr("./dat/out/{0}/srch_radec.hdf5".format(dat_dir), "good_pts") bad_pts = h5_arr("./dat/out/{0}/veto.hdf5".format(dat_dir), "bad_pts") # Set angular radius of effective area around bad points bad_r = np.arccos(1.0 - (np.pi * 9.8544099e-05) / (2 * 180 ** 2)) bad_r_deg = np.rad2deg(bad_r) # Set the cosmology with h free # Here the cosmology is based on WMAP (for first MultiDark simulation) if simul_cosmo == "Planck": # First make h free Planck13.__init__(100.0, Planck13.Om0) cosmo = Planck13 elif simul_cosmo == "WMAP": WMAP5.__init__(100.0, WMAP5.Om0) cosmo = WMAP5 comv = cosmo.comoving_distance # Build the trees # galaxy tree gal_baum = cKDTree(gals) # tree of bad points (angular coordinates on unit sphere) bad_xyz = radec2xyz(bad_pts) veto_baum = cKDTree(bad_xyz) # Initialise final output arrays # rad = np.arange(1.0, 67.0, 5.0) doing it one radius at a time # P_0 = np.zeros(rad.shape) # No. of spheres and norm # Nsph_arr = Nsph * np.array(4 * [0.01] + 4 * [0.1] + 4 * [1.0]) # norm = 1. / Nsph_arr # norm = 1. / Nsph rand_i = 0 for r_i, r in enumerate(rad): # start the count of successful voids count = 0 # Custom zrange for sphere size dis_near = Distance(comv(zlo).value + r, u.Mpc) dis_far = Distance(comv(zhi).value - r, u.Mpc) z_a = dis_near.compute_z(cosmology=cosmo) z_b = dis_far.compute_z(cosmology=cosmo) for i in range(Nsph): # _arr[r_i]): # compensate for finite length of mask file rand_i = rand_i % 999999 radec = good_pts[rand_i, :] rang = Angle(radec[0], u.deg) decang = Angle(radec[1], u.deg) randz = (z_a ** 3 + \ (z_b ** 3 - z_a ** 3) * np.random.rand(1)[0]) ** (1. / 3.) dis = Distance(comv(randz), u.Mpc) coord = ICRSCoordinates(rang, decang, distance=dis) sph_cen = np.array([coord.x.value, coord.y.value, coord.z.value]) nn = gal_baum.query(sph_cen) print "rad: ", r, ", sphere: ", i if not nn[0] < r: # add instance to probability count count += 1 # record quality of sphere using spline values for intersection # with bad points # Get radius of circular projection of sphere R = np.arcsin(r / np.sqrt(np.sum(sph_cen[:] ** 2))) # Get coordinates of circle centre on unit sphere crc_cen = radec2xyz(radec)[0] # Compute tree search radius from Cosine rule # (include points extending beyond sphere edge to account for # finite area around bad points) l_srch = np.sqrt(2. - 2. * np.cos(R)) # Run search pierce_l = veto_baum.query_ball_point(crc_cen, l_srch) bad_vol = 0. R = np.degrees(R) # need in degrees for bad_vol computation for pt in pierce_l: pt_ang = bad_pts[pt] dis = np.degrees(central_angle(pt_ang, radec)) l = dis / R bad_vol += 1.5 * (bad_r_deg / R) ** 2 \ * np.sqrt(1.0 - l ** 2) f_r = open("./dat/out/{0}/{1}/vpf_out/volfrac_{2}.dat". format(dat_dir, simul_cosmo, r), 'a') f_r.write("{0}\n".format(bad_vol)) f_r.close() rand_i += 1
def vpf(dat_dir, Nsph, simul_cosmo, rad): # Grab the data coordinates gals = h5_arr( "./dat/out/{0}/{1}/gals_cart_coords.hdf5".format(dat_dir, simul_cosmo), "cart_pts") # Get details about the redshift interval being considered nbar_dict = json.load( open("./dat/out/{0}/{1}/nbar_zrange.json".format(dat_dir, simul_cosmo))) zlo = nbar_dict["zlo"] zhi = nbar_dict["zhi"] # Get the search points good_pts = h5_arr("./dat/out/{0}/srch_radec.hdf5".format(dat_dir), "good_pts") bad_pts = h5_arr("./dat/out/{0}/veto.hdf5".format(dat_dir), "bad_pts") # Set angular radius of effective area around bad points bad_r = np.arccos(1.0 - (np.pi * 9.8544099e-05) / (2 * 180**2)) bad_r_deg = np.rad2deg(bad_r) # Set the cosmology with h free # Here the cosmology is based on WMAP (for first MultiDark simulation) if simul_cosmo == "Planck": # First make h free Planck13.__init__(100.0, Planck13.Om0) cosmo = Planck13 elif simul_cosmo == "WMAP": WMAP5.__init__(100.0, WMAP5.Om0) cosmo = WMAP5 comv = cosmo.comoving_distance # Build the trees # galaxy tree gal_baum = cKDTree(gals) # tree of bad points (angular coordinates on unit sphere) bad_xyz = radec2xyz(bad_pts) veto_baum = cKDTree(bad_xyz) # Initialise final output arrays # rad = np.arange(1.0, 67.0, 5.0) doing it one radius at a time # P_0 = np.zeros(rad.shape) # No. of spheres and norm # Nsph_arr = Nsph * np.array(4 * [0.01] + 4 * [0.1] + 4 * [1.0]) # norm = 1. / Nsph_arr # norm = 1. / Nsph rand_i = 0 for r_i, r in enumerate(rad): # start the count of successful voids count = 0 # Custom zrange for sphere size dis_near = Distance(comv(zlo).value + r, u.Mpc) dis_far = Distance(comv(zhi).value - r, u.Mpc) z_a = dis_near.compute_z(cosmology=cosmo) z_b = dis_far.compute_z(cosmology=cosmo) for i in range(Nsph): # _arr[r_i]): # compensate for finite length of mask file rand_i = rand_i % 999999 radec = good_pts[rand_i, :] rang = Angle(radec[0], u.deg) decang = Angle(radec[1], u.deg) randz = (z_a ** 3 + \ (z_b ** 3 - z_a ** 3) * np.random.rand(1)[0]) ** (1. / 3.) dis = Distance(comv(randz), u.Mpc) coord = ICRSCoordinates(rang, decang, distance=dis) sph_cen = np.array([coord.x.value, coord.y.value, coord.z.value]) nn = gal_baum.query(sph_cen) print "rad: ", r, ", sphere: ", i if not nn[0] < r: # add instance to probability count count += 1 # record quality of sphere using spline values for intersection # with bad points # Get radius of circular projection of sphere R = np.arcsin(r / np.sqrt(np.sum(sph_cen[:]**2))) # Get coordinates of circle centre on unit sphere crc_cen = radec2xyz(radec)[0] # Compute tree search radius from Cosine rule # (include points extending beyond sphere edge to account for # finite area around bad points) l_srch = np.sqrt(2. - 2. * np.cos(R)) # Run search pierce_l = veto_baum.query_ball_point(crc_cen, l_srch) bad_vol = 0. R = np.degrees(R) # need in degrees for bad_vol computation for pt in pierce_l: pt_ang = bad_pts[pt] dis = np.degrees(central_angle(pt_ang, radec)) l = dis / R bad_vol += 1.5 * (bad_r_deg / R) ** 2 \ * np.sqrt(1.0 - l ** 2) f_r = open( "./dat/out/{0}/{1}/vpf_out/volfrac_{2}.dat".format( dat_dir, simul_cosmo, r), 'a') f_r.write("{0}\n".format(bad_vol)) f_r.close() rand_i += 1