Exemple #1
0
    def do_position_loop(self):
        """Loop over all possible angular positions for this neighbour realisation."""
        # Some empty datavectors
        De1 = []
        De2 = []
        snr = []

        theta= np.linspace(0,2,10)*np.pi

        for i,t in enumerate(theta):
            print "  --  Level 2 iteration: %d (theta=%f)"%(i,t)

            x = self.neighbour_distance*np.cos(t)
            y = self.neighbour_distance*np.sin(t)

            gal, psf = i3s.setup_simple(boxsize=32, shear=self.g, flux=self.central_flux, psf_ellipticity=self.psf_e, psf_size=self.psf_size, neighbour_ellipticity=self.neighbour_e, neighbour=[x,y], neighbour_flux=self.neighbour_flux, neighbour_size=self.neighbour_radius, wcs=self.wcs, opt=self.opt)
            if self.neighbour_distance< 23:
                wts = self.generate_mock_weightmap(gal.array, x, y)
            else:
                wts = np.ones_like(gal.array)
            res, cat = i3s.run(gal, psf, weights=wts, opt=self.opt, return_cat=True, show=False)

            De1.append(res.e1)
            De2.append(res.e2)
            snr.append(cat.snr)

        # Compute the mean over all positions
        return np.mean(snr), np.mean(De1), np.mean(De2)
Exemple #2
0
    def do_main_calculation(self, central_data, neighbour_data, sel):
        self.generate_central_realisation(central_data, sel)
        if self.complexity != 0:
            self.generate_neighbour_realisation(neighbour_data, central_data,
                                                sel)
            # Draw this neighbour realisation repeatedly on a ring of angular position
            snr, e1, e2 = self.do_position_loop()
        else:
            noise = self.generate_effective_noise(neighbour_data, central_data,
                                                  sel)
            gal, psf = i3s.setup_simple(boxsize=32,
                                        shear=self.g,
                                        flux=self.central_flux,
                                        psf_ellipticity=self.psf_e,
                                        psf_size=self.psf_size,
                                        neighbour=[np.inf, np.inf],
                                        wcs=self.wcs,
                                        opt=self.opt)
            res, cat = i3s.run(gal + noise,
                               psf,
                               opt=self.opt,
                               return_cat=True,
                               show=False)
            snr, e1, e2 = cat.snr, res.e1, res.e2

        return snr, e1, e2
Exemple #3
0
    def do_main_calculation(self, central_data, neighbour_data, sel):
        self.generate_central_realisation(central_data, sel)
        if self.complexity!=0:
            self.generate_neighbour_realisation(neighbour_data, central_data, sel)
            # Draw this neighbour realisation repeatedly on a ring of angular position
            snr, e1, e2 = self.do_position_loop()
        else:
            noise = self.generate_effective_noise(neighbour_data, central_data, sel)
            gal, psf = i3s.setup_simple(boxsize=32, shear=self.g, flux=self.central_flux, psf_ellipticity=self.psf_e, psf_size=self.psf_size,  neighbour=[np.inf,np.inf], wcs=self.wcs, opt=self.opt)
            res, cat = i3s.run(gal+noise, psf, opt=self.opt, return_cat=True, show=False)
            snr, e1, e2 = cat.snr, res.e1, res.e2

        return snr, e1, e2
