def generate_rr(self, set_nbins=None, logbins=True, min_sep=0.01, 
                    force_n_randoms=None, save_to=None, n_chunks=1):
        #Do random-random counts over the entire field.  If set_nbins is declared,
        #generate_rr will not go looking for the correlation functions so that the
        #RR counts for the IC calculation and the CF calculation can be done in parallel.
 
        #Figure out how many randoms we need.  This was calculated by playing with
        #the number of randoms in the GOODS-S field and seeing when the RR counts converged
        #to the "way too many" curve.  27860 per 1.43e-5 steradians was what I settled on.
        #If there's a forced number, it will ignore my estimate.
        #  Amendment 4/15- this minimum number seems to be somewhat too small for fields that 
        #                  aren't as smooth as GOODS-S, so I'm multiplying it by 5.  This looks ok.
        #  Amendment 8/15- added the capability to do this in several chunks.
        
        if force_n_randoms is None:
            surface_density_required = 27860.*5./1.43e-5
            area = self._image_mask.masked_area_solid_angle()
            number_needed = surface_density_required * area
        else:
            number_needed=force_n_randoms

        #If we're doing more than one chunk, divide the number we need into n_chunks chunks
        if n_chunks > 1:
            number_needed = np.ceil(float(number_needed)/n_chunks).astype(int)
        total_number = number_needed * n_chunks
        print "total number: ",  total_number
        print "number per iteration: ", number_needed
        print "number of chunks: ", n_chunks

        #Range of separations to make bins over
        min_ra = self._ra[self._use].min()
        min_dec = self._dec[self._use].min()
        max_ra = self._ra[self._use].max()
        max_dec = self._dec[self._use].max()
        max_sep=misc.ang_sep(min_ra, min_dec, max_ra, max_dec,
                           radians_in=False, radians_out=False)

        #Choose how many bins
        if set_nbins is None:
            #Get our theta bin info from the CF if we can.  Error if we can't
            if self._theta_bins is None:
                raise ValueError("AngularCatalog.generate_rr says: I need"
                                " either a set number of bins (set_nbins=N)"
                                " or thetas from a CF to extrapolate. "
                                " You have given me neither.")
            centers, edges = self._cfs[name].get_thetas(unit='degrees')
            nbins= np.ceil( len(centers) * 2. * max_sep/edges.max())
        else:
            nbins=set_nbins

        #Make the bins
        rr_theta_bins = binclass.ThetaBins(min_sep, max_sep, nbins,
                                           unit='d', logbins=logbins)
        use_centers, use_theta_bins = rr_theta_bins.get_thetas(unit='degrees')

        #Do the loop
        G_p=np.zeros(nbins)
        rr_counts=np.zeros(nbins)
        for n_i in np.arange(n_chunks):
            print "doing chunk #", n_i
            #Remake the random sample so we're sure we have the right oversample factor            
            self.generate_random_sample(masked=True, make_exactly=number_needed)
        
            #Code snippet shamelessly copied from astroML.correlations
            xyz_data = corr.ra_dec_to_xyz(self._ra_random,
                                         self._dec_random)
            data_R = np.asarray(xyz_data, order='F').T
            bins = corr.angular_dist_to_euclidean_dist(use_theta_bins)
            Nbins = len(bins) - 1
            counts_RR = np.zeros(Nbins + 1)
            for i in range(Nbins + 1):
                counts_RR[i] = np.sum(self._random_tree.query_radius(data_R, bins[i],
                                                                            count_only=True))
            rr = np.diff(counts_RR)
            #Landy and Szalay define G_p(theta) as <N_p(theta)>/(n(n-1)/2)
            G_p += rr/(number_needed*(number_needed-1)) 
            rr_counts += rr

        print "Dividing out the theta bin sizes and number of chunks"
        
        #I divide out the bin width because just using the method
        #that L&S detail gives you a {G_p,i} with the property that
        #Sum[G_p,i]=1.  This is not equivalent to Integral[G_p d(theta)]=1,
        #which is what they assume everywhere else.
        #Dividing out the bin width gives you that and lets you pretend
        #G_p is a continuous but chunky-looking function.
        G_p /= np.diff(use_theta_bins)                    
        G_p /= n_chunks                                   
        self._rr_ngals=[total_number, n_chunks]
        self._Gp = gpclass.Gp(min_sep, max_sep, nbins, G_p, total_number,
                              n_chunks, logbins=logbins, unit='d',
                              RR=rr_counts)

        if save_to is not None:
            self.save_gp(save_to)
