def get_mean_z(ddz,vector,base):
n_ele = len(base)-1
values = N.zeros(n_ele)
base2 = base[:-1]+((base[1]-base[0])/2.)
for ii in range(n_ele):
good = N.greater_equal(vector,base[ii])
good *= N.less_equal(vector,base[ii+1])
values[ii] = U.mean_robust(ddz[good])
return values,base2
def get_seeing_from_data_pro(fwhm, mr):
"""
:param fwhm:
:param mr:
:return:
"""
dm = 0.1
base = N.arange(0., 7, dm)
stars = N.greater_equal(mr, 14) * N.less_equal(mr, 18)
b1, b2 = N.histogram(fwhm[stars], base)
pos = N.argmax(b1)
seeing = b2[pos] + (dm / 2.)
redu = N.less_equal(
fwhm,
U.mean_robust(fwhm[stars]) + U.std_mad(fwhm[stars]) * 2.)
redu *= N.greater_equal(
fwhm,
U.mean_robust(fwhm[stars]) - U.std_mad(fwhm[stars]) * 2.)
redu *= N.greater_equal(mr, 14) * N.less_equal(mr, 18)
return seeing, redu
def runZPcal_catalogue(reference, frame, final):
"""
----
filter_ref_cat,alig_frame_cat,alig_cal_frame_cat
"""
plots = 1
data2 = C.loaddata(frame) # Loading the whole catalog2 content.
head2 = C.loadheader(frame) # Loading the original header2.
pos_mags = 12 # ([12,20,21,22])
mag_r = U.get_data(reference, 12)
mag_f = U.get_data(frame, 12)
# good_sample = U.greater_equal(mag_r,16.) * U.less_equal(mag_r,21.5)
good_sample = U.greater_equal(mag_r, 16.) * U.less_equal(mag_r, 19.)
mag_r2, mag_f2 = U.multicompress(good_sample, (mag_r, mag_f))
offset = U.mean_robust(mag_f2 - mag_r2)
if plots:
plt.figure(11, figsize=(12, 9), dpi=80, facecolor='w', edgecolor='k')
plt.clf()
plt.plot(mag_r, (mag_f - mag_r - offset), 'ko', ms=10, alpha=0.1)
plt.xlim(16, 25)
plt.ylim(-5, 5.)
plt.xlabel('AB', size=25)
plt.ylabel('Mf-Mr', size=25)
plt.xticks(fontsize=25)
plt.yticks(fontsize=25)
plt.legend(['Offset: %.4f' % (offset)], loc='upper right', numpoints=1)
plt.title(A.getfilename(frame), size=15)
plt.grid()
figurename = final[:-3] + 'png'
print 'figurename: ', figurename
plt.savefig(figurename, dpi=100)
plt.close()
# Here it saves the offset in an ASCII file
fileout = open(final[:-3] + 'txt', 'w')
linea = '%s %.5f \n' % (final, offset)
fileout.write(linea)
fileout.close()
# The offset is only applied to m!=99. magnitudes.
new_mags = U.where(abs(mag_f) < 99, mag_f - offset, mag_f)
data2[:, pos_mags] = new_mags
C.savedata(data2, final, dir="", header=head2)
print ' '
def check_rms_SPLUS(segmentation,photometry,minrad,maxrad,totnum,plots,verbose):
"""
It describes the photometric noise in images by launching apertures
in blank areas and describing the area vs rms dependency.
Philosophy:
Several apertures (of random radius and positions) will be created (over blank areas) on
a 'segmentation' image to estimate the real photometric error of an input 'photometry' image.
--------
segmentation: Segmentation-like image (SExtractor output) used to select 'blank' areas.
photometry: scientific image over which estimate the real photometric errors
minrad,maxrad = minimun & maximum radius of the used apertures (pixels).
totnum = total number of apertures.
area,rms = final outputs.
---------
USAGE:
---------
import script_dcluster_tools as to
segmentation = 'f814.seg.fits'
photometry = 'f814.fits'
apertures,finalbackg,finalmeans,fluxes = to.check_rms_JPLUS(segmentation,photometry,1,21,5.0e+04,'yes',False)
----
"""
if not os.path.exists(segmentation):
print
print 'Image %s does not exist!' %(segmentation)
sys.exist()
if not os.path.exists(photometry):
print
print 'Image %s does not exist!' %(photometry)
sys.exist()
if verbose==True: verba=1
else: verba=0
# Reading data from images
if photometry[:-2]=='fz':
photima = fits.open(photometry)[1].data
else:
photima = fits.open(photometry)[0].data
if segmentation[:-2]=='fz':
segima = fits.open(segmentation)[1].data
else:
segima = fits.open(segmentation)[0].data
# Final root where to save the data
final_path = os.path.os.path.dirname(photometry)
base_name = os.path.os.path.basename(photometry)
len_extension = len(base_name.split('.')[-1])+1
file_root = final_path+'/Apertures/%s'%(base_name[:-len_extension])
# Physical limits (pixel) for the segmentation image.
xGC = N.shape(segima)[1]/2.
yGC = N.shape(segima)[0]/2.
# For CLASH, due to the rotating frames, a maximum radius is set.
min_maxim_radius = min([xGC,yGC])
radialmax = min_maxim_radius # Maximum radial distance to the center [pixels]
# Here the random position (X,Y) are limited in range.
minpix_X = 1500
maxpix_X = N.shape(segima)[1]-1500
minpix_Y = 1500
maxpix_Y = N.shape(segima)[0]-1500
binhisto = 100
# Final vector with positions.
x_values = N.arange(minpix_X,maxpix_X,1)
y_values = N.arange(minpix_Y,maxpix_Y,1)
# Total dimension for the input variables.
maxdim = int(20*(10.+(4*(((maxrad)*(maxrad+1))/2.))))
# Defining other variables.
XX = N.zeros((maxdim),float)
YY = N.zeros((maxdim),float)
XO = N.zeros((maxdim),float)
YO = N.zeros((maxdim),float)
RR = N.zeros(totnum)
# Range of apertures to be launched.
apertures = N.arange(minrad,maxrad,1)
n_apertures = len(apertures)
# Length definition for the final outputs.
finalbackg = N.zeros(n_apertures,'float64')
finalmeans = N.zeros(n_apertures,'float64')
gausshisto = N.zeros((binhisto,2*n_apertures),dtype='float64')
# Starting the analysis.
mmm = 0
for app in range(n_apertures):
raper = apertures[app]
# minrad = maxrad = raper
if verba:
print 'Interation %i out of %i ' %(app+1,n_apertures)
print '-------------------------'
# New temporal variables (erased in every loop).
fluxes = N.zeros(totnum,dtype='float64')
sbackg = N.zeros(totnum,dtype='float64')
ff = -1
# Now it runs until it gets "totnum" measurements.
hh = -1
contador = 0
while contador < (totnum):
kk = -1
# Random x,y numbers to estimate the position
# to place the aperture.
xo = N.random.random_integers(minpix_X,maxpix_X)
yo = N.random.random_integers(minpix_Y,maxpix_Y)
if verba: print 'xo,yo',xo,yo
# Corresponding radial distance to the center.
tempradii = N.sqrt((xo-xGC)*(xo-xGC)+(yo-yGC)*(yo-yGC))
if tempradii < (radialmax+1):
# Now it is computed the shape of the aperture.
Xr = N.zeros((raper*raper),float)
Yr = N.zeros((raper*raper),float)
for ii in range(raper):
xvalue = xo+ii
for jj in range(raper):
kk += 1
yvalue = yo+jj
Xr[kk] = xvalue
Yr[kk] = yvalue
# Here it checks the blanckness of the aperture.
tempflux = area2noise(segima,photima,Xr,Yr)
if raper<2 :
if tempflux != -999. :
fluxes[hh] = tempflux
if verba: print 'Adding flux: ',tempflux
hh += 1
contador += 1
if raper>1:
if tempflux[0] != -999. :
fluxes[hh] = tempflux.sum() - (finalmeans[0] * raper**2) #why?
contador += 1
hh += 1
if verba: print 'hh',hh
# Computing values from the sample.
sigfluxes = U.std_robust(fluxes)
good = U.less_equal(abs(fluxes),5.*sigfluxes)
fluxes = U.compress(good,fluxes)
# Storing the background dispersion & mean inside that aperture.
finalbackg[app] = U.std(fluxes)
finalmeans[app] = U.mean(fluxes)
if plots == 'yes':
plt.figure(1,figsize = (7,6),dpi=70, facecolor='w', edgecolor='k')
plt.clf()
# va1,va2 = N.histogram(fluxes,binhisto,normed=1)
va1,va2,va3 = plt.hist(fluxes,binhisto,normed=1,facecolor='black',alpha=0.5,linewidth=1.5)
baseh = va2[0:-1] + ((va2[1]-va2[0])/2.)
nele = len(fluxes)
mu = U.mean(fluxes)
sig = U.std(fluxes)
# yh = U.normpdf(va2,mu,sig)
# plt.plot(va2,yh,'r-',linewidth=3,alpha=0.7)
mu = U.mean_robust(fluxes) # repeated
sig = U.std_robust(fluxes) # repeated
# yh = U.normpdf(va2,mu,sig) # repeated
# plt.plot(va2,yh,'r--',linewidth=3,alpha=0.7) # repeated
plt.legend([('MEAN: %.4f ''\n'' RMS: %.4f '%(mu,sig)),
'Aperture: %i $pix$'%(raper*raper)],
numpoints=1,loc='upper right',fontsize=14)
plt.xlim(mu-4*sig,mu+4*sig)
plt.xlabel('Aperture Flux [ADU]',size=20)
plt.ylabel('Number Counts',size=20)
plt.xticks(fontsize=17),plt.yticks(fontsize=17)
nameima = photometry.split('/')[-1:][0]
plt.ylim()
figure2name = file_root+'_hfaper_%i.png' %(raper)
plt.savefig(figure2name,dpi=150)
plt.close()
# Here it saves the info from the histogram.
ind1 = app*2
ind2 = app*2+1
if verba: print 'ind1,ind2',ind1,ind2
gausshisto[:,ind1] = baseh # va2
gausshisto[:,ind2] = va1 # yh
# At this point all apertures have been computed.
# Now it will represent the sigma_vs_area dependency.
sigmas = finalbackg #-abs(finalmeans)
aa,bb = sigmafit(sigmas,sigmas[0],apertures)
if plots == 'yes':
plt.figure(2, figsize = (7,6),dpi=80, facecolor='w', edgecolor='k')
plt.clf()
plt.plot(apertures,sigmas[0]*apertures*(aa+bb*apertures),'k-',apertures,apertures*sigmas[0],'r-')
plt.legend([('%.3f$\sqrt{N}$ (%.3f + %.3f$\sqrt{N}$)' %(sigmas[0],aa,bb)),
'%.3f$\sqrt{N}$ | Poisson Distribution '%(sigmas[0])],
numpoints=1,loc='upper left')
plt.plot(apertures,sigmas,'ko')
plt.xlim(0.,max(apertures)+1)
plt.xlabel('$\sqrt{N}$',size=18)
plt.ylabel('$\sigma$',size=20)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
nick2 = photometry.split('/')[-1:][0]
figure1name = file_root+'_apersigma.png'
plt.savefig(figure1name,dpi=150)
plt.close()
# Saving outputs in ASCII files.
fileout = file_root+'.apertures.txt'
header = '# AREA[pix] RMS(std[counts]) MEAN(mean_robust[counts])'
U.put_data(fileout,(apertures,sigmas,finalmeans),header)
#print 'Saving data... in %s' %(fileout)
"""
plt.clf()
plt.subplot(211)
a13_p, a23_p, a33_p = plt.hist(mr[c3], base, alpha=0.5, color='red')
m_peak = base2[N.argmax(a13_p)]
plt.figure(2)
plt.clf()
c0 = N.greater_equal(s2n, .01) * N.less(mr, 30)
a13_c, a23_c, a33_c = plt.hist(mr[c0], base, cumulative='yes')
aa_norm_c = (a13_c / fov) / max(a13_c / fov)
plt.figure(1)
plt.subplot(212)
plt.plot(base2, aa_norm_c, 'o-', lw=12, alpha=0.5, color='orange')
pos_50 = N.argmin(abs(aa_norm_c - 0.5))
m_50 = base2[pos_50]
pos_80 = N.argmin(abs(aa_norm_c - 0.8))
m_80 = base2[pos_80]
pos_95 = N.argmin(abs(aa_norm_c - 0.95))
m_95 = base2[pos_95]
m_c3, s2n_c3 = U.get_data(filename, (mag_3arc_pos[ii], s2n_3arc_pos[ii]))
m_c3 += -0.2
c3_min = N.greater_equal(s2n_c3, 2.95) * N.less_equal(s2n_c3, 3.05)
c3_min *= N.less(m_c3, 30)
m_3s_3arcs = U.mean_robust(m_c3)
print '%s & %.2f & %.2f & %.2f & %.2f & %.2f ' % (
filters[ii], m_peak, m_50, m_80, m_95, m_3s_3arcs)
pausa = raw_input('paused')
good_g_aper = N.greater(g_aper, 0) * N.less(g_aper, 30)
good_r_aper = N.greater(r_aper, 0) * N.less(r_aper, 30)
good_i_aper = N.greater(i_aper, 0) * N.less(i_aper, 30)
good_z_aper = N.greater(z_aper, 0) * N.less(z_aper, 30)
#
good_u_sdss = N.greater(u_sdss, 0) * N.less(u_sdss, 30)
good_g_sdss = N.greater(g_sdss, 0) * N.less(g_sdss, 30)
good_r_sdss = N.greater(r_sdss, 0) * N.less(r_sdss, 30)
good_i_sdss = N.greater(i_sdss, 0) * N.less(i_sdss, 30)
good_z_sdss = N.greater(z_sdss, 0) * N.less(z_sdss, 30)
### Computing offsets
### U-band
dm_u_auto = u_auto[good_u_sdss * good_u_auto] - u_sdss[good_u_sdss *
good_u_auto]
offset_dm_u_auto = U.mean_robust(dm_u_auto)
dm_u_petro = u_petro[good_u_sdss * good_u_petro] - u_sdss[good_u_sdss *
good_u_petro]
offset_dm_u_petro = U.mean_robust(dm_u_petro)
dm_u_aper = u_auto[good_u_sdss * good_u_aper] - u_sdss[good_u_sdss *
good_u_aper]
offset_dm_u_aper = U.mean_robust(dm_u_aper)
# Saving info.
line = 'uJAVA %.3f %.3f ' % (offset_dm_u_auto, offset_dm_u_petro)
line += ' %.3f \n' % (offset_dm_u_aper)
filename.write(line)
### G-band
dm_g_auto = g_auto[good_g_sdss * good_g_auto] - g_sdss[good_g_sdss *
good_g_auto]
offset_dm_g_auto = U.mean_robust(dm_g_auto)
list_cali_columns = root2cats + 'calicolumns.list'
if not os.path.exists(list_cali_columns):
cmd = 'ls %s*.auto_cali.columns > %scalicolumns.list' % (root2cats,
root2cats)
os.system(cmd)
# Reading list
if os.path.exists(list_cali_columns):
cols = U.get_str(list_cali_columns, 0)
n_c = len(cols)
zp_val = N.zeros((12, n_c), float)
zp_final = N.zeros(12)
for ss in range(n_c):
vars, evars, posref, zpe, zpc = A.get_usefulcolumns(cols[ss])
#print zpc[:]
#pausa = raw_input('paused')
for ii in range(12):
zp_val[ii, ss] = zpc[ii]
for hh in range(12):
zp_final[hh] = U.mean_robust(zp_val[hh, :])
# Saving results
master_cali_columns = root2cats + 'master_calicolumns.txt'
U.put_data(master_cali_columns, (N.arange(12) + 1, zp_final),
'# Filter ZPc')
else:
print 'File %s does not exist!' % (master_cali_columns)
pepa = pepe[jj].split()
#print pepa
med_value[ii, jj] = float(pepa[1])
std_value[ii, jj] = float(pepa[2])
out_value[ii, jj] = float(pepa[3])
num_sourc[ii, jj] = float(pepa[4])
except:
med_value[ii, jj] = 0.0
std_value[ii, jj] = 0.0
out_value[ii, jj] = 0.0
num_sourc[ii, jj] = 0.0
print 'Model med std out num '
for jj in range(n_models):
good = N.greater(std_value[:, jj], 0.0001)
linea = '%i, %.3f, %.3f, ' % (jj + 1, U.mean_robust(
med_value[good, jj]), U.mean_robust(std_value[good, jj]))
linea += '%.3f %i ' % (U.mean_robust(
out_value[good, jj]), U.sum(num_sourc[good, jj]))
print linea
base_sz = N.arange(0.0005, 0.095, 0.015)
base_sz_2 = N.arange(-0.095, 0.095, 0.015)
plt.clf()
for ss in range(n_models):
plt.subplot(3, 4, ss + 1)
good = N.greater(std_value[:, ss], 0.0001)
a1, a2, a3 = plt.hist(std_value[good, ss], base_sz, alpha=0.5, normed=1)
b1, b2, b3 = plt.hist(med_value[good, ss],
base_sz_2,
facecolor='red',
alpha=0.5,
good_sample, (delta_ra, delta_dec, r_sd))
# Starting the figure
res = 50
plt.figure(1, figsize=(12, 10), dpi=70, facecolor='w', edgecolor='k')
plt.clf()
#plt.plot(U.mean_robust(delta_dec[::res])-0.15,U.mean_robust(delta_ra[::res]),'rs',ms=20)
plt.scatter(delta_dec[::res] - 0.15,
delta_ra[::res],
s=100,
c=r_sd[::res],
marker=u'o',
cmap=cm.PuOr,
alpha=0.25,
vmin=14.0,
vmax=21.5)
#plt.plot(U.mean_robust(delta_dec[::res])-0.15,U.mean_robust(delta_ra[::res]),'rs',ms=20)
#plt.legend(['Mean'],loc='upper left',fontsize=30)
cb = plt.colorbar(pad=0., format='%.1f')
cb.set_label('R-band Magnitude', size=25, labelpad=10)
plt.xlim(-1.99, 1.99)
plt.ylim(-1.99, 1.99)
plt.ylabel('$\delta$$(RA)$ [pix]', size=25, labelpad=5)
plt.xlabel('$\delta$$(Dec)$ [pix]', size=25, labelpad=5)
plt.xticks(fontsize=20)
plt.yticks(fontsize=20)
plt.grid()
print '%.2f,%.2f' % (U.mean_robust(
delta_dec[::res]), U.mean_robust(delta_ra[::res]))
plt.savefig('/Users/albertomolino/Desktop/example1.png', dpi=100)
def get_masterPDZ_pro(hdf5file, mmin, mmax, dm):
"""
TAKEN DIRECTLY FROM CLASH_TOOLS.py
This routine derives the master PDZ for
a sample of magnitudes based on an empirical
BPZ-HDF5 catalogue.
---
This new version allows the user to change
the magnitude range from outside.
===
import clash_tools as CT
hdf5file = root+'alhambra.spz.hdf5'
mpdz,z,sigz,meanz = CT.get_masterPDZ(hdf5file)
"""
# Reading data
p1 = h5py.File(hdf5file, mode='r')
pdz1 = p1.get('FullProbability')
zz1 = p1.get('redshift')[:]
tt1 = p1.get('type')[:]
mo1 = p1.get('m_0')[:]
# Defining resolution and other variables.
basem = N.arange(mmin, mmax + dm, dm)
nm = len(basem)
res = 2
zz1r = zz1[::res]
dz2 = (zz1r.max() - zz1r.min())
basez = N.linspace(-dz2, dz2, len(zz1r) * 2)
basez2 = basez + ((basez[1] - basez[0]) / 2.)
masterpdz = N.zeros((nm, len(basez)), float)
sigma_pdz = N.zeros(nm)
meanz = N.zeros(nm)
# Global P(z)
weirdpeaks = []
print 'Number of magnitude-bins: ', nm
for jj in range(nm):
# Selecting galaxies within that magnitude bin.
if jj == 0:
good = N.less_equal(mo1, basem[jj])
pdz1r = pdz1[good, :, :]
elif jj == nm - 1:
good = N.greater_equal(mo1, basem[jj - 1])
good *= N.less_equal(mo1, basem[jj])
pdz1r = pdz1[good, :, :]
else:
good = N.greater_equal(mo1, basem[jj - 1])
good *= N.less_equal(mo1, basem[jj])
pdz1r = pdz1[good, :, :]
ng1 = N.shape(pdz1r)[0]
peaks = []
print '%i galaxies in magnitude-bin %i ' % (ng1, jj + 1)
mo1r = mo1[good]
for ii in range(ng1):
# print 'galaxy number %i out of %i '%(ii+1,ng1)
pdz_ind = N.sum(pdz1r[ii, :, :], axis=1)
pdz_ind_r = pdz_ind[::res]
peak = pdz_ind_r.max()
pos = N.where(pdz_ind_r == peak)[0][0]
zpeak = zz1r[pos]
# new_zmin = len(zz1r)-zpeak
new_zmin = len(zz1r) - pos - 1 # len(zz1r[0:pos])
min_val = min(pdz_ind_r)
max_val = max(pdz_ind_r)
if abs(min_val - max_val) < 1.0e-8: pdz_ind_r[:] = zz1r * 0
if zpeak < 0.0005: pdz_ind_r[:] = zz1r * 0
# try:
if zpeak > 0.0005:
masterpdz[jj, new_zmin:new_zmin + len(zz1r)] += pdz_ind_r[:]
# except: weirdpeaks.append(zpeak)
if zpeak > 0.0005:
peaks.append(zpeak)
# plt.figure(200)
# plt.clf()
# plt.plot(zz1r,pdz_ind_r,'k-')
# plt.xlim(0.,0.2)
# plt.grid()
# print 'AB,dz/1+z,dz: %.2f,%.3f,%.2f:'%(mo1r[ii],(zpeak-0.044)/1.044,zpeak-0.044)
# pausa = raw_input('paused')
masterpdz[jj, :] /= float(masterpdz[jj, :].sum())
cumasterpdz = U.add.accumulate(masterpdz[jj, :])
cumasterpdz /= cumasterpdz.max()
zmin_err_e = U.match_resol(cumasterpdz, basez2, 0.17)
zmax_err_e = U.match_resol(cumasterpdz, basez2, 0.83)
sigma_pdz[jj] = (zmax_err_e - zmin_err_e)
peak_position = N.where(
masterpdz[jj, :] == masterpdz[jj, :].max())[0][0]
# print 'peak_position',peak_position
# print 'zpeak=',zz1r[peak_position]
meanz[jj] = U.mean_robust(N.array(peaks))
# U.std_mad(N.array(peaks))
return masterpdz, basez2, sigma_pdz, meanz
for sss in range(n_cats):
field = os.path.basename(cats[sss])[9:-15]
master_cat = root_to_cats + 'STRIPE82-%s_Photometry.cat' % (field) ##
print 'reading catalog %i out of %i ' % (sss + 1, n_cats)
x, y, fwhm, mr = U.get_data(master_cat, (3, 4, 8, 84))
fwhm_master, stars = sct.get_seeing_from_data_pro(fwhm, mr)
# Reading FWHM from Individual R images.
ind_catalog = root_to_ind + 'sex_STRIPE82-%s_R_swp.cat' % (field) ##
fwhm_indiv = U.get_data(ind_catalog, 6)
x_stars, y_stars, fw_stars = U.multicompress(stars, (x, y, fwhm_indiv))
center_pos_x = N.less(abs(x_stars - N.mean(x_stars)), 1000.)
center_pos_y = N.less(abs(y_stars - N.mean(y_stars)), 1000.)
fw_stars_center = fw_stars[center_pos_x * center_pos_y]
for ii in range(len(x_stars)):
linea = '%i %i ' % (x_stars[ii], y_stars[ii])
mean_value_center = U.mean_robust(fw_stars_center)
#valor = (fw_stars[ii]*fw_stars[ii])-(mean_value_center*mean_value_center)
valor = (fw_stars[ii] - mean_value_center)
linea += '%.2f \n' % (valor)
file_out.write(linea)
file_out.close()
if os.path.exists(file_out_name):
xx, yy, ff = U.get_data(file_out_name, (0, 1, 2))
# Starting the figure
res = 1
plt.figure(1, figsize=(12, 10), dpi=70, facecolor='w', edgecolor='k')
plt.clf()
plt.scatter(xx[::100] + 30000.,
yy[::100] + 30000.,
z_y1_model, mag_y1_model = U.get_data(ab_filter_y1_model, (0, 1))
ab_filter_y1[:, ii] = B.flux2mag(mag_y1_model)
ab_filter_y2_model = ab_path + sed_models[ii][:-3] + filter_y2 + '.AB'
z_y2_model, mag_y2_model = U.get_data(ab_filter_y2_model, (0, 1))
ab_filter_y2[:, ii] = B.flux2mag(mag_y2_model)
for zz in range(res_z - 1):
# Select galaxies with that redshift.
if zz < 1:
good_z = N.less_equal(zs, z_range[zz + 1])
else:
good_z = N.greater_equal(zs, z_range[zz])
good_z *= N.less_equal(zs, z_range[zz + 1])
mean_z = U.mean_robust(zs[good_z])
pos_z = N.argmin(abs(mean_z - z_ab))
#Template Colour definition
color_templ_xaxis = (ab_filter_x1[pos_z, :] - ab_filter_x2[pos_z, :])
color_templ_yaxis = (ab_filter_y1[pos_z, :] - ab_filter_y2[pos_z, :])
# Plots
plt.figure(1, figsize=(12, 10), dpi=75, facecolor='w', edgecolor='k')
plt.clf()
plt.plot(color_x[good_z], color_y[good_z], 'bo', alpha=0.2, ms=10)
if mean_z < 0.2:
plt.xlim(0., 2.5)
plt.ylim(0., 2.5)
else:
plt.xlim(0.5, 3.5)
#splus_colors = list(cm.jet(N.linspace(0, 1, 12)))
#splus_colors = list(cm.rainbow(N.linspace(0, 1, 5)))
y_min = -1.49
y_max = 1.49
y_min = -0.99
y_max = 0.99
x_min = 14
x_max = 21
## U
#plt.figure(1,figsize = (14,6),dpi=70, facecolor='w', edgecolor='k')
plt.figure(1, figsize=(14, 4), dpi=70, facecolor='w', edgecolor='k')
plt.clf()
uno = plt.axes([.075, .12, .725, .87])
plt.plot(u_sd[::res],
delta_u[::res] - (U.mean_robust(delta_u)),
'o',
ms=5,
alpha=0.1,
color='grey')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.grid()
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.ylabel('$m^{sp}_{u}$ - $m^{sd}_{u}$', size=25, labelpad=-1)
#plt.xlabel('$m^{sd}_{u}$',size=25,labelpad=1)
plt.xlabel('$m^{u,sp}$', size=23, labelpad=-10)
dos = plt.axes([.8, .12, .15, .87])
a1, a2, a3 = plt.hist(delta_u[::res] - (U.mean_robust(delta_u)),
#seeing_values = N.zeros((n_cats,12),float)
## Reading data from catalogues
for sss in range(n_cats):
field = os.path.basename(cats[sss])[9:-15]
master_cat = root_to_cats + 'STRIPE82-%s_Photometry.cat' % (field) ##
print 'reading catalog %i out of %i ' % (sss + 1, n_cats)
fwhm, mr = U.get_data(master_cat, (8, 84))
fwhm_master, stars = sct.get_seeing_from_data_pro(fwhm, mr)
for hhh in range(12):
ind_catalog = root_to_ind + 'sex_STRIPE82-%s_%s_swp.cat' % (
field, filters[hhh]) ##
fwhm_ind = U.get_data(ind_catalog, 6)
fwhm_redu = fwhm_ind[stars]
good_stars = N.greater_equal(fwhm_redu, 1.)
fwhm_values[sss, hhh] = U.mean_robust(fwhm_redu[good_stars]) * 0.55
# aa & bb have to be picked from other catalogues.
#aa,bb = U.get_data(ind_catalog,(11,12))
#pausa = raw_input('paused in filter: %s'%(filters[hhh]))
#boa_values[sss,hhh] = U.mean_robust((bb/aa)[stars])
# Reading s/n from master for each filter
mp, s2n = U.get_data(master_cat, (mag_pos[hhh], s2n_pos[hhh]))
mp += 0.083
c0 = N.greater_equal(s2n, 3.) * N.less(mp, 30)
w1, w2 = N.histogram(mp[c0], base_mlim)
mlim_values[sss, hhh] = base_mlim2[N.argmax(w1)]
# Reading ZP values
zp_file = root_to_zps + 'STRIPE82-%s_ZP.cat' % (field)
zps_values[sss, :] = U.get_data(zp_file, 1)[:]
