def selectionFunction_sc1324(cat): print '\n##############################################################################' print '## WARNING: DO NOT USE THIS SPATIAL SELECTION FOR SPECTROSCOPIC ANALYSIS ##' print '##############################################################################' image = '/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/SC_1324/catalogs/detection_i.fits' imwcs = wcs.WCS(image) ### center and radius(arcmin) of circle for selection region ra_center1, dec_center1, radius1 = 201.19367, 30.378647, 7.5 ra_center2, dec_center2, radius2 = 201.19789, 30.797195, 7.5 inds = pylab.find((mypy.radec_sep(cat.ra, cat.dec, ra_center1, dec_center1) < (radius1*60)) | (mypy.radec_sep(cat.ra, cat.dec, ra_center2, dec_center2) < (radius2*60))) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[201.25003,30.730522,47.512735], [201.22212,30.748129,13.458029], [201.27612,30.772911,22.274966], [201.10165,30.812886,23.675712], [201.25291,30.909185,17.122665], [201.15439,30.900116,12.10503], [201.25132,30.829188,9.7452902], [201.13392,30.846507,9.2278058], [201.13487,30.824375,7.6672608], [201.16874,30.769457,6.0614826], [201.26223,30.47085,36.090217], [201.25449,30.462586,12.670795], [201.22354,30.383661,33.454697], [201.20035,30.387129,27.711625], [201.10457,30.344156,28.993961], [201.13763,30.345778,11.809207], [201.30168,30.31483,20.60916], [201.2918,30.32177,8.7791076]]) area_arcsec2 = pylab.pi * ((radius1*60)**2 + (radius2*60)**2) for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
def selectionFunction_rxj1716(cat): image = '/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/RX_1716+6708/catalogs/detection_Riz.fits' imwcs = wcs.WCS(image) ### center and radius(arcmin) of circle for selection region ra_center, dec_center, radius = 259.22971, 67.143098, 7.5 inds = pylab.find(mypy.radec_sep(cat.ra, cat.dec, ra_center, dec_center) < (radius*60)) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[259.27315,67.137511,25.866736], [259.30226,67.138466,15.023128], [259.09091,67.166876,13.157666], [259.10066,67.218895,13.300506], [259.43251,67.196812,12.558967], [259.30401,67.162694,11.047812], [259.42721,67.163867,10.458859], [259.35307,67.153612,8.4644722], [259.18329,67.193086,8.7346083], [259.15519,67.086793,10.356007], [259.09615,67.113576,11.004811], [259.05713,67.110635,10.120949], [259.03645,67.098984,10.50559], [259.33435,67.234392,10.655293], [259.29348,67.246694,10.491968], [259.31441,67.25702,10.165386], [259.14271,67.101326,5.997919], [259.13191,67.100998,7.3613226], [259.13364,67.081616,9.624462], [259.10055,67.243124,12.539747], [259.04234,67.207214,9.2868871], [259.15655,67.224092,8.8955654]]) area_arcsec2 = pylab.pi * (radius*60)**2 for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
def selectionFunction_sg0023(cat): image = '/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/Cl_0023+0423/catalogs/detection_RIsup.fits' imwcs = wcs.WCS(image) ### center and radius(arcmin) of circle for selection region ra_center, dec_center, radius = 5.9679299, 4.371602, 8. inds = pylab.find(mypy.radec_sep(cat.ra, cat.dec, ra_center, dec_center) < (radius*60)) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[6.0002043,4.443438,13.101802], [6.0442164,4.4577949,14.926456], [6.0607516,4.4383802,16.134604], [6.0596828,4.4229565,11.242492], [6.0636816,4.4075321,18.773037], [6.0260797,4.4758797,8.532085], [6.0111424,4.4806675,7.0114467], [6.0004691,4.3984959,10.130726], [6.012204,4.3894537,8.1548529], [6.0130024,4.3602015,12.254177], [6.0260685,4.3312143,12.638204], [5.9529946,4.3602027,9.4850712], [5.9439261,4.3796153,6.3277603], [5.945526,4.3926459,7.6725706], [5.9031293,4.2700502,18.44122], [5.8625822,4.365514,11.637917], [5.8505758,4.39636,11.531429], [5.866039,4.4415702,11.457626], [5.8908441,4.4487533,9.8495449], [6.0970164,4.3796046,9.194863], [6.0930157,4.3788075,4.9400946], [5.9988648,4.3016978,7.724253]]) area_arcsec2 = pylab.pi * (radius*60)**2 for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
def __init__(self, name, version, zclust, sigmaz, alpha=50): self.name = name # e.g. "NEP 200" self.version = version # e.g. "nep200_v0.0.4" self.zclust = zclust # cluster redshift self.sigmaz = sigmaz # 1sigma scatter in (zphot-zspec)/(1+zspec) self.zspec_lo = 0 # lower redshift bound for specz self.zspec_hi = 0 # upper redshift bound for specz self.substructures = [] self.cat = gunzip_read_gzip('%s/%s/%s.cat.gz' % (data_dir, version, version), readcat=1) self.zout = gunzip_read_gzip('%s/%s/%s.zout.gz' % (data_dir, version, version), readzout=1) self.fout = gunzip_read_gzip('%s/%s/%s.fout.gz' % (data_dir, version, version), readcat=1) ### UPDATING USE FLAG WITH REDUCE CHI**2 > 10 chi2red = self.zout.chi_p / (self.zout.nfilt - 1.) cinds = pylab.find(chi2red > 10) self.cat.use[cinds] = 0. #print ' reading: %s_voronoi.pickle' % name #self.voronoi = pickle.load(open('../data/%s_voronoi.pickle' % name, 'rb')) xyrd1 = self.cat.x[0], self.cat.y[0], self.cat.ra[0], self.cat.dec[0] xyrd2 = self.cat.x[1], self.cat.y[1], self.cat.ra[1], self.cat.dec[1] d_arcsec = mypy.radec_sep(xyrd1[2], xyrd1[3], xyrd2[2], xyrd2[3]) d_pixel = ((xyrd1[0] - xyrd2[0])**2 + (xyrd1[1] - xyrd2[1])**2)**0.5 self.px_scale = d_arcsec / d_pixel ### getting z band magnitude try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_z) except: pass try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_Zplus) except: pass ### setting spatial flag based on Convex Hull method #zspecinds = pylab.find(self.cat.z_spec > 0) #self.spatial_flag = checkPoint(self.cat.ra[zspecinds], self.cat.dec[zspecinds], self.cat.ra, self.cat.dec) #self.inds_spatial = pylab.find(self.spatial_flag == 1) ### setting spatial flag based on Concave Hull method (creates a "tighter" spatial selection than Cnvex Hull) zspecinds = pylab.find(self.cat.z_spec > 0) points = pylab.array(zip(self.cat.x[zspecinds], self.cat.y[zspecinds])) self.concave_hull, self.edge_points = alpha_shape(points, alpha) self.inds_spatial = CheckPoints(self.concave_hull.buffer(10), self.cat.x, self.cat.y) self.area_pix2 = self.concave_hull.buffer(10).area self.area_arcmin2 = self.area_pix2 * (self.px_scale / 60.)**2 print ''
def selectionFunction_nep5281(cat): image = '/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/NEP5281/catalogs/detection_iz.fits' imwcs = wcs.WCS(image) ### center and radius(arcmin) of circle for selection region ra_center, dec_center, radius = 275.36968, 68.44678, 7.5 inds = pylab.find(mypy.radec_sep(cat.ra, cat.dec, ra_center, dec_center) < (radius*60)) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[275.27978,68.520525,46.056259], [275.53037,68.517381,40.509531], [275.50134,68.477453,24.628801], [275.26677,68.477929,23.442467], [275.268,68.46827,16.965804], [275.59468,68.47603,26.884972], [275.60796,68.486988,28.267962], [275.42581,68.432277,25.402459], [275.50188,68.374711,30.164172], [275.47205,68.365075,27.880421], [275.42809,68.39759,25.101274], [275.63699,68.413618,36.739731], [275.30528,68.383986,17.026886], [275.27421,68.405926,17.166376], [275.49268,68.43092,18.095503], [275.38766,68.489806,16.166629], [275.23104,68.445854,13.20395], [275.32431,68.409895,15.990675], [275.33392,68.352819,21.671266]]) area_arcsec2 = pylab.pi * (radius*60)**2 for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
def selectionFunction_nep200(cat): image = '/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/NEP200/catalogs/detection_ri.fits' imwcs = wcs.WCS(image) ### center and radius(arcmin) of circle for selection region ra_center, dec_center, radius = 269.34685, 66.517873, 7.5 inds = pylab.find(mypy.radec_sep(cat.ra, cat.dec, ra_center, dec_center) < (radius*60)) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[269.46246,66.429833,70.075997], [269.43695,66.446738,40.164039], [269.46396,66.517388,42.679144], [269.15691,66.559085,29.881235], [269.13197,66.599941,20.804753], [269.42969,66.613853,24.66493], [269.26007,66.457846,15.792927], [269.25119,66.452952,15.792927], [269.32334,66.592537,13.907813], [269.53687,66.57243,17.460344], [269.29668,66.505863,16.241715], [269.26984,66.532962,14.637499], [269.22505,66.561377,11.433118], [269.55164,66.462634,14.754796]]) area_arcsec2 = pylab.pi * (radius*60)**2 for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
### of any substructure center. If there are two such ### substructures, then the nearest is chosen. zspec = [] zphot = [] zlss = [] lmass = [] truefalse_array = [] for i_gal in range(len(zinds)): ra0, dec0 = ra_spec[i_gal], dec_spec[i_gal] ### measuring distance of galaxy to all substructure centroids rproj_list = [] for ss in f.substructures: rproj_arcsec = mypy.radec_sep(ra0, dec0, ss.ra, ss.dec) asecperkpc = cosmo.arcsec_per_kpc_proper(ss.zmean) rproj_kpc = rproj_arcsec / asecperkpc.value rproj_list.append(rproj_kpc) if min(rproj_list) <= 1000*rproj_search: rind = rproj_list.index(min(rproj_list)) zspec.append(f.cat.z_spec[zinds][i_gal]) zphot.append(f.zout.z_peak[zinds][i_gal]) lmass.append(f.fout.lmass[zinds][i_gal]) zlss.append(f.substructures[rind].zmean) ### now that we've grabbed the galaxy, determine if it is: ### 0 = true + ### 1 = true - ### 2 = false +
def __init__(self, name, version, zclust, sigmaz, alpha=50, chi2red_thresh=10): self.name = name # e.g. "NEP 200" self.version = version # e.g. "nep200_v0.0.4" self.zclust = zclust # cluster redshift self.sigmaz = sigmaz # 1sigma scatter in (zphot-zspec)/(1+zspec) self.zspec_lo = 0 # lower redshift bound for specz self.zspec_hi = 0 # upper redshift bound for specz self.substructures = [] self.alpha = alpha self.cat = gunzip_read_gzip('%s/%s/%s.cat.gz' % (github_dir, version, version), readcat=1) self.zout = gunzip_read_gzip('%s/%s/%s.zout.gz' % (github_dir, version, version), readzout=1) self.fout = gunzip_read_gzip('%s/%s/%s.fout.gz' % (github_dir, version, version), readcat=1) self.restframe = gunzip_read_gzip('%s/%s/%s.restframe.gz' % (github_dir, version, version), readcat=1) self.rfcolors = gunzip_read_gzip('%s/%s/%s.restframe_colors.gz' % (github_dir, version, version), readcat=1) ### SETTING OBJECTS IDENTIFIED AS SECURE STARS FROM SPECTROSCOPY TO use=0 self.crossmatch = gunzip_read_gzip('%s/%s/%s.crossmatch.gz' % (github_dir, version, version), readcat=1, dtype=str) self.star_inds = pylab.find(self.crossmatch.Q == '-1') for i_star in self.star_inds: id_phot_arr = self.crossmatch.id_phot[i_star].split(',') for id_phot in id_phot_arr: if id_phot != '-1': self.cat.use[int(id_phot)-1] *= 0 print ' reading: %s_voronoi.pickle' % name self.voronoi = pickle.load(open('../data/%s_voronoi.pickle' % name, 'rb')) self.overdens_max = [] for vi in range(len(self.voronoi.overdens_matrix)): self.overdens_max.append(self.voronoi.overdens_matrix[vi].max()) self.overdens_max = pylab.array(self.overdens_max) ### UPDATING USE FLAG WITH REDUCE CHI**2 THRESHOLD chi2red = self.zout.chi_p / (self.zout.nfilt - 1.) cinds = pylab.find((chi2red > chi2red_thresh) & (self.cat.z_spec < 0)) self.cat.use[cinds] = 0. ### UVJ classification self.UV_color = -2.5 * pylab.log10(self.restframe.restflux_U / self.restframe.restflux_V) self.VJ_color = -2.5 * pylab.log10(self.restframe.restflux_V / self.restframe.restflux_J) self.uvj_class = mypy.uvj_select(self.UV_color, self.VJ_color, self.fout.z) ### UVJ classification based on EAZY in 2-filter mode self.UV_color_2filter = self.rfcolors.U_V_color self.VJ_color_2filter = self.rfcolors.V_J_color self.uvj_class_2filter = mypy.uvj_select(self.UV_color_2filter, self.VJ_color_2filter, self.fout.z) ### NUVrJ classification self.NUVr_color = -2.5 * pylab.log10(self.restframe.restflux_NUV / self.restframe.restflux_r) self.rJ_color = -2.5 * pylab.log10(self.restframe.restflux_r / self.restframe.restflux_J) self.nuvrj_class = mypy.nuvrj_select(self.NUVr_color, self.rJ_color, self.fout.z) xyrd1 = self.cat.x[0], self.cat.y[0], self.cat.ra[0], self.cat.dec[0] xyrd2 = self.cat.x[1], self.cat.y[1], self.cat.ra[1], self.cat.dec[1] d_arcsec = mypy.radec_sep(xyrd1[2], xyrd1[3], xyrd2[2], xyrd2[3]) d_pixel = ((xyrd1[0]-xyrd2[0])**2 + (xyrd1[1] - xyrd2[1])**2)**0.5 self.px_scale = d_arcsec / d_pixel ### getting z band magnitude try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_z) except: pass if name != 'SC1324': try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_Zplus) except: pass ### setting spatial flag based on Convex Hull method #zspecinds = pylab.find(self.cat.z_spec > 0) #self.spatial_flag = checkPoint(self.cat.ra[zspecinds], self.cat.dec[zspecinds], self.cat.ra, self.cat.dec) #self.inds_spatial = pylab.find(self.spatial_flag == 1) ### setting spatial flag based on Concave Hull method (creates a "tighter" spatial selection than Cnvex Hull) zspecinds = pylab.find(self.cat.z_spec > 0) points = pylab.array(zip(self.cat.x[zspecinds], self.cat.y[zspecinds])) self.concave_hull, self.edge_points = alpha_shape(points, alpha) self.inds_spatial = CheckPoints(self.concave_hull.buffer(10), self.cat.x, self.cat.y) self.area_pix2 = self.concave_hull.buffer(10).area self.area_arcmin2 = self.area_pix2 * (self.px_scale/60.)**2 print ''
def __init__(self, name, version, zclust, sigmaz, imname, alpha=50, chi2red_thresh=10): self.name = name # e.g. "NEP 200" self.version = version # e.g. "nep200_v0.0.4" self.zclust = zclust # cluster redshift self.sigmaz = sigmaz # 1sigma scatter in (zphot-zspec)/(1+zspec) self.zspec_lo = 0 # lower redshift bound for specz self.zspec_hi = 0 # upper redshift bound for specz self.alpha = alpha self.imname = imname self.cat = gunzip_read_gzip('%s/%s/%s.cat.gz' % (data_dir, version, version), readcat=1) self.zout = gunzip_read_gzip('%s/%s/%s.zout.gz' % (data_dir, version, version), readzout=1) self.fout = gunzip_read_gzip('%s/%s/%s.fout.gz' % (data_dir, version, version), readcat=1) print ' reading: %s_voronoi.pickle' % name self.voronoi = pickle.load( open('../data/%s_voronoi.pickle' % name, 'rb')) ### UPDATING USE FLAG WITH REDUCE CHI**2 THRESHOLD chi2red = self.zout.chi_p / (self.zout.nfilt - 1.) cinds = pylab.find((chi2red > chi2red_thresh) & (self.cat.z_spec < 0)) self.cat.use[cinds] = 0. xyrd1 = self.cat.x[0], self.cat.y[0], self.cat.ra[0], self.cat.dec[0] xyrd2 = self.cat.x[1], self.cat.y[1], self.cat.ra[1], self.cat.dec[1] d_arcsec = mypy.radec_sep(xyrd1[2], xyrd1[3], xyrd2[2], xyrd2[3]) d_pixel = ((xyrd1[0] - xyrd2[0])**2 + (xyrd1[1] - xyrd2[1])**2)**0.5 self.px_scale = d_arcsec / d_pixel ### getting z band magnitude try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_z) except: pass if name != 'SC1324': try: self.zmagnitude = 25 - 2.5 * pylab.log10( self.cat.fluxauto_Zplus) except: pass ### setting spatial flag based on Convex Hull method #zspecinds = pylab.find(self.cat.z_spec > 0) #self.spatial_flag = checkPoint(self.cat.ra[zspecinds], self.cat.dec[zspecinds], self.cat.ra, self.cat.dec) #self.inds_spatial = pylab.find(self.spatial_flag == 1) ### setting spatial flag based on Concave Hull method (creates a "tighter" spatial selection than Cnvex Hull) zspecinds = pylab.find(self.cat.z_spec > 0) points = pylab.array(zip(self.cat.x[zspecinds], self.cat.y[zspecinds])) self.concave_hull, self.edge_points = alpha_shape(points, alpha) self.inds_spatial = CheckPoints(self.concave_hull.buffer(10), self.cat.x, self.cat.y) self.area_pix2 = self.concave_hull.buffer(10).area self.area_arcmin2 = self.area_pix2 * (self.px_scale / 60.)**2 ### SEGMENTATION IMAGE image = fits.open(imname) segmap = image[0].data * 0. xpoints, ypoints = [], [] for x in range(segmap.shape[1]): mypy.progress_bar(x, segmap.shape[1]) for y in range(segmap.shape[0]): xpoints.append(x) ypoints.append(y) xpoints = pylab.array(xpoints) ypoints = pylab.array(ypoints) concave_hull_segmap, edge_points_segmap = alpha_shape(points, alpha) inds_segmap = CheckPoints(concave_hull_segmap.buffer(10), xpoints, ypoints) inds_segmap_spatial = (ypoints[inds_segmap] - 1, xpoints[inds_segmap] - 1) segmap[inds_segmap_spatial] += 1 fits.writeto('../data/zspec_segmentation_maps/%s_segmap.fits' % version, segmap, header=image[0].header, clobber=1) print ''
def __init__(self, name, version, zclust, sigmaz, alpha=50, chi2red_thresh=10): self.name = name # e.g. "NEP 200" self.version = version # e.g. "nep200_v0.0.4" self.zclust = zclust # cluster redshift self.sigmaz = sigmaz # 1sigma scatter in (zphot-zspec)/(1+zspec) self.zspec_lo = 0 # lower redshift bound for specz self.zspec_hi = 0 # upper redshift bound for specz self.substructures = [] self.alpha = alpha self.chi2red_thresh = chi2red_thresh self.cat = gunzip_read_gzip('%s/%s/%s.cat.gz' % (data_dir, version, version), readcat=1) self.zout = gunzip_read_gzip('%s/%s/%s.zout.gz' % (data_dir, version, version), readzout=1) self.fout = gunzip_read_gzip('%s/%s/%s.fout.gz' % (data_dir, version, version), readcat=1) self.restframe = gunzip_read_gzip('%s/%s/%s.restframe.gz' % (data_dir, version, version), readcat=1) self.masslimits = mypy.readcat( '../data/completeness/masslimits_%s.dat' % name) ### UPDATING USE FLAG WITH REDUCE CHI**2 THRESHOLD chi2red = self.zout.chi_p / (self.zout.nfilt - 1.) cinds = pylab.find((chi2red > chi2red_thresh) & (self.cat.z_spec < 0)) self.cat.use[cinds] = 0. ### UVJ classification self.UV_color = -2.5 * pylab.log10( self.restframe.restflux_U / self.restframe.restflux_V) self.VJ_color = -2.5 * pylab.log10( self.restframe.restflux_V / self.restframe.restflux_J) self.uvj_class = mypy.uvj_select(self.UV_color, self.VJ_color, self.fout.z) xyrd1 = self.cat.x[0], self.cat.y[0], self.cat.ra[0], self.cat.dec[0] xyrd2 = self.cat.x[1], self.cat.y[1], self.cat.ra[1], self.cat.dec[1] d_arcsec = mypy.radec_sep(xyrd1[2], xyrd1[3], xyrd2[2], xyrd2[3]) d_pixel = ((xyrd1[0] - xyrd2[0])**2 + (xyrd1[1] - xyrd2[1])**2)**0.5 self.px_scale = d_arcsec / d_pixel ### getting z band magnitude try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_z) except: pass if name != 'SC1324': try: self.zmagnitude = 25 - 2.5 * pylab.log10( self.cat.fluxauto_Zplus) except: pass ### setting spatial flag based on Convex Hull method #zspecinds = pylab.find(self.cat.z_spec > 0) #self.spatial_flag = checkPoint(self.cat.ra[zspecinds], self.cat.dec[zspecinds], self.cat.ra, self.cat.dec) #self.inds_spatial = pylab.find(self.spatial_flag == 1) ### setting spatial flag based on Concave Hull method (creates a "tighter" spatial selection than Cnvex Hull) zspecinds = pylab.find(self.cat.z_spec > 0) points = pylab.array(zip(self.cat.x[zspecinds], self.cat.y[zspecinds])) self.concave_hull, self.edge_points = alpha_shape(points, alpha) self.inds_spatial = CheckPoints(self.concave_hull.buffer(10), self.cat.x, self.cat.y) self.area_pix2 = self.concave_hull.buffer(10).area self.area_arcmin2 = self.area_pix2 * (self.px_scale / 60.)**2 print ''
def __init__(self, name, version, zclust, sigmaz, alpha=50, chi2red_thresh=10, uvj_slope=0.88, uvj_intercept=0.59, radio_AGN_filename=None, readcats=True): self.name = name # e.g. "NEP 200" self.version = version # e.g. "nep200_v0.0.4" self.zclust = zclust # cluster redshift self.sigmaz = sigmaz # 1sigma scatter in (zphot-zspec)/(1+zspec) self.zspec_lo = 0 # lower redshift bound for specz self.zspec_hi = 0 # upper redshift bound for specz self.alpha = alpha if readcats: print ' reading: %s.cat' % version self.cat = mypy.readcat('%s/%s/%s/%s.cat.gz' % (github_dir, github_photo_cats, version, version)) print ' reading: %s.zout' % version self.zout = mypy.readzout('%s/%s/%s/%s.zout.gz' % (github_dir, github_photo_cats, version, version)) print ' reading: %s_ZFparams.fout' % version self.fout = mypy.readcat('%s/%s/%s/%s_ZFparams.fout.gz' % (github_dir, github_photo_cats, version, version)) print ' reading: %s.fir' % version self.fir = mypy.readcat('%s/%s/%s/%s.fir.gz' % (github_dir, github_photo_cats, version, version)) print ' reading: %s.restframe' % version self.restframe = mypy.readcat('%s/%s/%s/%s.restframe.gz' % (github_dir, github_photo_cats, version, version)) #print ' reading: %s.restframe_colors' % version #self.rfcolors = mypy.readcat('%s/%s/%s/%s.restframe_colors.gz' % (github_dir, github_photo_cats, version, version)) ### SETTING OBJECTS IDENTIFIED AS SECURE STARS FROM SPECTROSCOPY TO use=0 self.crossmatch = mypy.readcat('%s/%s/%s/%s.crossmatch.gz' % (github_dir, github_photo_cats, version, version), dtype=str) self.star_inds = self.crossmatch.Q == '-1' for i_star in self.star_inds: id_phot_arr = self.crossmatch.id_phot[i_star].split(',') for id_phot in id_phot_arr: if id_phot != '-1': self.cat.use[int(id_phot)-1] *= 0 print ' reading: %s_voronoi.pickle' % name self.voronoi = pickle.load(open('/Users/atomczak/Dropbox/ORELSE/DATA/VORONOI/%s_voronoi.pickle' % name, 'rb')) self.overdens_max = [] for vi in range(len(self.voronoi.overdens_matrix)): self.overdens_max.append(self.voronoi.overdens_matrix[vi].max()) self.overdens_max = numpy.array(self.overdens_max) ### UPDATING USE FLAG WITH REDUCE CHI**2 THRESHOLD chi2red = self.zout.chi_p / (self.zout.nfilt - 1.) cinds = (chi2red > chi2red_thresh) & (self.cat.z_spec < 0) self.cat.use[cinds] = 0. ### UVJ classification self.UV_color = -2.5 * numpy.log10(self.restframe.restflux_U / self.restframe.restflux_V) self.VJ_color = -2.5 * numpy.log10(self.restframe.restflux_V / self.restframe.restflux_J) self.uvj_class = mypy.uvj_select(self.UV_color, self.VJ_color, self.fout.z) #self.uvj_class = uvj_select(self.UV_color, self.VJ_color, self.fout.z, uvj_slope=uvj_slope, uvj_intercept=uvj_intercept) ### UVJ classification based on EAZY in 2-filter mode #self.UV_color_2filter = self.rfcolors.U_V_color #self.VJ_color_2filter = self.rfcolors.V_J_color #self.uvj_class_2filter = mypy.uvj_select(self.UV_color_2filter, self.VJ_color_2filter, self.fout.z) ### NUVrJ classification self.NUVr_color = -2.5 * numpy.log10(self.restframe.restflux_NUV / self.restframe.restflux_r) self.rJ_color = -2.5 * numpy.log10(self.restframe.restflux_r / self.restframe.restflux_J) self.nuvrj_class = mypy.nuvrj_select(self.NUVr_color, self.rJ_color, self.fout.z) ########################### ### adding Radio AGN flag ########################### self.radio_AGN_cat = None self.AGN_flag_radio = numpy.zeros(len(self.cat.id)) if radio_AGN_filename != None: self.radio_AGN_cat = mypy.readcat('%s/%s/%s' % (github_dir, github_radio_cats, radio_AGN_filename), dtype=str) ids_radio_AGN = self.radio_AGN_cat.id_phot.astype(int) self.AGN_flag_radio[ids_radio_AGN - 1] = 1 ########################### ### adding Xray AGN flag ########################### self.xray_AGN_cat = None self.AGN_flag_xray = numpy.zeros(len(self.cat.id)) xyrd1 = self.cat.x[0], self.cat.y[0], self.cat.ra[0], self.cat.dec[0] xyrd2 = self.cat.x[1], self.cat.y[1], self.cat.ra[1], self.cat.dec[1] d_arcsec = mypy.radec_sep(xyrd1[2], xyrd1[3], xyrd2[2], xyrd2[3]) d_pixel = ((xyrd1[0]-xyrd2[0])**2 + (xyrd1[1] - xyrd2[1])**2)**0.5 self.px_scale = d_arcsec / d_pixel ### getting z band magnitude try: self.zmagnitude = 25 - 2.5 * numpy.log10(self.cat.fluxauto_z) except: pass if name != 'SC1324': try: self.zmagnitude = 25 - 2.5 * numpy.log10(self.cat.fluxauto_Zplus) except: pass ### setting spatial flag based on Convex Hull method #zspecinds = self.cat.z_spec > 0 #self.spatial_flag = checkPoint(self.cat.ra[zspecinds], self.cat.dec[zspecinds], self.cat.ra, self.cat.dec) #self.inds_spatial = self.spatial_flag == 1 ### setting spatial flag based on Concave Hull method (creates a "tighter" spatial selection than Cnvex Hull) zspecinds = self.cat.z_spec > 0 points = numpy.array(zip(self.cat.x[zspecinds], self.cat.y[zspecinds])) self.concave_hull, self.edge_points = mypy.alpha_shape(points, alpha) self.inds_spatial = mypy.CheckPoints(self.concave_hull.buffer(10), self.cat.x, self.cat.y) self.area_pix2 = self.concave_hull.buffer(10).area self.area_arcmin2 = self.area_pix2 * (self.px_scale/60.)**2 print ''
print 'searching for spectroscopic matches...' inds_match_tomczak = [] inds_match_lemaux = [] nmatch = [] for i in range(len(speccat.id)): ### Skipping serendipitous objects with no previously identified photometric counterpart if i > 0 and speccat.ra[i] == speccat.ra[i-1] and speccat.dec[i] == speccat.dec[i-1]: continue ra, dec = float(speccat.ra[i]), float(speccat.dec[i]) seps = mypy.radec_sep(ra, dec, sexcats[0].x_world, sexcats[0].y_world) inds = pylab.find(seps < 0.75) nmatch.append(len(inds)) if len(inds) == 1: id_specs[inds[0]] = speccat.id[i] z_specs[inds[0]] = float(speccat.z_spec[i]) z_spec_errs[inds[0]] = float(speccat.z_spec_err[i]) Q_specs[inds[0]] = int(speccat.Q[i]) inds_match_tomczak.append(inds[0]) inds_match_lemaux.append(i) if len(inds) == 0: print speccat.ra[i], speccat.dec[i], speccat.Q[i], speccat.slitnum[i], speccat.id[i]
try: os.mkdir('./catalogs') except: pass try: os.mkdir('./psfs') except: pass ### zooming psf to pixel scale of image psf_pxscale = 0.2 xcen, ycen = pylab.array(imdat.shape) / 2 ra1, dec1 = imwcs.all_pix2world([xcen], [ycen], 1) ra2, dec2 = imwcs.all_pix2world([xcen+1], [ycen], 1) imdat_pxscale = mypy.radec_sep(ra1[0], dec1[0], ra2[0], dec2[0]) psfdat_zoom = ndimage.zoom(psfdat, psf_pxscale / imdat_pxscale) fits.writeto('./psfs/psf_%s' % os.path.basename(imname), psfdat_zoom, clobber=1) print '\nwrote to ./psfs/psf_%s' % os.path.basename(imname) ### estimate FWHM dx, dy = psfdat_zoom.shape xx, yy = pylab.meshgrid(range(-dx/2+1, dx/2+1), range(-dy/2+1, dy/2+1)) rr = (xx**2 + yy**2)**0.5
### coordinates and size of large box (size in arcmin) ra0, dec0, box_size_amin, cutout_size_amin = 259.1919, 67.147616, 14., 2.5 x0, y0 = voronoi_wcs.wcs_world2pix([ra0], [dec0], 1) x0, y0 = int(x0 + 0.5), int(y0 + 0.5) ### pixel scale of voronoi map xs, ys = voronoi_wcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(xs[0], ys[0], xs[1], ys[1]) box_size_px = int(box_size_amin * 60 / px_scale) fig = pylab.figure(figsize=(18.1125, 8.35)) sp2 = pylab.subplot2grid((5, 12), (1, 3), rowspan=3, colspan=3, aspect=1) sp1 = pylab.subplot2grid((5, 12), (1, 0), rowspan=3, colspan=3, aspect=1, title='Voronoi Tesselation') sp3 = pylab.subplot2grid((5, 12), (0, 7), rowspan=5, colspan=5, aspect=1) fig.subplots_adjust(wspace=0.1, left=0.02) sp1.xaxis.set_visible(0)
def __init__(self, name, version, zclust, sigmaz, alpha=50, chi2red_thresh=10): self.name = name # e.g. "NEP 200" self.version = version # e.g. "nep200_v0.0.4" self.zclust = zclust # cluster redshift self.sigmaz = sigmaz # 1sigma scatter in (zphot-zspec)/(1+zspec) self.zspec_lo = 0 # lower redshift bound for specz self.zspec_hi = 0 # upper redshift bound for specz self.substructures = [] self.alpha = alpha self.cat = gunzip_read_gzip('%s/%s/%s.cat.gz' % (github_dir, version, version), readcat=1) self.zout = gunzip_read_gzip('%s/%s/%s.zout.gz' % (github_dir, version, version), readzout=1) self.fout1 = gunzip_read_gzip('%s/%s/%s.fout.gz' % (github_dir, version, version), readcat=1) self.fout2 = gunzip_read_gzip('%s/%s/%s_ZFparams.fout.gz' % (github_dir, version, version), readcat=1) ### SETTING OBJECTS IDENTIFIED AS SECURE STARS FROM SPECTROSCOPY TO use=0 self.crossmatch = gunzip_read_gzip('%s/%s/%s.crossmatch.gz' % (github_dir, version, version), readcat=1, dtype=str) self.star_inds = pylab.find(self.crossmatch.Q == '-1') for i_star in self.star_inds: id_phot_arr = self.crossmatch.id_phot[i_star].split(',') for id_phot in id_phot_arr: if id_phot != '-1': self.cat.use[int(id_phot) - 1] *= 0 ### UPDATING USE FLAG WITH REDUCE CHI**2 THRESHOLD chi2red = self.zout.chi_p / (self.zout.nfilt - 1.) cinds = pylab.find((chi2red > chi2red_thresh) & (self.cat.z_spec < 0)) self.cat.use[cinds] = 0. xyrd1 = self.cat.x[0], self.cat.y[0], self.cat.ra[0], self.cat.dec[0] xyrd2 = self.cat.x[1], self.cat.y[1], self.cat.ra[1], self.cat.dec[1] d_arcsec = mypy.radec_sep(xyrd1[2], xyrd1[3], xyrd2[2], xyrd2[3]) d_pixel = ((xyrd1[0] - xyrd2[0])**2 + (xyrd1[1] - xyrd2[1])**2)**0.5 self.px_scale = d_arcsec / d_pixel ### getting z band magnitude try: self.zmagnitude = 25 - 2.5 * pylab.log10(self.cat.fluxauto_z) except: pass if name != 'SC1324': try: self.zmagnitude = 25 - 2.5 * pylab.log10( self.cat.fluxauto_Zplus) except: pass ### setting spatial flag based on Convex Hull method #zspecinds = pylab.find(self.cat.z_spec > 0) #self.spatial_flag = checkPoint(self.cat.ra[zspecinds], self.cat.dec[zspecinds], self.cat.ra, self.cat.dec) #self.inds_spatial = pylab.find(self.spatial_flag == 1) ### setting spatial flag based on Concave Hull method (creates a "tighter" spatial selection than Cnvex Hull) zspecinds = pylab.find(self.cat.z_spec > 0) points = pylab.array(zip(self.cat.x[zspecinds], self.cat.y[zspecinds])) self.concave_hull, self.edge_points = alpha_shape(points, alpha) self.inds_spatial = CheckPoints(self.concave_hull.buffer(10), self.cat.x, self.cat.y) self.area_pix2 = self.concave_hull.buffer(10).area self.area_arcmin2 = self.area_pix2 * (self.px_scale / 60.)**2 print ''
def selectionFunction_cl0910(cat): image='/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/Cl_0910+5422/images/sci/wregister/detection_image/my_detection_RcI+Z+.fits' imwcs = wcs.WCS(image) ### vertices of lines foriming polygon selection region ra1_a, dec1_a, ra2_a, dec2_a = 137.46145,54.333665,137.71293,54.468663 ra1_b, dec1_b, ra2_b, dec2_b = 137.89374,54.400527,137.71354,54.469018 ra1_c, dec1_c, ra2_c, dec2_c = 137.89313,54.400172,137.6829,54.293655 ra1_d, dec1_d, ra2_d, dec2_d = 137.35995,54.202896,137.6829,54.293655 ra1_e, dec1_e, ra2_e, dec2_e = 137.35995,54.202896,137.33306,54.292819 ra1_f, dec1_f, ra2_f, dec2_f = 137.46145,54.333665,137.33306,54.292819 (x1_a, y1_a), (x2_a, y2_a) = imwcs.wcs_world2pix(pylab.array(zip([ra1_a, ra2_a], [dec1_a, dec2_a])), 1) (x1_b, y1_b), (x2_b, y2_b) = imwcs.wcs_world2pix(pylab.array(zip([ra1_b, ra2_b], [dec1_b, dec2_b])), 1) (x1_c, y1_c), (x2_c, y2_c) = imwcs.wcs_world2pix(pylab.array(zip([ra1_c, ra2_c], [dec1_c, dec2_c])), 1) (x1_d, y1_d), (x2_d, y2_d) = imwcs.wcs_world2pix(pylab.array(zip([ra1_d, ra2_d], [dec1_d, dec2_d])), 1) (x1_e, y1_e), (x2_e, y2_e) = imwcs.wcs_world2pix(pylab.array(zip([ra1_e, ra2_e], [dec1_e, dec2_e])), 1) (x1_f, y1_f), (x2_f, y2_f) = imwcs.wcs_world2pix(pylab.array(zip([ra1_f, ra2_f], [dec1_f, dec2_f])), 1) xs = pylab.array([x1_a, x2_a, x1_b, x2_b, x1_c, x2_c, x1_d, x2_d, x1_e, x2_e, x1_f, x2_f]) ys = pylab.array([y1_a, y2_a, y1_b, y2_b, y1_c, y2_c, y1_d, y2_d, y1_e, y2_e, y1_f, y2_f]) slope_a = (y1_a - y2_a) / (x1_a - x2_a) slope_b = (y1_b - y2_b) / (x1_b - x2_b) slope_c = (y1_c - y2_c) / (x1_c - x2_c) slope_d = (y1_d - y2_d) / (x1_d - x2_d) slope_e = (y1_e - y2_e) / (x1_e - x2_e) slope_f = (y1_f - y2_f) / (x1_f - x2_f) norm_a = y1_a - slope_a * x1_a norm_b = y1_b - slope_b * x1_b norm_c = y1_c - slope_c * x1_c norm_d = y1_d - slope_d * x1_d norm_e = y1_e - slope_e * x1_e norm_f = y1_f - slope_f * x1_f ### selecting galaxies within a user-defind polygon enclosing the spectroscopic coverage inds = pylab.find(((cat.y < slope_a * cat.x + norm_a) | (cat.y < slope_f * cat.x + norm_f)) & (cat.y < slope_b * cat.x + norm_b) & (cat.y > slope_c * cat.x + norm_c) & (cat.y > slope_d * cat.x + norm_d) & (cat.y > slope_e * cat.x + norm_e) & (cat.use == 1)) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[137.72017,54.439911,11.491746], [137.81728,54.398832,6.7431164], [137.71937,54.409576,9.3121025], [137.76736,54.369088,12.255985], [137.7616,54.351868,9.1073549], [137.68401,54.371568,6.48], [137.67523,54.374569,11.123555], [137.65235,54.358788,9.5279771], [137.64415,54.358564,9.6752827], [137.62866,54.394229,19.453046], [137.65501,54.374567,5.6216075], [137.58682,54.325645,13.965681], [137.5307,54.353927,8.7263942], [137.58229,54.305084,8.101748], [137.5724,54.299409,16.05717], [137.61487,54.295104,6.9433894], [137.59756,54.28876,6.0919288], [137.44301,54.249783,10.550997], [137.46675,54.292829,7.7258551], [137.54163,54.2766,7.7839873], [137.48524,54.330752,7.1368481], [137.52003,54.250906,8.5717222], [137.50938,54.250447,7.4277835], [137.47348,54.241281,11.223961], [137.41227,54.237608,12.044997], [137.34195,54.281106,11.348039], [137.86589,54.391751,6.305658]]) area_px2 = PolyArea(xs, ys) area_arcsec2 = area_px2 * px_scale**2 for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
### finding lower/upper zspec limits zlo_spec, zhi_spec = f.zclust, f.zclust dr_pkpc_arr = pylab.zeros((len(f.substructures), len(f.cat.id))) for ssi in range(len(f.substructures)): ss = f.substructures[ssi] vmean = vrecess(ss.zmean) vlo = vmean - 3*ss.vsigma1mpc vhi = vmean + 3*ss.vsigma1mpc zlo = zrecess(vlo) zhi = zrecess(vhi) if zlo < zlo_spec: zlo_spec = zlo if zhi > zhi_spec: zhi_spec = zhi ### calculating projected distance between SS and each galaxy dr_arcsec = mypy.radec_sep(ss.ra, ss.dec, f.cat.ra, f.cat.dec) dr_pkpc_arr[ssi] += dr_arcsec * kpc2arcsec ### identifying projected radius to nearest substructure for all galaxies dr_pkpc_min = pylab.zeros(len(f.cat.id)) for gi in range(len(f.cat.id)): dr_pkpc_min[gi] += min(dr_pkpc_arr[:,gi]) #print '\nUSING EXPANDED ZSPEC WINDOW !!!\n' #zlo_spec = f.zclust - 0.2
def selectionFunction_sc1604(cat): image='/Volumes/PHOENIX/atomczak/DATA/ORELSE/catalogs/v001/Cl_1604+4320/catalogs/CL1604_master_Rc.fits' imwcs = wcs.WCS(image) ### vertices of lines foriming polygon selection region ra1_a, dec1_a, ra2_a, dec2_a = 241.18999,43.319742,241.13575,43.032008 ra1_b, dec1_b, ra2_b, dec2_b = 241.04834,43.042383,241.13575,43.032008 ra1_c, dec1_c, ra2_c, dec2_c = 241.04834,43.042383,240.91837,43.295081 ra1_d, dec1_d, ra2_d, dec2_d = 240.75818,43.365714,240.91837,43.295081 ra1_e, dec1_e, ra2_e, dec2_e = 240.75818,43.365714,240.79529,43.455913 ra1_f, dec1_f, ra2_f, dec2_f = 241.20824,43.440948,240.79529,43.455913 ra1_g, dec1_g, ra2_g, dec2_g = 241.20824,43.440948,241.24855,43.325684 ra1_h, dec1_h, ra2_h, dec2_h = 241.18999,43.319742,241.24855,43.325684 (x1_a, y1_a), (x2_a, y2_a) = imwcs.wcs_world2pix(pylab.array(zip([ra1_a, ra2_a], [dec1_a, dec2_a])), 1) (x1_b, y1_b), (x2_b, y2_b) = imwcs.wcs_world2pix(pylab.array(zip([ra1_b, ra2_b], [dec1_b, dec2_b])), 1) (x1_c, y1_c), (x2_c, y2_c) = imwcs.wcs_world2pix(pylab.array(zip([ra1_c, ra2_c], [dec1_c, dec2_c])), 1) (x1_d, y1_d), (x2_d, y2_d) = imwcs.wcs_world2pix(pylab.array(zip([ra1_d, ra2_d], [dec1_d, dec2_d])), 1) (x1_e, y1_e), (x2_e, y2_e) = imwcs.wcs_world2pix(pylab.array(zip([ra1_e, ra2_e], [dec1_e, dec2_e])), 1) (x1_f, y1_f), (x2_f, y2_f) = imwcs.wcs_world2pix(pylab.array(zip([ra1_f, ra2_f], [dec1_f, dec2_f])), 1) (x1_g, y1_g), (x2_g, y2_g) = imwcs.wcs_world2pix(pylab.array(zip([ra1_g, ra2_g], [dec1_g, dec2_g])), 1) (x1_h, y1_h), (x2_h, y2_h) = imwcs.wcs_world2pix(pylab.array(zip([ra1_h, ra2_h], [dec1_h, dec2_h])), 1) xs = pylab.array([x1_a, x2_a, x1_b, x2_b, x1_c, x2_c, x1_d, x2_d, x1_e, x2_e, x1_f, x2_f, x1_g, x2_g, x1_h, x2_h]) ys = pylab.array([y1_a, y2_a, y1_b, y2_b, y1_c, y2_c, y1_d, y2_d, y1_e, y2_e, y1_f, y2_f, y1_g, y2_g, y1_h, y2_h]) slope_a = (y1_a - y2_a) / (x1_a - x2_a) slope_b = (y1_b - y2_b) / (x1_b - x2_b) slope_c = (y1_c - y2_c) / (x1_c - x2_c) slope_d = (y1_d - y2_d) / (x1_d - x2_d) slope_e = (y1_e - y2_e) / (x1_e - x2_e) slope_f = (y1_f - y2_f) / (x1_f - x2_f) slope_g = (y1_g - y2_g) / (x1_g - x2_g) slope_h = (y1_h - y2_h) / (x1_h - x2_h) norm_a = y1_a - slope_a * x1_a norm_b = y1_b - slope_b * x1_b norm_c = y1_c - slope_c * x1_c norm_d = y1_d - slope_d * x1_d norm_e = y1_e - slope_e * x1_e norm_f = y1_f - slope_f * x1_f norm_g = y1_g - slope_g * x1_g norm_h = y1_h - slope_h * x1_h ### selecting galaxies within a user-defind polygon enclosing the spectroscopic coverage inds = pylab.find((cat.y > slope_b * cat.x + norm_b) & (cat.y < slope_e * cat.x + norm_e) & (cat.y < slope_f * cat.x + norm_f) & (cat.y < slope_g * cat.x + norm_g) & ((cat.y > slope_a * cat.x + norm_a) | (cat.y > slope_h * cat.x + norm_h)) & ((cat.y > slope_c * cat.x + norm_c) | (cat.y > slope_d * cat.x + norm_d))) ### calculating the area of the user-defind polygon ra12, dec12 = imwcs.wcs_pix2world([0, 0], [0, 1], 1) px_scale = mypy.radec_sep(ra12[0], dec12[0], ra12[1], dec12[1]) ### ra_center, dec_center, radius(arcsec) holes = pylab.array([[241.05287,43.441308,25.845097], [241.06541,43.41401,32.433931], [241.14686,43.421204,18.177141], [241.16931,43.423087,20.559791], [241.14311,43.316167,33.185926], [241.14619,43.265732,16.692676], [241.01331,43.335491,18.023439], [240.9647,43.396499,14.2458], [240.90351,43.438506,17.323747], [240.86569,43.357668,14.619093], [241.0764,43.323762,13.507682], [241.0665,43.321485,12.243407], [241.16817,43.348006,10.962367], [241.15879,43.351425,10.710095], [240.99444,43.401458,11.073026], [241.13639,43.386322,9.8980624], [241.0962,43.266503,12.931588], [241.05871,43.255123,11.746842], [241.12848,43.252088,14.79412], [241.13003,43.233886,20.697477], [240.96029,43.262636,10.254993], [240.96757,43.267574,8.1846382], [240.88354,43.322437,13.506917], [241.14769,43.195158,20.80547], [241.1222,43.190997,13.509939], [241.0936,43.219441,8.9580593], [241.09204,43.206169,9.7404603], [241.02857,43.204634,11.522894], [241.11335,43.159146,13.839286], [241.09931,43.099992,11.866212], [241.0396,43.082537,15.065785], [240.80567,43.366973,13.366928]]) area_px2 = PolyArea(xs, ys) area_arcsec2 = area_px2 * px_scale**2 for hole in holes: area_arcsec2 -= pylab.pi * hole[2]**2 area_arcmin2 = area_arcsec2 / 60.**2 return inds, area_arcmin2
master_id_spec = numpy.append( master_id_spec, f.crossmatch.id_spec[ind_crossmatch]) master_slitmask = numpy.append( master_slitmask, f.crossmatch.slitmask[ind_crossmatch]) except: pass digi_lmass = numpy.digitize(master_lmass, lmassbins) digi_overdens = numpy.digitize(master_overdens, overdensbins) ### Creating Xray AGN flag in post if True: master_AGN_flag_xray = [] for i_gal in range(len(master_id_gal)): separations = mypy.radec_sep(xray_ra, xray_dec, master_ra[i_gal], master_dec[i_gal]) ind_min_sep = numpy.where(separations == separations.min())[0][0] if separations.min() <= 2. and xray_lum_tot[ind_min_sep] > 10**42.5: master_AGN_flag_xray.append(True) else: master_AGN_flag_xray.append(False) master_AGN_flag_xray = numpy.array(master_AGN_flag_xray) master_id_field = master_id_field[-master_AGN_flag_xray] master_id_gal = master_id_gal[-master_AGN_flag_xray] master_ra = master_ra[-master_AGN_flag_xray] master_dec = master_dec[-master_AGN_flag_xray] master_zspec = master_zspec[-master_AGN_flag_xray] master_ftot_mips24 = master_ftot_mips24[-master_AGN_flag_xray] master_etot_mips24 = master_etot_mips24[-master_AGN_flag_xray] master_SFR_UVIR = master_SFR_UVIR[-master_AGN_flag_xray]