示例#2
0
    def subdivide_mask(self, n_shortside=3, n_longside=4, preview=False,
                       rotation_angle=None, padding=None, only_show=None,
                       save_plot=None):
        """
        Subdivide mask takes the image mask, draws a rectangle around the
        valid region of the mask, rotated to be as small as possible, and
        subdivides that rectangle.  The rotation angle of the box can be
        set manually and space can be trimmed or added from the sides of
        the box.

        Parameters
        ----------
        n_shortside : integer (optional)
            The number of cells along the short side of the rectangle.
            Default is 3.
            
        n_longside : integer (optional)
            The number of cells along the long side of the rectangle.
            Default is 4.
            
        preview : bool (optional)
            Should the mask show you what this set of parameters looks like
            but not store the results?  If preview == True, either a plot
            will be shown on your screen (no value given for save_plot) or
            saved to a file (save_plot specified).  The image mask object
            will not keep the division information.  If preview == False,
            which is the default, the values will be stored and a plot will
            only be made if save_plot is specified.
            
        rotation_angle : scalar (optional)
            Fixes the rotation angle that the mask's bounding box will be
            defined at with respect to the XY coordinate system of the
            mask.  By default, the routine will choose the integer angle in
            degrees which minimizes the area of the bounding box.
            
        padding : 4 element array-like (optional)
            How many pixels extra to allow in the rotated coordinates of
            the bounding box.  The order is [bottom, top, left, right].
            Positive padding corresponds to moving the edges outwards and
            leaving extra room.  Negative padding will move the bounding
            box inward and cut off part of the mask.
            
        only_show : integer (optional)
            If you only want to see the random points that fall into one of
            the cells in the subdivided mask, you set only_show to that
            cell number.  This will only matter if you have preview=True
            or have specified save_plot.
            
        save_plot : string (optional)
            Name with path from '/' of the file where you would like the
            plot of the subdivided mask saved.  If only_show is set to an
            integer that corresponds to a cell number, only the points in
            that cell will be shown.
        """
        
        #Start by putting down a bunch of randoms.
        ra, dec, __ = self.generate_random_sample(5.e4)
        x1, y1=self.ra_dec_to_xy(ra, dec)

        #Set the padding on each side
        if padding:
            try:
                pad_bottom, pad_top, pad_left, pad_right=padding
            except:
                #If we can't unpack the padding, either raise an
                #informative error (if we're doing the subdivision
                #permanently) or just a warning if we're only previewing
                says_str = "subdivide_mask says: "
                message_str = ("You have given me something I can't use "
                               "for padding.  Padding must be a 4-element "
                               "1D array in the format [bottom, top, left,"
                               " right].")
                if preview == True:
                    print (says_str + "WARNING!  " + message_str +
                           "  No padding used this time")
                    pad_bottom, pad_top, pad_left, pad_right=[0,0,0,0]
                else:
                    raise ValueError(says_str + "ERROR!  " + message_str)
        else:
            pad_bottom, pad_top, pad_left, pad_right=[0,0,0,0]
        
        #If we don't have an already chosen angle, choose a bunch of angles
        #and transform the coordinates to rotated systems and get the areas
        #of the rectangle enclosing all the data points at this angle. Take
        #The angle with the minimum area for the enclosing rectangle.
        if rotation_angle is None:
            thetas=np.radians(np.arange(90, dtype=np.float))
            areas=[]
            corners=[]
            for th in thetas:
                x2, y2= misc.rotate_coords(x1, y1, th)
                #Don't take padding into account to determine the angle.
                x2min=x2.min()
                x2max=x2.max()
                y2min=y2.min()
                y2max=y2.max()
                areas.append((x2.max()-x2.min()) * (y2.max()-y2.min()))

            areas=np.asarray(areas)
            which_theta=np.where(areas==areas.min())[0][0]
            use_theta=thetas[which_theta]
        #Else, use the given angle
        else:
            use_theta=np.radians(rotation_angle)

        #Define the edges of the regions
        x2, y2= misc.rotate_coords(x1, y1, use_theta)
        x2min=x2.min() - pad_left
        x2max=x2.max() + pad_right
        y2min=y2.min() - pad_bottom
        y2max=y2.max() + pad_top

        #Figure out the x2 and y2 bin divisions
        if (x2max-x2min) < (y2max-y2min):
            nx=n_shortside
            ny=n_longside
        else:
            ny=n_shortside
            nx=n_longside

        x2edges = np.linspace(x2min, x2max, nx+1)
        y2edges = np.linspace(y2min, y2max, ny+1)

        #-----------------#
        #- Make the plot -#
        #-----------------#
        if preview or save_plot:
            #Figure out what subregions we have
            subregions=self.return_subregions(ra, dec, theta=use_theta,
                                              rot_xedges=x2edges,
                                              rot_yedges=y2edges)
            outside = subregions == -1
            inside= np.invert(outside)
            if only_show is not None:
                this_box = subregions==only_show
                inside = inside & this_box

            #Make a figure and plot the random points
            fig=plt.figure()
            ax=fig.add_subplot(111)
            ax.scatter(x1[outside], y1[outside], c='LightGray')
            ax.scatter(x1[inside], y1[inside], c='Blue')  
                      
            #Plot the vertical lines
            for ix in range(nx+1):
                x2=[x2edges[ix], x2edges[ix]]
                y2=[y2min, y2max]
                x1, y1=misc.rotate_coords(x2, y2, -use_theta)
                ax.plot(x1, y1, color='Red', lw=2)
            #Plot the horizontal lines
            for iy in range(ny+1):
                x2=[x2min, x2max]
                y2=[y2edges[iy], y2edges[iy]]
                x1, y1=misc.rotate_coords(x2, y2, -use_theta)
                ax.plot(x1, y1, color='Red', lw=2)

            #Figure out the dimensions of the boxes in angular space
            x2=[x2edges[0], x2edges[0], x2edges[1]]
            y2=[y2edges[0], y2edges[1], y2edges[0]]
            ra_box, dec_box=self.xy_to_ra_dec(x2, y2)
            y_side=misc.ang_sep(ra_box[0], dec_box[0], ra_box[1], dec_box[1],
                               radians_in=False, radians_out=False) * 3600
            x_side=misc.ang_sep(ra_box[0], dec_box[0], ra_box[2], dec_box[2],
                               radians_in=False, radians_out=False) * 3600

            #Print out the parameters
            ax.text(.05, .95, "theta= "+str(np.degrees(use_theta))[0:5],
                    transform=ax.transAxes, fontsize=8)
            ax.text(.05, .925, "padding="+str(padding),
                    transform=ax.transAxes, fontsize=8)
            ax.text(.05, .9, "n_longside="+str(n_longside),
                    transform=ax.transAxes, fontsize=8)
            ax.text(.05, .875, "n_shortside="+str(n_shortside),
                    transform=ax.transAxes, fontsize=8)
            ax.text(.5, .05, ("box size: "+str(x_side)[0:5]+" by "+
                              str(y_side)[0:5]+" arcsec"),
                    transform=ax.transAxes, fontsize=8)

            #Label the subregions
            y_label_coord=.85
            avg_ngals=float(len(ra[np.invert(outside)]))/(nx*ny)
            ax.text(0.8, 0.95, "N_bin/N_avg", transform=ax.transAxes,
                    fontsize=12)
            ax.text(0.8, 0.9, "outside-> "+str(float(len(ra[outside]))/avg_ngals)[0:4],
                    transform=ax.transAxes, fontsize=9)
            for ix in range(nx):
                for iy in range(ny):
                    #What bin number is this?
                    bin_number= nx*iy + ix
                    #Where's the center of the box?
                    text_x2=(x2edges[ix] + x2edges[ix+1])/2.
                    text_y2=(y2edges[iy] + y2edges[iy+1])/2.
                    text_x1, text_y1=misc.rotate_coords(text_x2, text_y2,
                                                        -use_theta)
                    #Print the bin number at the center of the box
                    ax.text(text_x1, text_y1, str(bin_number), fontsize=20,
                            color='Lime', horizontalalignment='center',
                            verticalalignment='center')

                    #Print the number of galaxies in the upper right corner
                    thisbin= subregions==bin_number
                    n_thisbin= float(len(ra[thisbin]))
                    print ("bin "+str(bin_number)+" has "+str(n_thisbin)+
                           " randoms in it")
                    display_string=('bin '+str(bin_number)+'-> '+
                                    str(n_thisbin/avg_ngals)[0:4])
                    ax.text(0.85, y_label_coord, display_string,
                            transform=ax.transAxes, fontsize=9)
                    y_label_coord-=0.05

            if save_plot:
                plt.savefig(save_plot, bbox_inches='tight')
                plt.close()
            else:
                plt.show()

        #If we want to store the information, do so
        if not preview:
            #Store the subregion information
            self.set_subregions(use_theta, x2edges, y2edges)