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
