Example #1
0
    def add_noise(self, ci):
        """
        Add noise based on requested S/N.  We only add background noise
        so the S/N is

              sum(pix)
        -------------------   = S/N
        sqrt(npix*skysig**2)

        thus
            
            sum(pix)
        ----------------   = sigsky
        sqrt(npix)*(S/N)

        
        We use an aperture of 3sigma but if no pixels
        are returned we increase the aperture until some
        are returned.

        Side effects:
            ci.image is set to the noisy image
            self['sigsky'] is set to the noise level
        """
        s2n = self['s2n']

        cen = ci['cen_uw']
        T = ci['cov_uw'][0] + ci['cov_uw'][2]
        sigma = fimage.mom2sigma(T)
        imagenn = ci.image_nonoise
        shape = imagenn.shape

        row,col=ogrid[0:shape[0], 0:shape[1]]
        rm = array(row - cen[0], dtype='f8')
        cm = array(col - cen[1], dtype='f8')

        radpix = sqrt(rm**2 + cm**2)
        # sigfac is 4 in admom
        sigfac = 4.0
        step=0.1
        w = where(radpix <= sigfac*sigma)
        npix = w[0].size + w[1].size
        while npix == 0:
            sigfac += step
            w = where(radpix <= sigfac*sigma)
            npix = w[0].size + w[1].size

        pix = imagenn[w]
        wt = sqrt(pix)
        wsignal = (wt*pix).sum()
        wsum = wt.sum()

        sigsky = wsignal/sqrt(wsum)/s2n

        noise_image = \
            sigsky*standard_normal(imagenn.size).reshape(shape)
        ci.image = imagenn + noise_image

        out = admom.admom(ci.image, cen[0], cen[1], guess=T/2., sigsky=sigsky)

        # fix up sigsky based on measurement
        sigsky = out['s2n']/s2n*sigsky
        noise_image = \
            sigsky*standard_normal(imagenn.size).reshape(shape)
        ci.image = imagenn + noise_image
        self['sigsky'] = sigsky


        if False:
            out = admom.admom(ci.image, cen[0], cen[1], guess=T/2., sigsky=sigsky)
            print("    target S/N:            ",s2n)
            print("    meas S/N after noise:  ",out['s2n'])
