def catsimSatellite(config, lon_centroid, lat_centroid, distance, stellar_mass, r_physical,
m_maglim_1, m_maglim_2, m_ebv,
plot=False, title='test'):
"""
Simulate a single satellite. This is currently only valid for band_1 = g and band_2 = r.
r_physical is azimuthally averaged half-light radius, kpc
"""
# Probably don't want to parse every time
completeness = getCompleteness(config)
log_photo_error = getPhotoError(config)
s = ugali.analysis.source.Source()
# Following McConnachie 2012, ellipticity = 1 - (b/a) , where a is semi-major axis and b is semi-minor axis
r_h = np.degrees(np.arcsin(r_physical / distance)) # Azimuthally averaged half-light radius
#ellipticity = 0.3 # Semi-arbitrary default for testing purposes
# See http://iopscience.iop.org/article/10.3847/1538-4357/833/2/167/pdf
# Based loosely on https://arxiv.org/abs/0805.2945
ellipticity = np.random.uniform(0.1, 0.8)
position_angle = np.random.uniform(0., 180.) # Random position angle (deg)
a_h = r_h / np.sqrt(1. - ellipticity) # semi-major axis (deg)
# Elliptical kernels take the "extension" as the semi-major axis
ker = ugali.analysis.kernel.EllipticalPlummer(lon=lon_centroid, lat=lat_centroid, ellipticity=ellipticity, position_angle=position_angle)
flag_too_extended = False
if a_h >= 1.0:
print 'Too extended: a_h = %.2f'%(a_h)
a_h = 1.0
flag_too_extended = True
ker.setp('extension', value=a_h, bounds=[0.0,1.0])
s.set_kernel(ker)
age = np.random.choice([10., 12.0, 13.5])
metal_z = np.random.choice([0.0001, 0.0002])
distance_modulus = ugali.utils.projector.distanceToDistanceModulus(distance)
iso = isochrone_factory('Bressan2012', survey=config['survey'], age=age, z=metal_z, distance_modulus=distance_modulus)
s.set_isochrone(iso)
# Simulate takes stellar mass as an argument, NOT richness
mag_1, mag_2 = s.isochrone.simulate(stellar_mass)
lon, lat = s.kernel.sample_lonlat(len(mag_2))
nside = healpy.npix2nside(len(m_maglim_1)) # Assuming that the two maglim maps have same resolution
pix = ugali.utils.healpix.angToPix(nside, lon, lat)
maglim_1 = m_maglim_1[pix]
maglim_2 = m_maglim_2[pix]
if config['survey'] == 'des':
# DES Y3 Gold fiducial
mag_extinction_1 = 3.186 * m_ebv[pix]
mag_extinction_2 = 2.140 * m_ebv[pix]
elif config['survey'] == 'ps1':
# From Table 6 in Schlafly 2011 with Rv = 3.1
# http://iopscience.iop.org/article/10.1088/0004-637X/737/2/103/pdf
mag_extinction_1 = 3.172 * m_ebv[pix]
mag_extinction_2 = 2.271 * m_ebv[pix]
# Photometric uncertainties are larger in the presence of interstellar dust reddening
mag_1_error = 0.01 + 10**(log_photo_error((mag_1 + mag_extinction_1) - maglim_1))
mag_2_error = 0.01 + 10**(log_photo_error((mag_2 + mag_extinction_2) - maglim_2))
# It would be better to convert to a flux uncertainty and then transform back to a magnitude
#mag_1_meas = mag_1 + np.random.normal(scale=mag_1_error)
#mag_2_meas = mag_2 + np.random.normal(scale=mag_2_error)
flux_1_meas = magToFlux(mag_1) + np.random.normal(scale=getFluxError(mag_1, mag_1_error))
mag_1_meas = np.where(flux_1_meas > 0., fluxToMag(flux_1_meas), 99.)
flux_2_meas = magToFlux(mag_2) + np.random.normal(scale=getFluxError(mag_2, mag_2_error))
mag_2_meas = np.where(flux_2_meas > 0., fluxToMag(flux_2_meas), 99.)
# In the HSC SXDS ultra-deep field:
# mean maglim_r_sof_gold_2.0 = 23.46
# median maglim_r_sof_gold_2.0 = 23.47
# m = healpy.read_map('/Users/keithbechtol/Documents/DES/projects/mw_substructure/des/y3a1/data/maps/y3a2_gold_1.0_cmv02-001_v1_nside4096_nest_r_depth.fits.gz')
# np.mean(m[ugali.utils.healpix.angToDisc(4096, 34.55, -4.83, 0.75)])
# np.median(m[ugali.utils.healpix.angToDisc(4096, 34.55, -4.83, 0.75)])
# Includes penalty for interstellar extinction and also include variations in depth
if config['survey'] == 'des':
cut_detect = (np.random.uniform(size=len(mag_2)) < completeness(mag_2 + mag_extinction_2 + (23.46 - np.clip(maglim_2, 20., 26.))))
elif config['survey'] == 'ps1':
cut_detect = (np.random.uniform(size=len(mag_2)) < completeness(mag_2 + mag_extinction_2))
n_g22 = np.sum(cut_detect & (mag_1 < 22.))
n_g24 = np.sum(cut_detect & (mag_1 < 24.))
print ' n_sim = %i, n_detect = %i, n_g24 = %i, n_g22 = %i'%(len(mag_1),np.sum(cut_detect),n_g24,n_g22)
richness = stellar_mass / s.isochrone.stellarMass()
#abs_mag = s.isochrone.absolute_magnitude()
#abs_mag_martin = s.isochrone.absolute_magnitude_martin(richness=richness, n_trials=10)[0] # 100 trials seems to be sufficient for rough estimate
#print 'abs_mag_martin = %.2f mag'%(abs_mag_martin)
# The more clever thing to do would be to sum up the actual simulated stars
if config['survey'] == 'des':
v = mag_1 - 0.487*(mag_1 - mag_2) - 0.0249 # See https://github.com/DarkEnergySurvey/ugali/blob/master/ugali/isochrone/model.py
elif config['survey'] == 'ps1':
# https://arxiv.org/pdf/1706.06147.pdf
# V - g = C_0 + C_1 * (g - r)
C_0 = -0.017
C_1 = -0.508
v = mag_1 + C_0 + C_1 * (mag_1 - mag_2)
flux = np.sum(10**(-v/2.5))
abs_mag = -2.5*np.log10(flux) - distance_modulus
#print abs_mag, abs_mag_martin
#distance = ugali.utils.projector.distanceModulusToDistance(distance_modulus)
#r_h = extension * np.sqrt(1. - ellipticity) # Azimuthally averaged half-light radius
r_physical = distance * np.tan(np.radians(r_h)) # Azimuthally averaged half-light radius, kpc
#print 'distance = %.3f kpc'%(distance)
#print 'r_physical = %.3f kpc'%(r_physical)
surface_brightness = ugali.analysis.results.surfaceBrightness(abs_mag, r_physical, distance) # Average within azimuthally averaged half-light radius
#print 'surface_brightness = %.3f mag arcsec^-2'%(surface_brightness)
if plot:
import pylab
pylab.ion()
n_sigma_p = np.sum(cut_detect & (mag_1 < 23.))
pylab.figure(figsize=(6., 6.))
pylab.scatter(mag_1_meas[cut_detect] - mag_2_meas[cut_detect], mag_1_meas[cut_detect], edgecolor='none', c='black', s=5)
pylab.xlim(-0.5, 1.)
pylab.ylim(26., 16.)
pylab.xlabel('g - r')
pylab.ylabel('g')
pylab.title('Number of stars with g < 23: %i'%(n_sigma_p))
pylab.savefig('y3_sat_sim_cmd_%s.png'%(title), dpi=150.)
print 'n_Sigma_p = %i'%(n_sigma_p)
raw_input('WAIT')
#if flag_too_extended:
# # This is a kludge to remove these satellites. fragile!!
# n_g24 = 1.e6
return lon[cut_detect], lat[cut_detect], mag_1_meas[cut_detect], mag_2_meas[cut_detect], mag_1_error[cut_detect], mag_2_error[cut_detect], mag_extinction_1[cut_detect], mag_extinction_2[cut_detect], n_g22, n_g24, abs_mag, surface_brightness, ellipticity, position_angle, age, metal_z, flag_too_extended
def analysis(ra, dec, mod, mc_source_id):
"""Analyze a candidate"""
pix_nside_select = ugali.utils.healpix.angToPix(nside, ra, dec)
ra_select, dec_select = ugali.utils.healpix.pixToAng(
nside, pix_nside_select)
pix_nside_neighbors = np.concatenate([[pix_nside_select],
healpy.get_all_neighbours(
nside, pix_nside_select)])
# Construct data
#data = simple.simple_utils.construct_modal_data(mode, pix_nside_neighbors)
data = simple.simple_utils.construct_real_data(pix_nside_neighbors)
if (mode == 0):
print('mode = 0: running only on real data')
elif (mode == 1):
print('mode = 1: running on real data and simulated data')
# inject objects for simulated object of mc_source_id
sim_data = simple.simple_utils.construct_sim_data(
pix_nside_neighbors, mc_source_id)
data = simple.simple_utils.inject_sim(data, sim_data, mc_source_id)
else:
print('No mode specified; running only on real data')
print('Loading data...')
data = simple.simple_utils.construct_modal_data(mode, pix_nside_neighbors,
mc_source_id)
quality_cut = simple.filters.quality_filter(survey, data)
data = data[quality_cut]
print('Found {} objects...').format(len(data))
data = simple.filters.dered_mag(survey, data)
# This should be generalized to also take the survey
iso = isochrone_factory(name=isoname,
survey=isosurvey,
age=12,
z=0.0001,
distance_modulus=mod,
band_1=band_1.lower(),
band_2=band_2.lower())
# g_radius estimate
filter = simple.filters.star_filter(survey, data)
iso_filter = simple.simple_utils.cut_isochrone_path(data[mag_dered_1],
data[mag_dered_2],
data[mag_err_1],
data[mag_err_2],
iso,
radius=0.1,
return_all=False)
angsep = ugali.utils.projector.angsep(ra, dec, data[basis_1],
data[basis_2])
bins = np.linspace(0, 0.4, 21) # deg
centers = 0.5 * (bins[1:] + bins[0:-1])
area = np.pi * (bins[1:]**2 - bins[0:-1]**2) * 60**2
hist = np.histogram(angsep[(angsep < 0.4) & filter & iso_filter],
bins=bins)[0] # counts
f_interp = interpolate.interp1d(
np.linspace(centers[0], centers[-1], len(hist)), hist / area, 'cubic')
f_range = np.linspace(centers[0], centers[-1], 1000)
f_val = f_interp(f_range)
pairs = zip(f_range, f_val)
peak = max(pairs[:len(pairs) / 4],
key=lambda x: x[1]) # find peak within first quarter
def peak_index(pairs, peak):
for i in range(len(pairs)):
if pairs[i] == peak:
return i
osc = int(
0.04 / 0.4 *
1000) # +/- 0.04 (rounded down) deg oscillation about local extremum
relmin = argrelextrema(f_val, np.less, order=osc)[0]
try:
if len(relmin) > 0:
#half_point = f_range[relmin[0]]
i = 0
while ((f_range[relmin[i]] <= f_range[peak_index(pairs, peak)]) &
(i <= len(relmin) - 1)):
i += 1
half_point = f_range[relmin[i]]
elif len(relmin) == 0:
half_peak = (
peak[1] + np.mean(f_val[len(f_val) / 4:])
) / 2. # normalized to background (after first quarter)
#half_peak = np.mean(f_val[len(f_val)/4:])
half_pairs = []
for i in pairs[peak_index(pairs, peak):len(pairs) /
2]: # start after peak, stay within first quarter
if i != peak:
half_pairs.append((i[0], abs(i[1] - half_peak)))
half_point = min(half_pairs, key=lambda x: x[1])[0] # deg
except:
half_point = 0.1 # fixed value to catch errors
g_min = 0.5 / 60. # deg
g_max = 12. / 60. # deg
if half_point < g_min:
g_radius = g_min
elif half_point > g_max:
g_radius = g_max
else:
g_radius = half_point # deg
angsep = ugali.utils.projector.angsep(ra, dec, data[basis_1],
data[basis_2])
nbhd = (angsep < g_radius)
return (data, iso, g_radius, nbhd)
def analysis(targ_ra, targ_dec, mod):
"""Analyze a candidate"""
#hdisc = healpix.ang2disc(nside, targ_ra, targ_dec, 1, inclusive=True)
#files = []
#for i in hdisc:
# if os.path.exists(datadir+'/cat_hpx_'+str(i).zfill(5)+'.fits'):
# files.append(datadir+'/cat_hpx_'+str(i).zfill(5)+'.fits')
#
##data = utils.load_infiles(files, columns=['RA', 'DEC', 'WAVG_MAG_PSF_G', 'WAVG_MAG_PSF_R', 'EXTINCTION_G', 'EXTINCTION_R', 'WAVG_SPREAD_MODEL_R', 'SPREADERR_MODEL_R', 'WAVG_MAGERR_PSF_G', 'WAVG_MAGERR_PSF_R', 'MAGERR_PSF_G', 'MAGERR_PSF_R'])
#data = utils.load_infiles(files, columns=COLUMNS)
pix_nside_select = ugali.utils.healpix.angToPix(nside, targ_ra, targ_dec)
ra_select, dec_select = ugali.utils.healpix.pixToAng(
nside, pix_nside_select)
pix_nside_neighbors = np.concatenate([[pix_nside_select],
healpy.get_all_neighbours(
nside, pix_nside_select)])
data_array = []
for pix_nside in pix_nside_neighbors:
#infile = '%s/cat_hpx_%05i.fits'%(datadir, pix_nside)
infile = '%s/y3a2_ngmix_cm_%05i.fits' % (datadir, pix_nside)
#infile = '%s/*_%05i.fits'%(datadir, pix_nside) # TODO: get to work
if not os.path.exists(infile):
continue
reader = pyfits.open(infile)
data_array.append(reader[1].data)
reader.close()
print('Assembling data...')
data = np.concatenate(data_array)
print('Found {} objects...').format(len(data))
print('Loading data...')
## De-redden magnitudes
#try:
# data = mlab.rec_append_fields(data, ['WAVG_MAG_PSF_DRED_G', 'WAVG_MAG_PSF_DRED_R'], [data[mag_g_dred_flag], data[mag_r_dred_flag]])
##except:
## data = mlab.rec_append_fields(data, ['WAVG_MAG_PSF_DRED_G', 'WAVG_MAG_PSF_DRED_R'], [data[mag_g_flag] - data[extinction_g_flag], data[mag_r_flag] - data[extinction_r_flag]])
#except:
# data = mlab.rec_append_fields(data, ['WAVG_MAG_PSF_DRED_G', 'WAVG_MAG_PSF_DRED_R'], [data[mag_g_flag], data[mag_r_flag]])
#
#mag_g = data['WAVG_MAG_PSF_DRED_G']
#mag_r = data['WAVG_MAG_PSF_DRED_R']
mag_g = data[mag_g_dred_flag]
mag_r = data[mag_r_dred_flag]
iso = isochrone_factory('Bressan2012',
age=12,
z=0.0001,
distance_modulus=mod)
# g_radius estimate
filter_s = star_filter(data)
mag_g = data[mag_g_dred_flag]
mag_r = data[mag_r_dred_flag]
iso_filter = (iso.separation(mag_g, mag_r) < 0.1)
angsep = ugali.utils.projector.angsep(targ_ra, targ_dec, data['RA'],
data['DEC'])
bins = np.linspace(0, 0.4, 21) # deg
centers = 0.5 * (bins[1:] + bins[0:-1])
area = np.pi * (bins[1:]**2 - bins[0:-1]**2) * 60**2
hist = np.histogram(angsep[(angsep < 0.4) & filter_s & iso_filter],
bins=bins)[0] # counts
f_interp = interpolate.interp1d(
np.linspace(centers[0], centers[-1], len(hist)), hist / area, 'cubic')
f_range = np.linspace(centers[0], centers[-1], 1000)
f_val = f_interp(f_range)
pairs = list(zip(f_range, f_val))
peak = max(pairs[:len(pairs) / 4],
key=lambda x: x[1]) # find peak within first quarter
def peak_index(pairs, peak):
for i in range(len(pairs)):
if pairs[i] == peak:
return i
osc = int(
0.04 / 0.4 *
1000) # +/- 0.04 (rounded down) deg oscillation about local extremum
relmin = argrelextrema(f_val, np.less, order=osc)[0]
try:
if len(relmin) > 0:
#half_point = f_range[relmin[0]] # TODO rename
i = 0
while ((f_range[relmin[i]] <= f_range[peak_index(pairs, peak)]) &
(i <= len(relmin) - 1)):
i += 1
half_point = f_range[relmin[i]]
elif len(relmin) == 0:
half_peak = (
peak[1] + np.mean(f_val[len(f_val) / 4:])
) / 2. # normalized to background (after first quarter)
#half_peak = np.mean(f_val[len(f_val)/4:])
half_pairs = []
for i in pairs[peak_index(pairs, peak):len(pairs) /
2]: # start after peak, stay within first quarter
if i != peak:
half_pairs.append((i[0], abs(i[1] - half_peak)))
half_point = min(half_pairs, key=lambda x: x[1])[0] # deg
except:
half_point = 0.1 # fixed value to catch errors
g_min = 0.5 / 60. # deg
g_max = 12. / 60. # deg
if half_point < g_min:
g_radius = g_min
elif half_point > g_max:
g_radius = g_max
else:
g_radius = half_point # deg
#c1 = SkyCoord(targ_ra, targ_dec, unit='deg') # frame is ICRS
#nbhd = c1.separation(SkyCoord(data['RA'], data['DEC'], unit='deg')).deg < g_radius # selects objects inside the galactic radius
angsep = ugali.utils.projector.angsep(targ_ra, targ_dec, data['RA'],
data['DEC'])
nbhd = (angsep < g_radius)
return (data, iso, g_radius, nbhd)
def catsimSatellite(config,
lon_centroid,
lat_centroid,
distance,
stellar_mass,
r_physical,
ellipticity,
position_angle,
age,
metal,
m_maglim_1,
m_maglim_2,
m_ebv,
plot=False,
title='test'):
""" Simulate a single satellite. This is currently only valid for
band_1 = g and band_2 = r. r_physical is azimuthally averaged
half-light radius, kpc
Parameters
----------
config : configuration
lon_centroid : longitude centroid (deg)
lat_centroid : latitude centroid (deg)
distance : distance (kpc)
stellar_mass : stellar mass (Msun)
r_physical : azimuthally averaged physical half-light radius (kpc)
ellipticity : ellipticity [0, 1]
position_angle : position angle (deg)
age : age (Gyr)
metal : metallicity
m_maglim_1 : mask of magnitude limit in band 2
m_maglim_2 : mask of magnitude limit in band 2
m_ebv : mask of E(B-V) values
plot : Plot the output [False]
Returns
-------
satellite : ordered dictionary of satellite star output
"""
# Probably don't want to parse every time
completeness = getCompleteness(config)
log_photo_error = getPhotoError(config)
s = ugali.analysis.source.Source()
# Azimuthally averaged projected half-light radius (deg)
r_h = np.degrees(np.arcsin(r_physical / distance))
# Elliptical half-light radius along semi-major axis (deg)
a_h = r_h / np.sqrt(1. - ellipticity)
# Create the kernel without extension
ker = ugali.analysis.kernel.EllipticalPlummer(
lon=lon_centroid,
lat=lat_centroid,
ellipticity=ellipticity,
position_angle=position_angle)
# Apply a max extension cut
flag_too_extended = False
max_extension = 5.0 # deg
if a_h >= max_extension:
print 'Too extended: a_h = %.2f' % (a_h)
a_h = max_extension
flag_too_extended = True
# Elliptical kernels take the "extension" as the semi-major axis
extension = a_h # Elliptical half-light radius
ker.setp('extension', value=a_h, bounds=[0.0, max_extension])
s.set_kernel(ker)
# Create the isochrone
distance_modulus = ugali.utils.projector.dist2mod(distance)
iso = isochrone_factory('Bressan2012',
survey=config['survey'],
age=age,
z=metal,
distance_modulus=distance_modulus)
s.set_isochrone(iso)
# Simulate takes stellar mass as an argument, NOT richness
mag_1, mag_2 = s.isochrone.simulate(stellar_mass)
# Generate the positions of stars
lon, lat = s.kernel.sample_lonlat(len(mag_2))
nside = hp.npix2nside(len(
m_maglim_1)) # Assuming that the two maglim maps have same resolution
pix = ugali.utils.healpix.ang2pix(nside, lon, lat)
maglim_1 = m_maglim_1[pix]
maglim_2 = m_maglim_2[pix]
if config['survey'] == 'des':
# DES Y3 Gold fiducial
mag_extinction_1 = 3.186 * m_ebv[pix]
mag_extinction_2 = 2.140 * m_ebv[pix]
elif config['survey'] == 'ps1':
# From Table 6 in Schlafly 2011 with Rv = 3.1
# http://iopscience.iop.org/article/10.1088/0004-637X/737/2/103/pdf
mag_extinction_1 = 3.172 * m_ebv[pix]
mag_extinction_2 = 2.271 * m_ebv[pix]
elif config['survey'] == 'lsst':
# From Table 6 in Schlafly 2011 with Rv = 3.1
# http://iopscience.iop.org/article/10.1088/0004-637X/737/2/103/pdf
mag_extinction_1 = 3.237 * m_ebv[pix]
mag_extinction_2 = 2.273 * m_ebv[pix]
# Photometric uncertainties are larger in the presence of interstellar dust reddening
mag_1_error = 0.01 + 10**(log_photo_error((mag_1 + mag_extinction_1) -
maglim_1))
mag_2_error = 0.01 + 10**(log_photo_error((mag_2 + mag_extinction_2) -
maglim_2))
# It would be better to convert to a flux uncertainty and then transform back to a magnitude
#mag_1_meas = mag_1 + np.random.normal(scale=mag_1_error)
#mag_2_meas = mag_2 + np.random.normal(scale=mag_2_error)
flux_1_meas = magToFlux(mag_1) + np.random.normal(
scale=getFluxError(mag_1, mag_1_error))
mag_1_meas = np.where(flux_1_meas > 0., fluxToMag(flux_1_meas), 99.)
flux_2_meas = magToFlux(mag_2) + np.random.normal(
scale=getFluxError(mag_2, mag_2_error))
mag_2_meas = np.where(flux_2_meas > 0., fluxToMag(flux_2_meas), 99.)
# In the HSC SXDS ultra-deep field:
# mean maglim_r_sof_gold_2.0 = 23.46
# median maglim_r_sof_gold_2.0 = 23.47
# m = healpy.read_map('/Users/keithbechtol/Documents/DES/projects/mw_substructure/des/y3a1/data/maps/y3a2_gold_1.0_cmv02-001_v1_nside4096_nest_r_depth.fits.gz')
# np.mean(m[ugali.utils.healpix.angToDisc(4096, 34.55, -4.83, 0.75)])
# np.median(m[ugali.utils.healpix.angToDisc(4096, 34.55, -4.83, 0.75)])
# Includes penalty for interstellar extinction and also include variations in depth
if config['survey'] == 'des':
cut_detect = (np.random.uniform(size=len(mag_2)) <
completeness(mag_2 + mag_extinction_2 +
(23.46 - np.clip(maglim_2, 20., 26.))))
elif config['survey'] == 'ps1':
cut_detect = (np.random.uniform(size=len(mag_2)) <
completeness(mag_2 + mag_extinction_2))
elif config['survey'] == 'lsst':
cut_detect = (np.random.uniform(size=len(mag_2)) <
completeness(mag_2 + mag_extinction_2 +
(25.0 - np.clip(maglim_2, 20., 26.)))
) # Using the psuedo mag depth of 25 for now
n_g22 = np.sum(cut_detect & (mag_1 < 22.))
n_g24 = np.sum(cut_detect & (mag_1 < 24.))
print(' n_sim = %i, n_detect = %i, n_g24 = %i, n_g22 = %i' %
(len(mag_1), np.sum(cut_detect), n_g24, n_g22))
richness = stellar_mass / s.isochrone.stellarMass()
#abs_mag = s.isochrone.absolute_magnitude()
#abs_mag_martin = s.isochrone.absolute_magnitude_martin(richness=richness, n_trials=10)[0] # 100 trials seems to be sufficient for rough estimate
#print 'abs_mag_martin = %.2f mag'%(abs_mag_martin)
# The more clever thing is to sum the simulated stars
if config['survey'] == 'des':
# See https://github.com/DarkEnergySurvey/ugali/blob/master/ugali/isochrone/model.py
v = mag_1 - 0.487 * (mag_1 - mag_2) - 0.0249
elif config['survey'] == 'ps1':
# https://arxiv.org/pdf/1706.06147.pdf
# V - g = C_0 + C_1 * (g - r)
C_0 = -0.017
C_1 = -0.508
v = mag_1 + C_0 + C_1 * (mag_1 - mag_2)
elif config['survey'] == 'lsst':
# Numbers are just placeholders for now, need to figure out exact ones
C_0 = -0.02
C_1 = -0.50
v = mag_1 + C_0 + C_1 * (mag_1 - mag_2)
flux = np.sum(10**(-v / 2.5))
abs_mag = -2.5 * np.log10(flux) - distance_modulus
# Realized surface brightness within azimuthally averaged half-light radius
surface_brightness = ugali.analysis.results.surfaceBrightness(
abs_mag, r_physical, distance)
if plot:
import pylab
pylab.ion()
n_sigma_p = np.sum(cut_detect & (mag_1 < 23.))
pylab.figure(figsize=(6., 6.))
pylab.scatter(mag_1_meas[cut_detect] - mag_2_meas[cut_detect],
mag_1_meas[cut_detect],
edgecolor='none',
c='black',
s=5)
pylab.xlim(-0.5, 1.)
pylab.ylim(26., 16.)
pylab.xlabel('g - r')
pylab.ylabel('g')
pylab.title('Number of stars with g < 23: %i' % (n_sigma_p))
pylab.savefig('y3_sat_sim_cmd_%s.png' % ('test'), dpi=150.)
print('n_Sigma_p = %i' % (n_sigma_p))
raw_input('WAIT')
satellite = odict(lon=lon[cut_detect],
lat=lat[cut_detect],
mag_1=mag_1_meas[cut_detect],
mag_2=mag_2_meas[cut_detect],
mag_1_error=mag_1_error[cut_detect],
mag_2_error=mag_2_error[cut_detect],
mag_extinction_1=mag_extinction_1[cut_detect],
mag_extinction_2=mag_extinction_2[cut_detect],
n_g22=n_g22,
n_g24=n_g24,
abs_mag=abs_mag,
surface_brightness=surface_brightness,
extension=extension,
flag_too_extended=flag_too_extended)
return satellite
# quality selection
quality_cut = quality_filter(survey, data)
data = data[quality_cut]
data = dered_mag(survey, data)
color = data[mag_dered_1] - data[mag_dered_2]
mag = data[mag_dered_1]
stars = star_filter(survey, data)
galaxies = galaxy_filter(survey, data)
iso = isochrone_factory(name='Bressan2012',
survey='des',
age=12.0,
z=0.0001,
distance_modulus=mod,
band_1='g',
band_2='r')
#iso_sep = iso.separation(data[mag_1], data[mag_2])
iso_filter = cut_isochrone_path(data[mag_dered_1],
data[mag_dered_2],
data[mag_err_1],
data[mag_err_2],
iso,
radius=0.1,
return_all=False)
# projection of image
proj = ugali.utils.projector.Projector(ra, dec)
x, y = proj.sphereToImage(data['RA'], data['DEC'])
