def plot_Galactic_slice(Rmax, Zmax, component=None, log_scale=True):
# Determine density in slice
model = TGalacticModel()
R = np.abs(np.linspace(-Rmax*1000, Rmax*1000, 500))
Z = np.abs(np.linspace(-Zmax*1000, Zmax*1000, 500))
RR, ZZ = np.meshgrid(R, Z)
rho = model.rho_rz(RR.flatten(), ZZ.flatten(), component=component)
# Remove overdensity at center
idx = np.isfinite(rho)
rho[~idx] = np.max(rho[idx])
rho_sorted = rho.__copy__()
rho_sorted.sort()
rho_max = rho_sorted[int(0.95*(rho_sorted.size-1))]
idx = (rho > rho_max)
rho[idx] = rho_max
if log_scale:
rho = np.log(rho)
rho.shape = (R.size, Z.size)
# Set matplotlib options
mplib.rc('text',usetex=True)
mplib.rc('xtick.major', size=6)
mplib.rc('xtick.minor', size=4)
mplib.rc('axes', grid=True)
# Set up figure
fig = plt.figure(figsize=(12,7), dpi=100)
title = None
if log_scale:
title = r'$\mathrm{Stellar\ number\ density\ (arbitrary\ log\ scale)}$'
else:
r'$\mathrm{Stellar\ number\ density\ (arbitrary\ scale)}$'
fig.suptitle(title, fontsize=22, y=0.95)
ax = fig.add_subplot(1,1,1)
fig.subplots_adjust(top=0.88)
ax.imshow(rho, extent=(-Rmax, Rmax, -Zmax, Zmax), cmap='gray')
ax.set_xlabel(r'$R \, (\mathrm{kpc})$', fontsize=18)
ax.set_ylabel(r'$Z \, (\mathrm{kpc})$', fontsize=18)
ax.grid(which='major', alpha=0.2)
fig.savefig('../plots/log_rho.png', dpi=300)
plt.show()
def main():
parser = argparse.ArgumentParser(prog='gen_test_input.py',
description='Generates test input file for galstar.',
add_help=True)
parser.add_argument('-N', type=int, default=None, help='# of stars to generate.')
parser.add_argument('-rad', '--radius', type=float, default=None, help='Radius of beam.')
parser.add_argument('-o', '--output', type=str, default=None,
help='Output filename (creates Bayestar input file).')
parser.add_argument('-lb', '--gal-lb', type=float, nargs=2,
metavar='deg', default=(90., 10.),
help='Galactic latitude and longitude, in degrees.')
parser.add_argument('-EBV', '--mean-EBV', type=float, default=0.02,
metavar='mags', help='Mean E(B-V) extinction.')
parser.add_argument('--EBV-uniform', action='store_true',
help='Draw E(B-V) from U(0,2).')
parser.add_argument('-cl', '--clouds', type=float, nargs='+',
default=None, metavar='mu Delta_EBV',
help='Place clouds of reddening Delta_EBV at distances mu')
parser.add_argument('-r', '--max-r', type=float, default=23.,
metavar='mags', help='Limiting apparent r-band magnitude.')
parser.add_argument('-lim', '--limiting-mag', metavar='mags', type=float,
nargs=5, default=(22.4, 21.7, 21.7, 21.1, 20.1),
help='Limiting magnitudes in grizy_{P1}.')
parser.add_argument('-nb', '--n-bands', type=int, default=4,
help='# of bands required to keep object.')
parser.add_argument('-flat', '--flat', action='store_true',
help='Draw parameters from flat distribution')
parser.add_argument('-sh', '--show', action='store_true',
help='Plot distribution of DM, Mr and E(B-V).')
parser.add_argument('-err', '--scale-errors', type=float, default=1.,
help='Stretch uncertainties by given amount.')
parser.add_argument('-LF', '--luminosity-function', type=str, default=None,
help='Filename of luminosity function.')
parser.add_argument('-t', '--templates', type=str, default=None,
help='Filename of stellar templates.')
#parser.add_argument('-b', '--binary', action='store_true', help='Generate binary stars.')
if 'python' in sys.argv[0]:
offset = 2
else:
offset = 1
args = parser.parse_args(sys.argv[offset:])
# Parameters for Galactic and stellar models
LF_fname = args.luminosity_function
t_fname = args.templates
model_kwargs = {'fh':fh}
if LF_fname != None:
model_kwargs['LF_fname'] = LF_fname
# Determine number of stars to draw
redraw = False
N_stars = None
if args.N == None:
if args.radius == None:
print 'Either -N or -rad must be specified'
model = TGalacticModel(**model_kwargs)
N_stars = model.tot_num_stars(args.gal_lb[0], args.gal_lb[1], args.radius)
N_stars = np.random.poisson(lam=N_stars)
else:
if args.radius != None:
print 'Cannot specify both -N and -rad'
redraw = True
N_stars = args.N
EBV_of_mu = None
if args.clouds != None:
mu = np.linspace(-5., 35., 1000)
dmu = mu[1] - mu[0]
Delta_EBV = 0.01 * dmu * np.ones(mu.size)
for i in range(len(args.clouds)/2):
s = 0.05
m = args.clouds[2*i]
EBV = args.clouds[2*i+1]
Delta_EBV += EBV/np.sqrt(2.*np.pi)/s*np.exp(-(mu-m)*(mu-m)/2./s/s)
EBV = np.cumsum(Delta_EBV) * dmu
EBV_of_mu = InterpolatedUnivariateSpline(mu, EBV)
mu = np.linspace(4., 19., 1000)
EBV = EBV_of_mu(mu)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.plot(mu, EBV)
plt.show()
#print Ar
params = None
if args.flat:
pass
#params = draw_flat(values.N, EBV_spread=args.mean_EBV,
# r_max=values.max_r, EBV_of_mu=EBV_of_mu)
else:
params = draw_from_model(args.gal_lb[0], args.gal_lb[1],
N_stars, EBV_spread=args.mean_EBV,
mag_lim=args.limiting_mag, EBV_of_mu=EBV_of_mu,
EBV_uniform=args.EBV_uniform, redraw=redraw,
n_bands=args.n_bands, scale=args.scale_errors,
model_kwargs=model_kwargs, t_fname=t_fname)
print '%d stars observed' % (len(params))
#params['mag'][:,4] -= 0.05
# Write Bayestar input file
if args.output != None:
mag_lim = np.array(args.limiting_mag)
mag_lim.shape = (1, 5)
mag_lim = np.repeat(mag_lim, len(params), axis=0)
write_infile(args.output, params['mag'], params['err'], mag_lim,
l=args.gal_lb[0], b=args.gal_lb[1],
access_mode='w')
# Write true parameter values
write_true_params(args.output, params['DM'], params['EBV'],
params['Mr'], params['FeH'],
l=args.gal_lb[0], b=args.gal_lb[1])
header = '''# Format:
# l b
# DM E(B-V) Mr FeH
# DM E(B-V) Mr FeH
# DM E(B-V) Mr FeH
# ...'''
#print header
#print '%.3f %.3f' % (args.gal_lb[0], args.gal_lb[1])
#for p in params:
# print '%.3f %.3f %.3f %.3f' % (p['DM'], p['EBV'], p['Mr'], p['FeH']), p['mag'], p['err']
if args.show:
model = TGalacticModel(**model_kwargs)
l = np.pi/180. * args.gal_lb[0]
b = np.pi/180. * args.gal_lb[1]
cos_l, sin_l = np.cos(l), np.sin(l)
cos_b, sin_b = np.cos(b), np.sin(b)
dN_dDM = lambda mu: model.dn_dDM(mu, cos_l, sin_l, cos_b, sin_b)
mplib.rc('text', usetex=True)
fig = plt.figure(figsize=(6,4), dpi=300)
ax = fig.add_subplot(2,2,1)
ax.hist(params['DM'], bins=100, normed=True, alpha=0.3)
xlim = ax.get_xlim()
x = np.linspace(xlim[0], xlim[1], 1000)
ax.plot(x, dN_dDM(x)/quad(dN_dDM, 1., 25.)[0], 'g-', lw=1.3, alpha=0.5)
ax.set_xlim(xlim)
ax.set_xlabel(r'$\mu$', fontsize=14)
ax = fig.add_subplot(2,2,2)
ax.hist(params['Mr'], bins=100, normed=True, alpha=0.3)
xlim = ax.get_xlim()
x = np.linspace(model.Mr_min, model.Mr_max, 1000)
ax.plot(x, model.LF(x)/quad(model.LF, x[0], x[-1], full_output=1)[0],
'g-', lw=1.3, alpha=0.5)
ax.set_xlim(xlim)
ylim = ax.get_ylim()
ax.set_ylim(0., ylim[1])
ax.set_xlabel(r'$M_{r}$', fontsize=14)
ax = fig.add_subplot(2,2,3)
ax.hist(params['EBV'], bins=100, normed=True, alpha=0.3)
ax.set_xlabel(r'$\mathrm{E} \! \left( B \! - \! V \right)$', fontsize=14)
ax = fig.add_subplot(2,2,4)
ax.hist(params['FeH'], bins=100, normed=True, alpha=0.3)
xlim = ax.get_xlim()
x = np.linspace(xlim[0], xlim[1], 100)
y = model.p_FeH_los(x, cos_l, sin_l, cos_b, sin_b)
ax.plot(x, y, 'g-', lw=1.3, alpha=0.5)
ax.set_xlabel(r'$\left[ \mathrm{Fe} / \mathrm{H} \right]$', fontsize=14)
ax.set_xlim(xlim)
fig.subplots_adjust(hspace=0.40, wspace=0.25,
bottom=0.13, top=0.95,
left=0.1, right=0.9)
# CMD of stars
fig = plt.figure(figsize=(6,4), dpi=150)
ax = fig.add_subplot(1,1,1)
idx = ((params['err'][:,0] < 1.e9)
& (params['err'][:,1] < 1.e9)
& (params['err'][:,2] < 1.e9))
ax.hexbin(params['mag'][idx,0] - params['mag'][idx,2],
params['mag'][idx,1],
gridsize=100, bins='log')
ax.set_xlabel(r'$g - i$', fontsize=14)
ax.set_ylabel(r'$m_{r}$', fontsize=14)
ylim = ax.get_ylim()
ax.set_ylim(ylim[1], ylim[0])
plt.show()
return 0
def main():
parser = argparse.ArgumentParser(prog='plot_prior.py',
description='Plot galstar priors along a line of sight',
add_help=True)
parser.add_argument('RA',
type=str, help='Right Ascension (hh:mm:ss) or degrees')
parser.add_argument('DEC',
type=str, help='Declination (deg:mm:ss) or degrees')
parser.add_argument('Radius',
type=str,
nargs='?',
default="'1d'",
help='Radius (hh:mm:ss) or degrees')
parser.add_argument('--lb',
action='store_true',
help='Interpret RA and DEC as Galactic l and b, respectively')
parser.add_argument('--correct',
action='store_true',
help='Correct for Malmquist bias.')
#parser.add_argument('--density', action='store_true', help='Plot stellar number density rather than p(mu)')
parser.add_argument('--output',
type=str,
default=None,
help='Save output to file (default: open window with output)')
if sys.argv[0] == 'python':
offset = 2
else:
offset = 1
args = []
for arg in sys.argv[offset:]:
args.append(arg)
if '--' not in arg: args[-1] = "'%s'" % args[-1]
values = parser.parse_args(args)
# Get Galactic coordinates
if values.lb:
l = float(values.RA[1:-1])
b = float(values.DEC[1:-1])
else:
# Parse RA and DEC
RA = parse_dhms(values.RA[1:-1])
if RA == None: RA = parse_RA(values.RA[1:-1])
DEC = parse_dhms(values.DEC[1:-1])
if DEC == None: DEC = parse_DEC(values.DEC[1:-1])
l, b = equatorial2galactic(RA, DEC)
# Parse Radius
radius = parse_dhms(values.Radius[1:-1])
if radius == None: radius = float(values.Radius[1:-1])
radius = deg2rad(radius)
print '# Galactic Coordinates (l, b): %d %d' % (round(l) , round(b))
# Set up figure
mplib.rc('text',usetex=True)
mplib.rc('xtick.major', size=6)
mplib.rc('xtick.minor', size=4)
mplib.rc('axes', grid=True)
fig = plt.figure(figsize=(8.5, 11.))
fig.suptitle(r'$\mathrm{Priors \ for} \ ( \ell = %d^{\circ} , \, b = %d^{\circ} )$' % (round(l) , round(b)), fontsize=24, y=0.97)
ax = []
for i in range(2):
ax.append(fig.add_subplot(2, 1, i+1))
#fig.subplots_adjust(left=0.12, right=0.90, hspace=0.25)
fig.subplots_adjust(left=0.14, right=0.90, top=0.88, bottom=0.08, hspace=0.20)
# Intialize Galactic model
model = TGalacticModel(fh=0.0030)
model.L_epsilon = 500.
# Precompute trigonometric functions
l, b = deg2rad(l), deg2rad(b)
cos_l, sin_l, cos_b, sin_b = cos(l), sin(l), cos(b), sin(b)
# Determine total number of stars along line of sight
f_disk = lambda x: model.dn_dDM(x, cos_l, sin_l, cos_b, sin_b,
radius, component='disk',
correct=values.correct)
N_disk = quad(f_disk, 0.01, 20., epsrel=1.e-5)[0]
print '# of stars in disk: %d' % int(N_disk)
f_halo = lambda x: model.dn_dDM(x, cos_l, sin_l, cos_b, sin_b,
radius, component='halo',
correct=values.correct)
N_halo = quad(f_halo, 0.01, 40., epsrel=1.e-5)[0]
print '# of stars in halo: %d' % int(N_halo)
f_bulge = lambda x: model.dn_dDM(x, cos_l, sin_l, cos_b, sin_b,
radius, component='bulge',
correct=values.correct)
N_bulge = quad(f_bulge, 0.01, 40., epsrel=1.e-5)[0]
print '# of stars in bulge: %d' % int(N_bulge)
# Calculate dn/dDM and rho
DM_range = np.linspace(4., 20., 500)
dn_dDM_disk, dn_dDM_halo, dn_dDM_bulge = [np.empty(500, dtype='f8') for i in xrange(3)]
rho_disk, rho_halo, rho_bulge = [np.empty(500, dtype='f8') for i in xrange(3)]
for i,DM in enumerate(DM_range):
rho_halo[i] = model.rho(DM, cos_l, sin_l, cos_b, sin_b, component='halo')
rho_disk[i] = model.rho(DM, cos_l, sin_l, cos_b, sin_b, component='disk')
rho_bulge[i] = model.rho(DM, cos_l, sin_l, cos_b, sin_b, component='bulge')
dn_dDM_halo[i] = 1./(N_halo+N_disk+N_bulge) * model.dn_dDM(DM,
cos_l, sin_l,
cos_b, sin_b,
radius, component='halo',
correct=values.correct)
dn_dDM_disk[i] = 1./(N_halo+N_disk+N_bulge) * model.dn_dDM(DM,
cos_l, sin_l,
cos_b, sin_b,
radius, component='disk',
correct=values.correct)
dn_dDM_bulge[i] = 1./(N_halo+N_disk+N_bulge) * model.dn_dDM(DM,
cos_l, sin_l,
cos_b, sin_b,
radius, component='bulge',
correct=values.correct)
rho_bulge[~np.isfinite(rho_bulge)] = 0.
dn_dDM_bulge[~np.isfinite(dn_dDM_bulge)] = 0.
print np.sum(dn_dDM_bulge)
rho = rho_disk + rho_halo + rho_bulge
dn_dDM = dn_dDM_halo + dn_dDM_disk + dn_dDM_bulge
# Plot dn/dDM
y_min = min(dn_dDM_disk.min(), dn_dDM_halo.min())
ax[0].fill_between(DM_range, y_min, dn_dDM, alpha=0.4, facecolor='k', label='__nolabel__')
ax[0].fill_between(DM_range, y_min, dn_dDM_disk, alpha=0.4, facecolor='g')
rect = Rectangle((0,0), 0, 0, facecolor='g', label=r'$\mathrm{disk}$', alpha=0.6)
ax[0].add_patch(rect)
ax[0].fill_between(DM_range, y_min, dn_dDM_halo, alpha=0.4, facecolor='b')
rect = Rectangle((0,0), 0, 0, facecolor='b', label=r'$\mathrm{halo}$', alpha=0.6)
ax[0].add_patch(rect)
ax[0].fill_between(DM_range, y_min, dn_dDM_bulge, alpha=0.4, facecolor='r')
rect = Rectangle((0,0), 0, 0, facecolor='r', label=r'$\mathrm{bulge}$', alpha=0.6)
ax[0].add_patch(rect)
ax[0].set_title(r'$\mathrm{Probability}$', fontsize=20)
ax[0].set_xlabel(r'$\mu$', fontsize=20)
ax[0].set_ylabel(r'$p(\mu)$', fontsize=18)
ax[0].yaxis.set_major_locator(MaxNLocator(nbins=5))
ax[0].yaxis.set_minor_locator(MaxNLocator(nbins=20))
y_max = ax[0].get_ylim()[1]
ax[0].set_ylim(0., y_max)
ax[0].legend(loc='upper left')
ax[0].get_legend().get_frame().set_alpha(0.)
# Plot rho
y_min = min(dn_dDM_disk.min(), dn_dDM_halo.min())
ax[1].fill_between(DM_range, y_min, rho, alpha=0.4, facecolor='k')
ax[1].fill_between(DM_range, y_min, rho_disk, alpha=0.4, facecolor='g')
ax[1].fill_between(DM_range, y_min, rho_halo, alpha=0.4, facecolor='b')
ax[1].fill_between(DM_range, y_min, rho_bulge, alpha=0.4, facecolor='r')
ax[1].set_title(r'$\mathrm{Density}$', fontsize=20)
ax[1].set_xlabel(r'$\mu$', fontsize=20)
ax[1].set_ylabel(r'$n (\mu)$', fontsize=18)
ax[1].set_yscale('log')
y_min = max(dn_dDM_disk.min(), dn_dDM_halo.min())
y_max = ax[1].get_ylim()[1]
ax[1].set_ylim(y_min, y_max)
'''
# dn/dFeH
FeH_range = np.linspace(-2.5, 0.5, 100)
p_FeH_range = np.empty(100, dtype=float)
for i,FeH in enumerate(FeH_range):
p_FeH_range[i] = model.p_FeH_los(FeH, cos_l, sin_l, cos_b, sin_b, DM_max=20.)
func = lambda x: model.p_FeH_los(x, cos_l, sin_l, cos_b, sin_b, DM_max=20.)
norm = quad(func, -2.5, 0.5, epsrel=1.e-3)[0]
for i in range(len(FeH_range)): FeH_range[i] /= norm
ax[1].fill_between(FeH_range, 0, p_FeH_range, alpha=0.8)
ax[1].set_xlabel(r'$[Fe/H]$', fontsize=17)
ax[1].set_ylabel(r'$p([Fe/H])$', fontsize=16)
y_max = ax[1].get_ylim()[1]
ax[1].set_ylim(0., y_max)
ax[1].set_xlim(-2.5, 0.5)
ax[1].xaxis.set_major_locator(MaxNLocator(nbins=4, prune='lower'))
ax[1].xaxis.set_minor_locator(MaxNLocator(nbins=20))
'''
for ax_i in ax:
ax_i.set_xlim(4., 20.)
ax_i.xaxis.set_major_locator(MultipleLocator(4.))
ax_i.xaxis.set_minor_locator(MultipleLocator(1.))
#for tick in ax_i.xaxis.get_major_ticks() + ax_i.xaxis.get_minor_ticks() + ax_i.yaxis.get_major_ticks() + ax_i.yaxis.get_minor_ticks():
# tick.tick2On = False
ax_i.grid(which='minor', alpha=0.3)
if values.output == None:
plt.show()
else:
fn = values.output[1:-1]
if '.' not in fn: fn += '.png'
fig.savefig(fn, dpi=300)
return 0
def draw_from_model(l, b, N, EBV_spread=0.02,
mag_lim=(23., 22., 22., 21., 20.),
EBV_of_mu=None, EBV_uniform=False,
redraw=True, n_bands=4,
scale=1., model_kwargs={}, t_fname=None):
dtype = [('DM', 'f8'), ('EBV', 'f8'),
('Mr', 'f8'), ('FeH', 'f8'),
('mag', '5f8'), ('err', '5f8')]
ret = np.empty(N, dtype=dtype)
l = np.pi/180. * l
b = np.pi/180. * b
cos_l, sin_l = np.cos(l), np.sin(l)
cos_b, sin_b = np.cos(b), np.sin(b)
gal_model = TGalacticModel(**model_kwargs)
if t_fname == None:
t_fname = os.path.expanduser('~/projects/bayestar/data/PScolors.dat')
stellar_model = TStellarModel(t_fname)
R = np.array([3.172, 2.271, 1.682, 1.322, 1.087])
mu_max = mag_lim[1] - gal_model.Mr_min + 3.
mu_min = min(0., mu_max-25.)
Mr_max = min(mag_lim[1]+3., gal_model.Mr_max)
dN_dDM = lambda mu: gal_model.dn_dDM(mu, cos_l, sin_l, cos_b, sin_b)
# Set up 1D samplers
draw_mu = TSample1D(dN_dDM, mu_min, mu_max, 500, 10000)
draw_Mr = TSample1D(gal_model.LF, gal_model.Mr_min, Mr_max, 10000, 1)
idx = np.arange(N)
keep_sampling = True
while keep_sampling:
size = idx.size
print 'Drawing %d...' % size
# Draw DM and Mr
ret['DM'][idx] = draw_mu(size)
ret['Mr'][idx] = draw_Mr(size)
# Draw EBV
ret['EBV'][idx] = 0.
if EBV_uniform:
ret['EBV'][idx] += 2. * np.random.random(size=idx.size)
else:
if EBV_of_mu != None:
ret['EBV'][idx] += EBV_of_mu(ret['DM'][idx]) #+ np.random.normal(scale=EBV_spread, size=size)
ret['EBV'][idx] += EBV_spread * np.random.chisquare(1., size)
x, y, z = gal_model.Cartesian_coords(ret['DM'][idx], cos_l,
sin_l, cos_b, sin_b)
# Determine which component stars belong to
f_halo, f_bulge = gal_model.f_halo_bulge(ret['DM'][idx], cos_l,
sin_l, cos_b, sin_b)
tmp_rand = np.random.random(size)
halo = (tmp_rand < f_halo)
bulge = (tmp_rand < f_halo + f_bulge)
bulge &= ~halo
thin = ~halo & ~bulge & (np.random.random(size) < 0.63)
thick = ~halo & ~bulge & ~thin
print ' # of bulge stars: %d' % (np.sum(bulge))
# Assign metallicities to halo stars
while np.any(halo):
ret['FeH'][idx[halo]] = np.random.normal(-1.46, 0.3, size=np.sum(halo))
halo &= (ret['FeH'][idx] <= -3.0) | (ret['FeH'][idx] >= 0.5)
# Assign metallicities to thin-disk stars
while np.any(thin):
ret['FeH'][idx[thin]] = np.random.normal(gal_model.mu_FeH_D(z[thin])-0.067,
0.2, size=np.sum(thin))
thin &= (ret['FeH'][idx] <= -3.0) | (ret['FeH'][idx] >= 0.5)
# Assign metallicities to thick-disk stars
while np.any(thick):
ret['FeH'][idx[thick]] = np.random.normal(gal_model.mu_FeH_D(z[thick])-0.067+0.14,
0.2, size=np.sum(thick))
thick &= (ret['FeH'][idx] <= -3.0) | (ret['FeH'][idx] >= 0.5)
# Assign metallicities to bulge stars
while np.any(bulge):
ret['FeH'][idx[bulge]] = np.random.normal(0., 0.40, size=np.sum(bulge))
bulge &= (ret['FeH'][idx] <= -3.0) | (ret['FeH'][idx] >= 0.5)
# Calculate absolute stellar magnitudes
absmags_tmp = stellar_model.absmags(ret['Mr'][idx], ret['FeH'][idx])
ret['mag'][idx,0] = absmags_tmp['g']
ret['mag'][idx,1] = absmags_tmp['r']
ret['mag'][idx,2] = absmags_tmp['i']
ret['mag'][idx,3] = absmags_tmp['z']
ret['mag'][idx,4] = absmags_tmp['y']
# Determine errors and apparent magnitudes
for k in xrange(5):
ret['mag'][idx,k] += ret['DM'][idx]
ret['mag'][idx,k] += ret['EBV'][idx] * R[k]
ret['err'][idx,k] = err_model(ret['mag'][idx][:,k], mag_lim[k], scale=scale)
#0.02 + 0.3 * np.exp(ret['mag'][idx][:,k] - mag_lim[k])
#idx_tmp = ret['err'][idx,k] > 1.
#ret['err'][idx[idx_tmp],k] = 1.
# Calculate observation probability
p_obs = np.empty((size, 5), dtype='f8')
for k in xrange(5):
p_obs[:,k] = 1. / (1. + np.exp( (ret['mag'][idx,k] - mag_lim[k] - 0.16) / 0.20 ))
#p_obs[:,k] = 0.5 - 0.5 * erf((ret['mag'][idx,k] - mag_lim[k] + 0.1) / 0.25)
# Determine which bands stars are observed in
obs = (p_obs > np.random.random(size=(size, 5)))
# Add in errors to apparent stellar magnitudes
ret['mag'][idx] += ret['err'][idx] * np.random.normal(size=(size,5))
# Re-estimate errors based on magnitudes
for k in xrange(5):
ret['err'][idx,k] = err_model(ret['mag'][idx,k], mag_lim[k], scale=scale)
# Remove observations with errors above 0.2 mags
obs = obs & (ret['err'][idx] < 0.2)
for k in xrange(5):
ret['mag'][idx[~obs[:,k]],k] = 0.
ret['err'][idx[~obs[:,k]],k] = 1.e10
# Require detection in g and at least n_bands-1 other bands
obs = obs[:,0] & (np.sum(obs, axis=1) >= n_bands)
#obs = (np.sum(obs, axis=1) >= n_bands)
idx = idx[~obs]
if redraw:
if idx.size == 0:
keep_sampling = False
else:
keep_sampling = False
ret = ret[obs]
#np.set_printoptions(formatter={'float':lambda x: '%.3f' % x})
#print ret['err']
#print np.sum(ret['mag'] < 1.)
fig = plt.figure()
for n in xrange(5):
# Mag histogram
ax = fig.add_subplot(5,2,1+2*n)
idx = ret['err'][:, n] < 1.e9
ax.hist(ret['mag'][idx, n], bins=100)
m = np.linspace(10., mag_lim[n] + 0.5, 1000)
err_curve = err_model(m, mag_lim[n], scale=scale)
ylim = ax.get_ylim()
err_curve *= 0.9 * ylim[1] / np.max(err_curve)
ax.plot(m, err_curve)
ax.set_xlim(10., 25.)
# Error histogram
ax = fig.add_subplot(5,2,2+2*n)
ax.hist(ret['err'][idx, n], bins=100)
ax.set_xlim(0., 0.2)
plt.show()
return ret
