def unmasked_random_sample(self, number_to_make, ra_range, dec_range): """ Generates a given number of randomly placed points in a specified RA and Dec range. This is really just an intermediary for a call to correlations.uniform_sphere(RAlim, DEClim, size=1). This routine does not allow for the RA and Dec ranges to be completely outside the mask. If you want that, go to the function in correlations. Parameters ---------- number_to_make : scalar The number of random objects to place in the RA and Dec range ra_range : array-like Randoms will be placed between ra_range[0] and ra_range[1]. Units are degrees. dec_range : array-like Randoms will be placed between dec_range[0] and dec_range[1]. Units are degrees. Returns ------- ra : numpy ndarray RA coords of the randomly placed objects. Array shape is (number_to_make,) dec : numpy ndarray Dec coords of the randomly placed objects. Array shape is (number_to_make,) """ #Check that we have an integer number of objects if int(number_to_make) != number_to_make: raise ValueError("You must give me an integer number of " "objects. You entered "+str(number_to_make)) #Check that we'll have at least some points in the mask ra_range_high = ra_range[0] >= self._ra_range[1] print ra_range_high ra_range_low = ra_range[1] <= self._ra_range[0] print ra_range_low bad_ra = ra_range_high | ra_range_low print bad_ra dec_range_high = dec_range[0] >= self._dec_range[1] print dec_range_high dec_range_low = dec_range[1] <= self._dec_range[0] print dec_range_low bad_dec = dec_range_high | dec_range_low print bad_dec if bad_ra or bad_dec: raise ValueError("You have given me a range that doesn't " "overlap with the RA and Dec range of the " "mask. Please correct that or use the " "correlations.uniform_sphere function.") #Return the call to uniform_sphere return corr.uniform_sphere(ra_range, dec_range, size=number_to_make)
def generate_random_sample(self, number_to_make): """ Generate a given number of random points within the mask. Parameters ---------- number_to_make : scalar Number of randomly placed objects within the mask area returned. Returns ------- ra : numpy ndarray The RAs of the randomly placed objects within the mask. Unit is degrees. The array shape is (number_to_make,) dec : numpy ndarray The Decs of the randomly placed objects within the mask. Unit is degrees. The array shape is (number_to_make,) """ #Check that we have an integer number of objects if int(number_to_make) != number_to_make: raise ValueError("You must give me an integer number of " "objects. You entered "+str(number_to_make)) #Make the first pass of randoms ra_R, dec_R= corr.uniform_sphere(self._ra_range, self._dec_range, size=number_to_make) #---------------------------------- #- Mask and add more if undershot #---------------------------------- #Get completenesses and see which to use random_completeness = self.return_completenesses(ra_R, dec_R) compare_to = rand.random(size=len(ra_R)) use = compare_to < random_completeness #Mask down to the ones that survived ra_R = ra_R[use] dec_R = dec_R[use] compare_to = compare_to[use] random_completeness = random_completeness[use] #How many do we have? number_we_have = len(ra_R) print ("ImageMask.generate_random_sample says: " " We made "+str(number_we_have)) print " We need ", number_to_make, " total" #Check to see by how many we've overshot number_left_to_make = number_to_make - number_we_have #If we've actually made too few, make more if number_left_to_make > 0: print ("ImageMask.generate_random_sample says: I have " "made too few objects within the target area. Making " "more.") #Figure out what fraction of the guys that we made were used #so if my mask is teeny and in a big field, it won't take #forever to get to where we want to be fraction_used_last_time = float(number_we_have)/number_to_make if fraction_used_last_time < 1.e-3: fraction_used_last_time = 1e-3 #Ask for exactly how many more we need. # new_multiplier = 1. / fraction_used_last_time # ask_for = np.ceil(number_left_to_make * new_multiplier) ask_for = number_left_to_make newguys = self.generate_random_sample(ask_for) #Unpack more_ras, more_decs, more_comps = newguys #Add these galaxies to the existing arrays ra_R= np.concatenate((ra_R, more_ras)) dec_R= np.concatenate((dec_R, more_decs)) random_completeness = np.concatenate((random_completeness, more_comps)) number_we_have = len(ra_R) number_left_to_make = number_to_make - number_we_have if number_left_to_make > 0: raise RuntimeError("Cathy screwed up something major this " "time. We didn't make the right number" " after falling short and calling " "generate_randoms again.") #If we overshot, cut some off if number_left_to_make < 0: print ("ImageMask.generate_random_sample says: " "Cutting down to exactly as many objects as we need.") ra_R=ra_R[0:number_to_make] dec_R=dec_R[0:number_to_make] random_completeness= random_completeness[0:number_to_make] else: print ("ImageMask.generate_random_sample says: " "I made exactly the right number! It's like winning " "the lottery but not actually fun...") #Return things! return ra_R, dec_R, random_completeness