Example #2
0
def run_trials(nsub, rg_admom_nsub):
    n=100
    rg_image_nsub = rg_admom_nsub 
    psf_order=10
    gal_shear_order = 8

    gal_theta = numpy.linspace(0.01843243,179.13423,n)
    spacing = gal_theta[1]-gal_theta[0]
    gal_theta += numpy.random.random(n)*spacing
    gal_T = 3.1+2.7
    gal_T = gal_T*10
    gal_e = 0.3

    # reduced shear required to make round
    shear = tanh( 0.5*arctanh(gal_e) )

    dt=[('gal_theta','f8'),
        ('shear1','f8'),
        ('shear2','f8'),
        ('shear','f8'),
        ('shear1meas','f8'),
        ('shear2meas','f8'),
        ('shearmeas','f8')]

    wl_shear=numpy.zeros(n, dtype=dt)
    am_shear=numpy.zeros(n, dtype=dt)

    wl_shear['gal_theta'] = gal_theta
    wl_shear['shear'] = shear
    am_shear['gal_theta'] = gal_theta
    am_shear['shear'] = shear

    for i in xrange(n):
        galcov=fimage.conversions.ellip2mom(gal_T,e=gal_e,
                                            theta=gal_theta[i])

        psfcov=[2.0,0.0,2.0]
        #psfcov=[2.0*5,0.0,2.0*5]
        imcov=[galcov[0]+psfcov[0], 
               galcov[1]+psfcov[1], 
               galcov[2]+psfcov[2]]

        im_sigma = fimage.mom2sigma(imcov[0]+imcov[2])
        dims = int(2*6*im_sigma)
        if (dims % 2) == 0:
            dims+=1
        if dims < 31: dims=31
        dims = [dims]*2

        shear1=0.5*(galcov[2]-galcov[0])/(galcov[2]+galcov[0])
        shear2=0.5*2*galcov[1]/(galcov[2]+galcov[0])
        wl_shear['shear1'][i] = shear1
        wl_shear['shear2'][i] = shear2
        am_shear['shear1'][i] = shear1
        am_shear['shear2'][i] = shear2
    

        wlq = deswl.cwl.WLQuick(psf_order,gal_shear_order)

        sky=0.0

        psfcen=[(dims[0]-1.)/2., (dims[0]-1.)/2.]
        psf = fimage.model_image('gauss',dims,psfcen,psfcov,
                                 nsub=nsub,counts=1)

        imcen=[(dims[0]-1.)/2., (dims[0]-1.)/2.]
        im = fimage.model_image('gauss',dims,imcen,imcov,
                                 nsub=nsub,counts=10000)

        aperture = 4.0*fimage.mom2sigma(imcov[0]+imcov[2])

        skysig=1.0
        wlq.set_psf(psf,psfcen[0],psfcen[1],sky)
        wlq.set_image(im,imcen[0],imcen[1],sky,skysig,aperture)

        guess=2.0
        flags = wlq.calculate_psf_sigma(guess)
        if flags != 0:
            print 'sigma flags:',flags
            return
        #print 'input psf sigma:',fimage.mom2sigma(psfcov[0]+psfcov[2])
        #print 'measured sigma: ',wlq.get_psf_sigma()

        flags += wlq.calculate_psf_shapelets()
        if flags != 0:
            print 'psf shapelets flags:',flags
            return

        #print
        flags += wlq.calculate_shear()
        if flags != 0:
            print 'shear flags:',flags
            return

        wl_shear['shear1meas'][i] = - wlq.get_shear1()
        wl_shear['shear2meas'][i] =   wlq.get_shear2()
        wl_shear['shearmeas'][i] = sqrt(wlq.get_shear1()**2 + 
                                        wlq.get_shear2()**2)

        #wl_shear['shear1meas'][i] = - 0.5*wlq.get_e1()
        #wl_shear['shear2meas'][i] = - 0.5*wlq.get_e2()

        rgkeys={}
        rgkeys['guess'] = (galcov[0] + galcov[2])/2
        rgkeys['guess_psf'] = (psfcov[0] + psfcov[2])/2
        rgkeys['admom_nsub'] = rg_admom_nsub
        rgkeys['image_nsub'] = rg_image_nsub
        #rgkeys['verbose'] = True
        rg = admom.ReGauss(im, imcen[0], imcen[1], psf, **rgkeys)
        rg.do_all()

        #am_shear['shear1meas'][i]=0.5*rg['rgcorrstats']['e1']
        #am_shear['shear2meas'][i]=0.5*rg['rgcorrstats']['e2']
        am_shear['shear1meas'][i]=0.5*rg['corrstats']['e1']
        am_shear['shear2meas'][i]=0.5*rg['corrstats']['e2']

        ame = sqrt(rg['corrstats']['e1']**2 + rg['corrstats']['e2']**2)

        am_shear['shearmeas'][i] = tanh(0.5*arctanh(ame))

        s='theta: %g in: %g %g wl: %g %g %g %g am: %g %g %g %g'

        s = s % (gal_theta[i],
                 shear1,shear2,
                 wl_shear['shear1meas'][i], 
                 wl_shear['shear1meas'][i]/shear1-1,
                 wl_shear['shear2meas'][i], 
                 wl_shear['shear2meas'][i]/shear2-1,
                 am_shear['shear1meas'][i], 
                 am_shear['shear1meas'][i]/shear1-1,
                 am_shear['shear2meas'][i], 
                 am_shear['shear2meas'][i]/shear2-1)
        print s
    return wl_shear, am_shear