Exemple #4
0
    def do_position_loop(self):
        """Loop over all possible angular positions for this neighbour realisation."""
        # Some empty datavectors
        De1 = []
        De2 = []
        snr = []

        theta = np.linspace(0, 2, 10) * np.pi

        for i, t in enumerate(theta):
            print "  --  Level 2 iteration: %d (theta=%f)" % (i, t)

            x = self.neighbour_distance * np.cos(t)
            y = self.neighbour_distance * np.sin(t)

            gal, psf = i3s.setup_simple(boxsize=32,
                                        shear=self.g,
                                        flux=self.central_flux,
                                        psf_ellipticity=self.psf_e,
                                        psf_size=self.psf_size,
                                        neighbour_ellipticity=self.neighbour_e,
                                        neighbour=[x, y],
                                        neighbour_flux=self.neighbour_flux,
                                        neighbour_size=self.neighbour_radius,
                                        wcs=self.wcs,
                                        opt=self.opt)
            if self.neighbour_distance < 23:
                wts = self.generate_mock_weightmap(gal.array, x, y)
            else:
                wts = np.ones_like(gal.array)
            res, cat = i3s.run(gal,
                               psf,
                               weights=wts,
                               opt=self.opt,
                               return_cat=True,
                               show=False)

            De1.append(res.e1)
            De2.append(res.e2)
            snr.append(cat.snr)

        # Compute the mean over all positions
        return np.mean(snr), np.mean(De1), np.mean(De2)
    def run(self,
            distributions,
            niterations=2000,
            filename="mc_toy_model-results",
            size=1,
            rank=0):
        # Highest level loop - Sets model parameters
        #-----------------------------------------------------------------------

        self.m = []
        self.centroid = []

        print "Setting up model"

        meds = s.meds_wrapper(
            "/share/des/disc8/cambridge/meds/DES2111+0043-r-sim-ohioA6-meds-y1a1-beta.fits.fz"
        )

        shears = [-0.02, 0.02]
        angles = np.linspace(0, 2 * np.pi, 31)[:-1]

        self.params = {
            "fc": 0,
            "fn": 0,
            "dgn": 0,
            "Rc": 0,
            "Rn": 0,
            "psf_size": 0
        }
        self.priors = {
            "fc": [200, 8000],
            "fn": [2, 9000],
            "dgn": [1, 70],
            "Rc": [0.1, 6.0],
            "Rn": [0.1, 6.0],
            "psf_size": [0.1, 4.0]
        }
        index_c = np.random.choice(distributions.size, niterations * 50)
        index_n = np.random.choice(distributions.size, niterations * 50)

        idone = 0

        for ireal, (icent, ineigh) in enumerate(zip(index_c, index_n)):
            if ireal % size != rank:
                continue
            self.get_realisation(distributions, icent, ineigh, ireal)
            outside_allowed = self.sanity_check()
            if outside_allowed:
                continue

            if idone > niterations: continue

            evec_g = []
            restart = False
            # Second level loop - input shear
            #-----------------------------------------------------------------------
            print "Will evaluate m using %d shear values" % len(shears)
            for ishear, g in enumerate(shears):
                print "g = (%2.2f, 0.00)" % g

                evec_t = []
                centroid = []

                # Third level loop - neighbour position
                #-----------------------------------------------------------------------
                print "Will use %d neighbour angles" % len(angles)
                for ipos, theta in enumerate(angles):
                    if restart: continue

                    x = self.params["dgn"] * np.cos(theta)
                    y = self.params["dgn"] * np.sin(theta)
                    print "theta = %2.3f degrees, position = (%3.2f,%3.2f)" % (
                        theta * 60., x, y)

                    gal, psf = i3s.setup_simple(
                        boxsize=96,
                        shear=(g, 0.0),
                        psf_size=self.params["psf_size"],
                        size=self.params["Rc"],
                        neighbour_ellipticity=(0.0, 0.0),
                        neighbour_flux=self.params["fn"],
                        flux=self.params["fc"],
                        neighbour_size=self.params["Rn"],
                        neighbour=[x, y],
                        opt=meds.options)
                    res = i3s.i3s([gal.array], [psf], meds=meds)

                    evec_t.append([res.e1, res.e2])
                    centroid.append(
                        np.sqrt(res.ra_as * res.ra_as +
                                res.dec_as * res.dec_as))

                meane1 = np.array(evec_t).T[0].mean()
                meane2 = np.array(evec_t).T[1].mean()
                evec_g.append([meane1, meane2])

            # Finally we have a vector, containing one mean measured shape for each of the input shear values
            # Calculate m
            residual_e1 = np.array(evec_g).T[0] - np.array(shears)
            residual_e2 = np.array(evec_g).T[1]

            m = (residual_e1[-1] - residual_e1[0]) / (shears[-1] - shears[0])

            print "---------------------- m=%f" % m
            print centroid

            self.m.append([
                (residual_e1[-1] - residual_e1[0]) / (shears[-1] - shears[0]),
                (residual_e2[-1] - residual_e2[0]) / (shears[-1] - shears[0])
            ])
            self.centroid.append(
                [np.array(centroid).mean(),
                 np.array(centroid).max()])
            if abs(self.m[-1][0]) > 2: continue
            if (self.m[-1][0] < -0.01) and (np.array(centroid).mean() < 1):
                import pdb
                pdb.set_trace()
            self.write_output_line(filename)
            idone += 1

        print "Done all loops"
