def get_aperture(self, r, mass, masserr): """ get r,mass,masserr and the mass from background within our aperture (rmin,rmax) """ w=where1((r >= self.rmin) & (r <= self.rmax)) rap=r[w] massap=mass[w] massaperr=masserr[w] # mass from background (standard rho) msap = self.mstd(r[w]) wl = where1(msap < massap) wg = where1(msap >= massap) if wl.size == w.size or wg.size == w.size: raise ValueError("lines do not cross in " "aperture: %s,%s" % (self.rmin,self.rmax)) if rap[wl].max() > rap[wg].min(): raise ValueError("mass is not monatonic") return rap, massap, massaperr, msap
def read_test_data(): import esutil as eu from . import select gal=eu.io.read('~/data/boss/calibObj-000756-3-gal.fits',lower=True) star=eu.io.read('~/data/boss/calibObj-000756-3-star.fits',lower=True) gflags = get_select_logic(gal,4.0) sflags = get_select_logic(star,4.0) gw = where1(gflags) sw = where1(sflags) ntot = gw.size + sw.size dt=[('origtype','i4'), ('modelflux','f4',5), ('modelflux_ivar','f4',5), ('psfflux','f4',5), ('psfflux_ivar','f4',5)] data = numpy.zeros(ntot, dtype=dt) data['origtype'][0:gw.size] = 3 data['origtype'][gw.size:] = 6 for n in ['modelflux','modelflux_ivar','psfflux','psfflux_ivar']: data[n][0:gw.size] = gal[n][gw] data[n][gw.size:] = star[n][sw] return data
def add_to_log_plot(plt, x, y, yerr, color='black', type='filled circle', minval=1.e-5): w = where1(y > minval) if w.size > 0: p = Points(x[w], y[w],type=type,color=color) plt.add(p) else: p=None ehigh = y + yerr elow = y - yerr # only show errors where y+yerr is greater than the min value. w=where1(ehigh > minval) if w.size > 0: elow = where(elow < minval, minval, elow) pe = ErrY(x[w], elow[w], ehigh[w],color=color) plt.add(pe) else: pe=None odict={} odict['p'] = p odict['pe'] = p #odict['xrange'] = [0.3*x.min(), 2.25*x.max()] #odict['yrange'] = [0.3*elow.min(), 2.25*ehigh.max()] odict['xrange'] = eu.plotting.get_log_plot_range(x) odict['yrange'] = eu.plotting.get_log_plot_range(y,yerr) return odict
def find_mvir(self, r, mass, masserr): """ Look where the mass curve crosses the mass from the background times delrho r in Mpc, mass in Msun """ rap, massap, massaperr, msap = self.get_aperture(r,mass,masserr) wl=where1(msap < massap) wg=where1(msap >= massap) i1 = rap[wl].argmax() i2 = rap[wg].argmin() i1 = wl[i1] i2 = wg[i2] r1 = rap[i1] r2 = rap[i2] if i2-i1 != 1: raise ValueError("indices i1,i2 are not consecutive") al=(log(massap[i2])-log(massap[i1]))/(log(rap[i2])-log(rap[i1])) A=massap[i1]/(rap[i1]**al) B=self.mfactor() rvir=(A/B)**(1./(3.-al)) mvir=B*rvir**3 mvir_err=(massaperr[i1]+massaperr[i2])/2.0 rvir_err=rvir*(mvir_err/mvir)/3.0 return rvir, rvir_err, mvir, mvir_err
def write_columns(self): d = files.input_coldir(self.name, self.version) if os.path.exists(d): raise ValueError("coldir exists, start fresh: '%s'" % d) outcols = Columns(d) outcols.create() if self.logic is None: self.select() w=where1(self.mag_and_mask_logic) print("\nkeeping those that pass mag and mask logic: %s/%s" % (w.size, self.logic.size)) colnames = ['photoid', 'ra', 'dec', 'objc_flags', 'objc_flags2', 'ingood', 'instar', 'inbadfield'] for col in colnames: print('Creating:',col) data = self.cols[col][:] data = data[w] outcols.write_column(col, data) del data combcols = ['flags','flags2', 'modelflux','modelflux_ivar', 'cmodelflux','cmodelflux_ivar', 'extinction'] for ccol in combcols: print('Creating:',ccol) colnames = [ccol+'_'+f for f in ['u','g','r','i','z'] ] data = self.cols.read_columns(colnames, rows=w, verbose=True) dts = data[ccol+'_'+f].dtype.descr[0][1] dt = [(ccol, dts, 5)] data = data.view(dt) # don't want it to show up as a .rec rawdata = data[ccol] outcols.write_column(ccol, rawdata) del data print('Adding more restrictive flags to "keep"') keep = zeros(w.size, dtype='u1') wrest = where1( self.logic[w] ) keep[wrest] = 1 outcols.write_column('keep', keep)
def process_image_cat(imfile, catfile, get_meta=False): """ Process the input image and cat files. If get_meta=True, a tuple of (array, meta) is returned. meta is a dictionary with 'shiftmax' and 'nsub' """ im, ivar_im, cat = read_image_cat(imfile, catfile) col=cat['x_image']-1 row=cat['y_image']-1 sky=cat['background'] colint=col.astype('i4') rowint=row.astype('i4') ivar = ivar_im[rowint,colint] sigsky = zeros(cat.size) w=where1(ivar > 0) wbad=where1(ivar <= 0) if w.size > 0: sigsky[w] = 1.0/sqrt(ivar[w]) print >>stderr,'running admom' tmp=admom.admom(im, row[w], col[w], sky=sky[w], sigsky=sigsky[w]) print >>stderr,'copying to array output' a,h=as_array(cat, w, wbad, tmp) if get_meta: out=(a,h) else: out=a else: out=None return out
def check_bounds(self, ra, dec): """ Select all points within the bounds of the sample specified in "type" """ logic = numpy.zeros(ra.size, dtype=numpy.bool) for type in sorted(bounds): stdout.write("Checking '%s'\n" % type) b = bounds[type] temp_logic = ( (ra >= b['ra'][0]) & (ra <= b['ra'][1]) & (dec >= b['dec'][0]) & (dec <= b['dec'][1]) ) # or the logics together logic = logic | temp_logic w=where1(temp_logic) stdout.write(" Found %s\n" % w.size) del w wtot = where1(logic) stdout.write("Kept a total of %s\n" % wtot.size) return wtot
def rotate_multi(self, runs, camcols, fields, filter, e1pix, e2pix, getrot=False, verbose=False): e1 = numpy.zeros(runs.size, dtype='f8') e2 = e1.copy() if getrot: angles = e1.copy() urun = unique(runs) for run in urun: if verbose: print(" run:", run) wrun = where1(runs == run) ucamcols = unique(camcols[wrun]) for camcol in ucamcols: if verbose: print(" camcol:", camcol) wc = where1(camcols[wrun] == camcol) wc = wrun[wc] h, rev = eu.stat.histogram(fields[wc], binsize=1, rev=True) for i in xrange(h.size): if rev[i] != rev[i + 1]: wf = rev[rev[i]:rev[i + 1]] wf = wc[wf] #uf = unique(fields[wf]) #if uf.size != 1: # raise ValueError("expected unique field") field = fields[wf[0]] #print(" field:",field) res = self.rotate(run, camcol, field, filter, e1pix[wf], e2pix[wf], getrot=getrot, verbose=verbose) e1[wf] = res[0] e2[wf] = res[1] if getrot: angles[wf] = res[2] if getrot: return e1, e2, angles else: return e1, e2
def create_objshear_input(self, nrand=None, extra=None): """ To work in chunks, send nrand= and extra=chunknum """ from es_sdsspy.stomp_maps import get_quad_logic if nrand is not None: if extra is None: raise ValueError("If sending nrand, also send extra=") else: nrand = self['nrand'] self.load_stomp_maps() strict_edgecut = self.get('strict_edgecut',False) print("Generating",nrand,"random points " "with z in [%0.2f,%0.2f]" % (self['zmin'],self['zmax'])) n=0 dt = lensing.files.lcat_dtype() output = numpy.zeros(nrand, dtype=dt) while n < nrand: if n == 0: print(" generating",nrand-n," ",end='') else: print(" re-generating",nrand-n," ",end='') print("z",end='') z = self.zgen.genrand(nrand-n) print(" -> ra,dec ",end='') ra,dec = self.tycho_map.GenerateRandomEq(nrand-n) if 'rmax_hard' in self: print(" -> maskflags_hard (%0.1f)" % self['rmax_hard'], end='') maskflags_hard = self.get_maskflags(ra,dec,z,hard=True) hard_edge_logic = get_quad_logic(maskflags_hard, strict=True) print(" -> maskflags (%0.1f)" % self['rmax'], end='') maskflags = self.get_maskflags(ra,dec,z) quad_logic = get_quad_logic(maskflags,strict=strict_edgecut) if 'rmax_hard' in self: wgood = where1(quad_logic & hard_edge_logic) else: wgood = where1(quad_logic) print(" -> good ones:",wgood.size) if wgood.size > 0: output['zindex'][n:n+wgood.size] = \ numpy.arange(n,n+wgood.size,dtype='i4') output['ra'][n:n+wgood.size] = ra[wgood] output['dec'][n:n+wgood.size] = dec[wgood] output['z'][n:n+wgood.size] = z[wgood] output['maskflags'][n:n+wgood.size] = maskflags[wgood] n += wgood.size lensing.files.lcat_write(sample=self['sample'], data=output, extra=extra)
def select_goods_gal(self,d): wf=where1(d['flags'] == 0) plt=eu.plotting.bscatter(d['mag_best'][wf], d['class_star'][wf], xrange=[15,30], yrange=[-0.05,1.05], type='dot', xlabel='mag_best',ylabel='class_star', show=False) w=where1( (d['flags'] == 0) & (d['mag_best'] < 25) & (d['class_star'] < 0.8)) eu.plotting.bscatter(d['mag_best'][w], d['class_star'][w], type='filled circle', color='red', plt=plt)
def gather_epochs(self, data, epochs_index_current): photoid = sdsspy.photoid(data) fh, frev=eu.stat.histogram(data['field'], binsize=1, rev=True) epochlist = [] epochs_indices = numpy.zeros(data.size) epochs_count = numpy.zeros(data.size) epochs_index = epochs_index_current for i in xrange(fh.size): if frev[i] != frev[i+1]: wfield = frev[ frev[i]:frev[i+1] ] field = data['field'][wfield[0]] epochs = sdsspy.read('photoEpochs', data['run'][0], data['camcol'][0], field=field, verbose=False, lower=True) # first extract those that were actually used according # to the criteria for selecting the primaries above w=where1(epochs['cmodel_used'][:,2] == 1) if w.size == 0: raise ValueError("found none that were used!") epochs = epochs[w] # extract those that match by photoid for j in xrange(wfield.size): pid = photoid[wfield[j]] w=where1(epochs['primary_photoid'] == pid) if w.size == 0: raise ValueError("no matches for pid",pid) epochs_indices[wfield[j]] = epochs_index epochs_count[wfield[j]] = w.size epochs_index += w.size epochlist.append(epochs[w]) if len(epochlist) == 0: raise ValueError("Expected to find some epochs!") epochs = eu.numpy_util.combine_arrlist(epochlist) if (epochs_index-epochs_index_current) != epochs.size: raise ValueError("epoch index not incremented right amount:" "%i vs %i" % (epochs_index-epochs_index_current,epochs.size)) return epochs, epochs_indices, epochs_count
def create_objshear_input(self, **keys): from es_sdsspy.stomp_maps import get_quad_logic lens_split=keys.get('lens_split',None) if lens_split is None: raise ValueError("send lens_split=") nsplit=self['nsplit'] print("doing lens_split %s: %s/%s" % (lens_split,lens_split+1,nsplit)) strict_edgecut = self['strict_edgecut'] n=0 data=self.read_original() ntot=data.size npersplit = data.size/nsplit start = lens_split*npersplit end = (lens_split+1)*npersplit data = data[start:end] print('lens_split',lens_split) print(' keeping: %d/%d' % (data.size,ntot)) # trim z for speed was not implemented in rmrand01 z_logic = self.get_z_logic(data['z']) w=where1(z_logic) data=data[w] maskflags = self.get_maskflags(data['ra'],data['dec'],data['z']) quad_logic = get_quad_logic(maskflags, strict=strict_edgecut) wgood = where1(quad_logic) print(" keeping: %d/%d" %(wgood.size,data.size)) data = data[wgood] maskflags = maskflags[wgood] dt = lensing.files.lcat_dtype() output = numpy.zeros(wgood.size, dtype=dt) output['zindex'][:] = data['zindex'] output['ra'][:] = data['ra'] output['dec'][:] = data['dec'] output['z'][:] = data['z'] output['maskflags'][:] = maskflags lensing.files.lcat_write(sample=self['sample'], data=output, lens_split=lens_split)
def tselect(t): import sdsspy from esutil.numpy_util import where1 plogic = (t['resolve_status'] & sdsspy.flagval('resolve_status','survey_primary')) != 0 blended_logic = (t['objc_flags'] & sdsspy.flagval('object1','blended')) == 0 nodeblend_logic = (t['objc_flags'] & sdsspy.flagval('object1','nodeblend')) != 0 pw = where1( plogic ) aw = where1( plogic & (blended_logic | nodeblend_logic) ) print 'primary:',pw.size print 'primary + blend cuts:',aw.size
def make_nasa_sdss_edge(stomp_map='boss', map_type='good', radmax=10.): """ radmax in degrees """ data=read_nasa_sdss() flagname='boss%s_maskflags' % map_type edgename='boss%s_edgeok' % map_type out = eu.numpy_util.add_fields(data, [(flagname,'i2',len(_radii)), (edgename,'i2',len(_radii))]) out[flagname] = -1 out[edgename] = 0 m = es_sdsspy.stomp_maps.load(stomp_map,map_type) cosmo = cosmology.Cosmo() for i,r in enumerate(_radii): w=where1(out['z'] > 0.0) d = cosmo.Da(0.0, data['z'][w]) srad = r/d*180.0/numpy.pi w2=where1(srad < radmax) print ' Found',w2.size,'with search rad <',radmax,'degrees' srad=srad[w2] w=w[w2] print ' search rad range from:',srad.min(),srad.max(),'degrees' print ' Checking edges' maskflags=m.Contains(out['ra'][w], out['dec'][w],"eq",srad) good=es_sdsspy.stomp_maps.quad_check(maskflags, strict=True) out[flagname][w,i] = maskflags[:] out[edgename][w[good],i] = 1 rstr = ' '.join( [str(r) for r in _radii] ) header=[{'name':'map', 'value':stomp_map, 'comment':'stomp map'}, {'name':'map_type','value':map_type, 'comment':'stomp map type'}, {'name':'H0', 'value':cosmo.H0(), 'comment':'H0 used for distance calculations'}, {'name':'flat', 'value':cosmo.flat(), 'comment':'Was a flat universe used?'}, {'name':'omega_m', 'value':cosmo.omega_m(), 'comment':'omega_m used for distance calculations'}, {'name':'omega_l', 'value':cosmo.omega_l(), 'comment':'omega_l used for distance calculations'}, {'name':'omega_k', 'value':cosmo.omega_k(), 'comment':'omega_k used for distance calculations'}, {'name':'radii', 'value':rstr, 'comment':'radii used for edge checks'}] write_nasa_sdss_edge(out, header=header)
def create_objshear_input(self, **keys): from es_sdsspy.stomp_maps import get_quad_logic nsplit=self['nsplit'] if nsplit != 1: raise ValueError("expected nsplit=1 for SDSSVoids") data = self.read_original() orig_size = data.size zindex = numpy.arange(orig_size,dtype='i4') zmin = self['zmin'] zmax = self['zmax'] good=where1( (data['z'] > zmin) & (data['z'] < zmax) ) print(" z cut: %s/%s: %s" % (data.size-good.size, orig_size, (data.size-good.size)/float(orig_size)) ) if good.size == 0: stop print("Actually trimming the bad z for speed") data = data[good] zindex = zindex[good] #maskflags = self.get_maskflags(data['ra'][0:5], data['dec'][0:5], data['z'][0:5]) maskflags = self.get_maskflags(data['ra'], data['dec'], data['z']) quad_logic = get_quad_logic(maskflags) good = where1(quad_logic) print(" quad mask cut: %s/%s: %s" % (data.size-good.size, orig_size, (data.size-good.size)/float(orig_size)) ) if good.size == 0: stop print('creating output array') output = make_output_array(good.size) print('copying data') output['zindex'] = zindex[good] output['ra'] = data['ra'][good] output['dec'] = data['dec'][good] output['z'] = data['z'][good] output['maskflags'] = maskflags[good] lensing.files.lcat_write(sample=self['sample'], data=output, lens_split=0)
def match_columns(photoid, tags, type='primgal'): """ Take the input photoids and match it to the input photo columns. Extract the requested columns. """ if isinstance(tags, str): tags=[tags] cols = open_columns(type) add_descr = [] for tag in tags: if tag not in cols: raise ValueError("Requested tag not in database:",tag) print("will extract:",cols[tag].dtype.descr[0]) add_descr.append(cols[tag].dtype.descr[0]) print("reading photoid from columns") pid = cols['photoid'][:] print("matching") minput, mcols = eu.numpy_util.match(photoid, pid) if minput.size != photoid.size: raise ValueError("Not all objects matched: %d/%d" % (minput.size, photoid.size)) print("verifying") tpid = cols['photoid'][mcols] wbad=where1(tpid != photoid[minput]) if wbad.size != 0: raise ValueError("extracted photoid did not match up") struct = cols.read_columns(tags, rows=mcols) return struct
def create_objshear_input(self, **keys): data = self.read_original() # keep index into original data orig_size = data.size zindex = numpy.arange(orig_size,dtype='i4') # trim not well understood low ngals stuff ngals_logic = self.ngals_logic(data['ngals_r200']) # trim z for speed z_logic = self.get_z_logic(data['photoz_cts']) good = where1(ngals_logic & z_logic) print("Finally kept: %d/%d" % (good.size,data.size)) print('creating output array') output = make_output_array(good.size) print('copying data') output['zindex'] = zindex[good] output['ra'] = data['ra'][good] output['dec'] = data['dec'][good] output['z'] = data['photoz_cts'][good] output['maskflags'] = self.get_maskflags(output['ra'],output['dec'],output['z']) lensing.files.lcat_write(sample=self['sample'], data=output)
def select_good_me_bycol(c): flags = c['shear_flags'][:] flagsin = c['input_flags'][:] flagswt = c['flags_weight'][:] w = where1((flags == 0) & (flagsin == 0) & (flagswt==0)) return w
def j3(self, r, **keys): """ This is proportional to the mass enclosed. If you do a fit for B, then you should be able to just multiply B*rhocrit0*j3 to get the mass. rhocrit0 is the rhocrit at redshift 0. See the m() for that very thing. You should use a small radius to get the mass right """ xi = self.xi(r, **keys) w=where1(xi <= 0) if w.size > 0: raise ValueError("all xi must be > 0 for power law " "interpolation") lr = log(r) lxi = log(xi) al=( lxi-roll(lxi,1) )/( lr-roll(lr,1) ) al[0]=al[1] A=xi/r**(al) ex=3.0+al Rb=r Ra=roll(r,1) Ra[0]=0.0 int0=A*(1.0/ex) *(Rb**ex -Ra**ex) j3=4*PI*int0.cumsum() return j3
def load(self, reload=False): if not hasattr(RunList, 'data') or reload: rl = read('runList') # remove duplicate, bad entry w = where1((rl['run'] != 5194) | (rl['rerun'] == '301')) rl = rl[w] RunList.data = rl
def rotate(self, run, camcol, field, filter, e1pix, e2pix, getrot=False, verbose=False): if not numpy.isscalar(run): return self.rotate_multi(run,camcol,field,filter,e1pix,e2pix, getrot=getrot, verbose=verbose) self.load_run(run) if verbose: print("%06i-%i-%04i" % (run,camcol,field)) w=where1((self.rotstruct['camcol'] == camcol) & (self.rotstruct['field'] == field) ) if w.size != 1: print("expected single match for %06i-%i-%04i, got %i" % (run,camcol,field,w.size)) fields = numpy.unique(self.rotstruct['field']) print("here are the fields:",fields) raise ValueError("stopping") filternum = sdsspy.FILTERNUM[filter] cos2angle = self.rotstruct['cos2angle'][w,filternum] sin2angle = self.rotstruct['sin2angle'][w,filternum] # hmm... this seems to be applying -2*angle rotation... e1 = e1pix*cos2angle + e2pix*sin2angle e2 = -e1pix*sin2angle + e2pix*cos2angle if getrot: angle = self.rotstruct['angle'][w,filternum] angles = numpy.zeros(e1.size, dtype='f8') + angle[0] return e1, e2, angles else: return e1,e2
def readfield(self, type, run, camcol, field, **keys): self.cache_column(type, run, camcol, **keys) data = self.data w=where1(data['field'] == field) if w.size == 0: raise ValueError("field not found: %06i-%i-%04i" % (run,camcol,field)) return data[w]
def readobj(self, type, run, camcol, field, id, **keys): self.cache_column(type, run, camcol, **keys) data = self.data w=where1( (data['field'] == field) & (data['id'] == id) ) if w.size == 0: raise ValueError("object not found: %06i-%i-%04i-%05i" % (run,camcol,field,id)) return data[w[0]]
def load(self, reload=False): if not hasattr(RunList, 'data') or reload: rl = read('runList') # remove duplicate, bad entry w=where1( (rl['run'] != 5194) | (rl['rerun'] == '301')) rl = rl[w] RunList.data = rl
def create_objshear_input(self, **keys): nsplit=self['nsplit'] if nsplit != 1: raise ValueError("expected nsplit=1 for RedMapperDES") z_field = self['z_field'] data = self.read_original() # keep index into original data orig_size = data.size zindex = numpy.arange(orig_size,dtype='i4') # trim z for speed z_logic = self.get_z_logic(data[z_field]) good=where1(z_logic) # make sure in the tycho window and two adjacent quadrants # not hitting edge (or no edge if strict=True) print('creating output array') output = make_output_array(good.size) print('copying data') output['zindex'] = zindex[good] output['ra'] = data['ra'][good] output['dec'] = data['dec'][good] output['z'] = data[z_field][good] output['maskflags'] = 0 # not currently used lensing.files.lcat_write(sample=self['sample'], data=output, lens_split=0)
def get_primary_indices(self, objs, run_primary=False): if run_primary: primary = self.flags.val('resolve_status','run_primary') else: primary = self.flags.val('resolve_status','survey_primary') w=where1((objs['resolve_status'] & primary) != 0) return w
def doplot(region=None, file=None): import biggles data = read_nasa_sdss_edge() lam,eta=eu.coords.eq2sdss(data['ra'],data['dec']) w0=where1( data['bossgood_edgeok'][:,0] == 1) w1=where1( data['bossgood_edgeok'][:,1] == 1) xlabel=r'$\lambda$' ylabel=r'$\eta$' plt=eu.plotting.bscatter(lam,eta, type='dot', xlabel=xlabel, ylabel=ylabel, show=False) plt=eu.plotting.bscatter(lam[w0],eta[w0], type='dot', color='red', show=False,plt=plt) plt=eu.plotting.bscatter(lam[w1],eta[w1], type='dot', color='blue', show=False,plt=plt) plt=es_sdsspy.stomp_maps.plot_boss_geometry(plt=plt, region=region, show=False) fake=eu.plotting.fake_filled_circles(['all','r=%0.2f' % _radii[0], 'r=%0.2f' % _radii[1]], colors=['black','red','blue']) # bug in biggles, ignores valign='bottom' for PlotKey valign='top' if region is None: k_yval=0.6 l_yval=0.6 elif region == 'sgc': k_yval=0.2 l_yval=0.05 valign='bottom' else: k_yval=0.95 l_yval=0.95 key=biggles.PlotKey(0.95,k_yval,fake,halign='right',valign=valign) plt.add(key) if region is not None: nt=biggles.PlotLabel(0.05,l_yval,region.upper(),halign='left',valign=valign) plt.add(nt) if file is None: plt.show() else: print 'Writing plot file:',file plt.write_eps(file)
def rotate_multi(self, runs, camcols, fields, filter, e1pix, e2pix, getrot=False, verbose=False): e1=numpy.zeros(runs.size, dtype='f8') e2=e1.copy() if getrot: angles = e1.copy() urun = unique(runs) for run in urun: if verbose: print(" run:",run) wrun=where1(runs == run) ucamcols = unique(camcols[wrun]) for camcol in ucamcols: if verbose: print(" camcol:",camcol) wc=where1( camcols[wrun] == camcol) wc=wrun[wc] h,rev=eu.stat.histogram(fields[wc], binsize=1, rev=True) for i in xrange(h.size): if rev[i] != rev[i+1]: wf = rev[rev[i]:rev[i+1]] wf = wc[wf] #uf = unique(fields[wf]) #if uf.size != 1: # raise ValueError("expected unique field") field = fields[wf[0]] #print(" field:",field) res=self.rotate(run, camcol, field, filter, e1pix[wf], e2pix[wf], getrot=getrot, verbose=verbose) e1[wf] = res[0] e2[wf] = res[1] if getrot: angles[wf] = res[2] if getrot: return e1,e2,angles else: return e1,e2
def create_objshear_input(self, lens_split=None): """ To work in chunks, send nrand= and extra=chunknum """ from es_sdsspy.stomp_maps import get_quad_logic nsplit=self['nsplit'] if lens_split is None: raise ValueError("send lens_split=") print("doing lens_split %s: %s/%s" % (lens_split,lens_split+1,nsplit)) self.load_stomp_maps() strict_edgecut = self['strict_edgecut'] n=0 data=self.read_raw() zindex = numpy.arange(data.size,dtype='i4') # do in chunks so we can see the progress npersplit = data.size/nsplit nleft = data.size % nsplit data = data[lens_split*npersplit:(lens_split+1)*npersplit] zindex = zindex[lens_split*npersplit:(lens_split+1)*npersplit] #data = data[0:100] #zindex = zindex[0:100] print("Generating z in [%0.2f,%0.2f]" % (self['zmin'],self['zmax'])) z = self.zgen.genrand(data.size) print(" -> maskflags, max radius: %0.1f" % self['rmax']) maskflags = self.get_maskflags(data['ra'],data['dec'],z) quad_logic = get_quad_logic(maskflags, strict=strict_edgecut) wgood = where1(quad_logic) print(" -> good ones:",wgood.size) data = data[wgood] zindex = zindex[wgood] z = z[wgood] maskflags = maskflags[wgood] dt = lensing.files.lcat_dtype() output = numpy.zeros(wgood.size, dtype=dt) output['zindex'][:] = zindex output['ra'][:] = data['ra'] output['dec'][:] = data['dec'] output['z'][:] = z output['maskflags'][:] = maskflags lensing.files.lcat_write(sample=self['sample'], data=output, lens_split=lens_split)
def load_primary_avg_gri(self, indices=None): cols = self.open_columns('primary82') cmodel_mean_g = cols['cmodelflux_mean_g'][:] cmodel_mean_ivar_g = cols['cmodelflux_mean_ivar_g'][:] psf_mean_g = cols['psfflux_mean_g'][:] psf_mean_ivar_g = cols['psfflux_mean_ivar_g'][:] cmodel_mean_r = cols['cmodelflux_mean_r'][:] cmodel_mean_ivar_r = cols['cmodelflux_mean_ivar_r'][:] psf_mean_r = cols['psfflux_mean_r'][:] psf_mean_ivar_r = cols['psfflux_mean_ivar_r'][:] cmodel_mean_i = cols['cmodelflux_mean_i'][:] cmodel_mean_ivar_i = cols['cmodelflux_mean_ivar_i'][:] psf_mean_i = cols['psfflux_mean_i'][:] psf_mean_ivar_i = cols['psfflux_mean_ivar_i'][:] cmodelflux, cmodelflux_ivar = avg_gri(cmodel_mean_g, cmodel_mean_ivar_g, cmodel_mean_r, cmodel_mean_ivar_r, cmodel_mean_i, cmodel_mean_ivar_i) psfflux, psfflux_ivar = avg_gri(psf_mean_g, psf_mean_ivar_g, psf_mean_r, psf_mean_ivar_r, psf_mean_i, psf_mean_ivar_i) cbad=where1(numpy.isnan(cmodelflux)) if cbad.size != 0: raise ValueError("nan found in cmodelflux") pbad=where1(numpy.isnan(psfflux)) if pbad.size != 0: raise ValueError("nan found in psfflux") if indices is not None: cmodelflux=cmodelflux[indices] cmodelflux_ivar=cmodelflux_ivar[indices] psfflux=psfflux[indices] psfflux_ivar=psfflux_ivar[indices] return cmodelflux, cmodelflux_ivar, psfflux, psfflux_ivar
def ngals_logic(self, ngals): print("Cutting ngals >= %d" % self['ngals_r200_min']) logic = ngals >= self['ngals_r200_min'] w=where1(logic) print(" Keeping %d/%d" % (w.size,ngals.size)) if w.size == 0: raise ValueError("No objects passed z cut") return logic
def get_z_logic(self, z): print("Cutting z to [%f, %f]" % (self['zmin'],self['zmax'])) logic = (z > self['zmin']) & (z < self['zmax']) w=where1(logic) print(" Keeping %d/%d" % (w.size,z.size)) if w.size == 0: raise ValueError("No objects passed z cut") return logic
def make_rotation_test_data(run=4335, camcol=3, field=100): c = lensing.regauss.open_columns('04') # note logic returns indices for Columns columns! w = c['run'] == run if w.size == 0: raise ValueError("no objects found for run %d" % run) flags = c['corrflags_rg_r'][w] camcols = c['camcol'][w] fields = c['field'][w] w2 = where1((camcols == camcol) & (flags == 0) & (fields == field)) #w2=where1( camcols == camcol ) if w2.size == 0: raise ValueError("not objects in camcol %s with flags==0" % camcol) w = w[w2] data = c.read_columns( ['ra', 'dec', 'run', 'camcol', 'field', 'e1_rg_r', 'e2_rg_r'], rows=w) output = numpy.zeros(data.size, dtype=[('ra', 'f8'), ('dec', 'f8'), ('g1eq', 'f8'), ('g2eq', 'f8'), ('clambda', 'f8'), ('ceta', 'f8'), ('g1survey', 'f8'), ('g2survey', 'f8')]) output['ra'] = data['ra'] output['dec'] = data['dec'] lam, eta = eu.coords.eq2sdss(data['ra'], data['dec']) output['clambda'] = lam output['ceta'] = eta eq_rotator = SDSSRotator('eq') survey_rotator = SDSSRotator('survey') g1eq_alt, g2eq_alt = eq_rotator.rotate(data['run'], data['camcol'], data['field'], 2, data['e1_rg_r'], data['e2_rg_r'], verbose=True) g1eq_alt /= 2 g2eq_alt /= 2 output_file = os.path.expanduser('~/tmp/test-rot/test-rot.rec') print("writing output file:", output_file) fobj = open(output_file, 'w') num = numpy.array([output.size], dtype='i8') num.tofile(fobj) #robj = eu.recfile.Recfile(output_file, 'w', delim=' ') robj = eu.recfile.Recfile(fobj, 'r+') robj.write(output) robj.close()
def rotate(self, run, camcol, field, filter, e1pix, e2pix, getrot=False, verbose=False): if not numpy.isscalar(run): return self.rotate_multi(run, camcol, field, filter, e1pix, e2pix, getrot=getrot, verbose=verbose) self.load_run(run) if verbose: print("%06i-%i-%04i" % (run, camcol, field)) w = where1((self.rotstruct['camcol'] == camcol) & (self.rotstruct['field'] == field)) if w.size != 1: print("expected single match for %06i-%i-%04i, got %i" % (run, camcol, field, w.size)) fields = numpy.unique(self.rotstruct['field']) print("here are the fields:", fields) raise ValueError("stopping") filternum = sdsspy.FILTERNUM[filter] cos2angle = self.rotstruct['cos2angle'][w, filternum] sin2angle = self.rotstruct['sin2angle'][w, filternum] # hmm... this seems to be applying -2*angle rotation... e1 = e1pix * cos2angle + e2pix * sin2angle e2 = -e1pix * sin2angle + e2pix * cos2angle if getrot: angle = self.rotstruct['angle'][w, filternum] angles = numpy.zeros(e1.size, dtype='f8') + angle[0] return e1, e2, angles else: return e1, e2
def compare(self, run): import biggles import pcolors pdata, mdata = self.load_data(run) if len(pdata) == 0: print("no princeton data found") return if len(mdata) == 0: print("no my data found") return tab = biggles.Table(2, 2) pcos_plt = biggles.FramedPlot() psin_plt = biggles.FramedPlot() mcos_plt = biggles.FramedPlot() msin_plt = biggles.FramedPlot() pcos_plots = [] psin_plots = [] mcos_plots = [] msin_plots = [] colors = pcolors.rainbow(6, 'hex') for camcol in xrange(1, 6 + 1): # first princeton wp = where1(pdata['camcol'] == camcol) bcos = eu.stat.Binner(pdata['field'][wp], cos(2 * pdata['phi_offset'][wp])) bcos.dohist(binsize=1.0) bcos.calc_stats() wgood_cos = where1(bcos['hist'] > 0) pcos = biggles.Curve(bcos['xmean'][wgood_cos], bcos['ymean'][wgood_cos], color=colors[camcol - 1]) pcos.label = 'princ camcol %s' % camcol pcos_plt.add(pcos) pcos_plots.append(pcos) bsin = eu.stat.Binner(pdata['field'][wp], sin(2 * pdata['phi_offset'][wp])) bsin.dohist(binsize=1.0) bsin.calc_stats() wgood_sin = where1(bsin['hist'] > 0) psin = biggles.Curve(bsin['xmean'][wgood_sin], bsin['ymean'][wgood_sin], color=colors[camcol - 1]) psin.label = 'princ camcol %s' % camcol psin_plt.add(psin) psin_plots.append(psin) # now mine wm = where1(mdata['camcol'] == camcol) mpcos = biggles.Curve(mdata['field'][wm], cos(2 * mdata['angle'][wm, 2]), color=colors[camcol - 1]) mpcos.label = 'mine camcol %s' % camcol mcos_plt.add(mpcos) mcos_plots.append(mpcos) wm = where1(mdata['camcol'] == camcol) mpsin = biggles.Curve(mdata['field'][wm], sin(2 * mdata['angle'][wm, 2]), color=colors[camcol - 1]) mpsin.label = 'mine camcol %s' % camcol msin_plt.add(mpsin) msin_plots.append(mpsin) # princeton stuff pcos_key = biggles.PlotKey(0.1, 0.9, pcos_plots) pcos_plt.add(pcos_key) pcos_plt.xlabel = 'Field' pcos_plt.title = 'Run: %s' % run pcos_plt.ylabel = 'cos(2*angle)' psin_key = biggles.PlotKey(0.1, 0.9, psin_plots) psin_plt.add(psin_key) psin_plt.xlabel = 'Field' psin_plt.title = 'Run: %s' % run psin_plt.ylabel = 'sin(2*angle)' tab[0, 0] = pcos_plt tab[0, 1] = psin_plt # my stuff mcos_key = biggles.PlotKey(0.1, 0.9, mcos_plots) mcos_plt.add(mcos_key) mcos_plt.xlabel = 'Field' mcos_plt.title = 'Run: %s' % run mcos_plt.ylabel = 'cos(2*angle)' msin_key = biggles.PlotKey(0.1, 0.9, msin_plots) msin_plt.add(msin_key) msin_plt.xlabel = 'Field' msin_plt.title = 'Run: %s' % run msin_plt.ylabel = 'sin(2*angle)' tab[1, 0] = mcos_plt tab[1, 1] = msin_plt tab.show()