Example #3
0
    def copy_output(self, s2, ellip, s2n, ci, res):
        st = zeros(1, dtype=self.out_dtype())

        # first copy inputs and data from the CI
        st['s2'] = s2
        st['s2n'] = s2n
        st['ellip'] = ellip
        st['e1true'] = ci['e1true']
        st['e2true'] = ci['e2true']
        st['etrue']  = ci['etrue']
        st['gamma'] = e2gamma(st['etrue'])
        st['gamma1'],st['gamma2'] = e1e2_to_g1g2(st['e1true'],st['e2true'])

        st['irr_uw'] = ci['cov_uw'][0]
        st['irc_uw'] = ci['cov_uw'][1]
        st['icc_uw'] = ci['cov_uw'][2]

        st['irr_psf_uw'] = ci['cov_psf_uw'][0]
        st['irc_psf_uw'] = ci['cov_psf_uw'][1]
        st['icc_psf_uw'] = ci['cov_psf_uw'][2]

        size2psf = ci['cov_psf_uw'][0]+ci['cov_psf_uw'][2]
        size2obj = ci['cov_image0_uw'][0]+ci['cov_image0_uw'][2]
        st['s2_uw'] = size2psf/size2obj

        s2psf_am = ci['cov_psf_admom'][0]+ci['cov_psf_admom'][2]
        s2obj_am = ci['cov_image0_admom'][0]+ci['cov_image0_admom'][2]
        st['s2admom'] = s2psf_am/s2obj_am
        st['sigma_psf_admom'] = \
            mom2sigma(ci['cov_psf_admom'][0]+ci['cov_psf_admom'][2])
        st['sigma_admom'] = \
            mom2sigma(ci['cov_image0_admom'][0]+ci['cov_image0_admom'][2])
        st['sigma0_admom'] = \
            mom2sigma(ci['cov_admom'][0]+ci['cov_admom'][2])

        if 'psf_res' in res:
            for i,r in enumerate(res['psf_res']['gmix']):
                for k in ['p','row','col','irr','irc','icc']:
                    st['gmix_psf'][k][0,i] = r[k] 

            psf_moms = gmix_image.total_moms(res['psf_res']['gmix'])
            st['irr_psf_meas'] = psf_moms['irr']
            st['irc_psf_meas'] = psf_moms['irc']
            st['icc_psf_meas'] = psf_moms['icc']
            st['sigma_psf_meas'] = 0.5*(psf_moms['irr']+psf_moms['icc'])

            st['numiter_psf'] = res['psf_res']['numiter']
            st['ntry_psf'] = res['psf_res']['ntry']
            st['fdiff_psf'] = res['psf_res']['fdiff']

        if 'res' in res:
            for i,r in enumerate(res['res']['gmix']):
                for k in ['p','row','col','irr','irc','icc']:
                    st['gmix'][k][0,i] = r[k] 

            moms = gmix_image.total_moms(res['res']['gmix'])
            st['irr_meas'] = moms['irr']
            st['irc_meas'] = moms['irc']
            st['icc_meas'] = moms['icc']
            st['s2_meas'] = \
                (psf_moms['irr']+psf_moms['icc'])/(moms['irr']+moms['icc'])
            st['sigma_meas'] = 0.5*(moms['irr']+moms['icc'])

            st['e1_meas'] = (moms['icc']-moms['irr'])/(moms['icc']+moms['irr']) 
            st['e2_meas'] = 2*moms['irc']/(moms['icc']+moms['irr']) 
            st['e_meas'] = sqrt(st['e1_meas']**2 + st['e2_meas']**2)


            st['gamma_meas'] = e2gamma(st['e_meas'])
            st['gamma1_meas'],st['gamma2_meas'] = \
                    e1e2_to_g1g2(st['e1_meas'],st['e2_meas'])

            st['flags'] = res['res']['flags']
            st['numiter'] = res['res']['numiter']
            st['ntry'] = res['res']['ntry']
            st['fdiff'] = res['res']['fdiff']
            
            # only makes sense for ngauss==1, need to adapt
            if s2n > 0:
                Tpsf = psf_moms['irr']+psf_moms['icc']
                Tobj = moms['irr']+moms['icc']
                R = 1.-Tpsf/(Tpsf+Tobj)

                st['e1_corr'] = corr_e(st['e1_meas'], R, s2n)
                st['e2_corr'] = corr_e(st['e2_meas'], R, s2n)
                st['e_corr'] = sqrt(st['e1_corr']**2 + st['e2_corr']**2)

                st['gamma_corr'] = e2gamma(st['e_corr'])
                st['gamma1_corr'],st['gamma2_corr'] = \
                        e1e2_to_g1g2(st['e1_corr'],st['e2_corr'])

        else:
            st['s2_meas'] = -9999



        # figure out how to measure this
        st['s2n_meas'] = st['s2n']


        return st