Exemple #6
0
def make_sersic(e1,e2):
    gal = i3s.setup_simple(boxsize=32,shear=(e1,e2), psf_size=Rp,  size=Rc_med, neighbour_ellipticity=(0.0,0.0), neighbour_flux=fn_med, flux=fc_med, neighbour_size=Rn_med, neighbour=[np.inf,0], opt=m.options)
    return gal[0].array
Exemple #7
0
Rn=2.9
fc=1650
fn=473

Rc_med=2.1
fc_med=945
fn_med=475
Rn_med=1.47

m=s.meds_wrapper("/share/des/disc8/cambridge/meds/DES2111+0043-r-sim-ohioA6-meds-y1a1-beta.fits.fz")

def make_sersic(e1,e2):
    gal = i3s.setup_simple(boxsize=32,shear=(e1,e2), psf_size=Rp,  size=Rc_med, neighbour_ellipticity=(0.0,0.0), neighbour_flux=fn_med, flux=fc_med, neighbour_size=Rn_med, neighbour=[np.inf,0], opt=m.options)
    return gal[0].array

g,p=i3s.setup_simple(boxsize=32,shear=(0.05,0.2), psf_size=Rp,  size=Rc_med, neighbour_ellipticity=(0.0,0.0), neighbour_flux=fn_med, flux=fc_med, neighbour_size=Rn_med, neighbour=[np.inf,0], opt=m.options)

os.system("touch /home/samuroff/hoopoe_paper/toy_model_data/simple_1parfit_e_maxsamples_g1_0.05_g2_0.2_noise8.txt")



gvec=np.linspace(-0.06,0.2,200) 

for i in xrange(30000):
    lvec_noisy0=[]
    noise=np.random.normal(size=32*32).reshape((32,32))*8
    for g1 in gvec:
        im=make_sersic(g1,0.4)
        chi2=((im-g.array+noise)*(im-g.array+noise) ).sum() ; lvec_noisy0.append(-0.5*chi2) ; print g1
    lvec_noisy0=np.array(lvec_noisy0)
    noisy_max = gvec[(lvec_noisy0==lvec_noisy0.max())]
for pe1 in pshears:
    e1ofg = []
    e2ofg = []
    for g1 in gshears:
        e1vec = []
        e2vec = []
        for i, theta in enumerate(angles):
            x = params["dgn"] * np.cos(theta)
            y = params["dgn"] * np.sin(theta)
            gal, psf = i3s.setup_simple(boxsize=48,
                                        shear=(g1, 0.0),
                                        psf_ellipticity=(pe1, 0),
                                        psf_size=params["Rp"],
                                        size=params["Rc"],
                                        neighbour_ellipticity=(0.0, 0.0),
                                        neighbour_flux=params["fn"],
                                        flux=params["fc"],
                                        neighbour_size=params["Rn"],
                                        neighbour=[x, y],
                                        opt=m.options)
            ra, transform, res, model, img = i3s.i3s([gal], [psf],
                                                     meds=m,
                                                     return_all_i3s=True)
            e1vec.append(res.e1)
            e2vec.append(res.e2)
        e1ofg.append([np.mean(e1vec), np.std(e1vec)])
        e2ofg.append([np.mean(e2vec), np.std(e2vec)])
    d1 = np.array(e1ofg).T[0] - gshears
    d2 = np.array(e2ofg).T[0]
    m1ofp.append((d1[1] - d1[0]) / (shears[1] - shears[0]))