def results(response):
info = VISinformation()
zodi = response.getvalue('zodi')
magnitude = float(response.getvalue('magnitude'))
exptime = float(response.getvalue('exptime'))
obj = response.getvalue('object')
exposures = int(response.getvalue('exposures'))
ETC.SNRproptoPeak(info, exptime=exptime, exposures=exposures, server=True)
if obj == 'galaxy':
galaxy = True
else:
galaxy = False
exp = ETC.exposureTime(info, magnitude, exposures=exposures, galaxy=galaxy, fudge=1.0)
limit = ETC.limitingMagnitude(info, exp=exptime, galaxy=galaxy, exposures=exposures, fudge=1.0)
snr = ETC.SNR(info, magnitude=magnitude, exptime=exptime, exposures=exposures, galaxy=galaxy)
print "<html>"
print "<head> <center> <b>Results</b> </center></head> "
print "<body style='background-color:Moccasin;''>"
print '<br><b> Results </b><br>'
print 'Exposure time required to reach SNR=10.0 given a %.2f magnitude %s is %.1f seconds ' \
'if combining %i exposures<br><br>' % (magnitude, obj, exp, exposures)
print 'SNR=%f for %.2fmag %s if exposure time is %.2f seconds<br><br>' % (snr, magnitude, obj, exptime*exposures)
print 'Limiting magnitude of a %s for %.2f second exposure is %.2f<br><br>' % (obj, exptime, limit)
print "<p><img src='../delete.png'/></p>"
print "</body>"
def objectDetection(log,
magnitude=24.5,
exptime=565,
exposures=3,
fpeak=0.7,
offset=0.5,
covering=2550,
ghostlevels=(6e-7, 1e-6, 4e-6, 5e-6, 1e-5, 5e-5)):
"""
Derive area loss in case of object detection i.e. the SNR drops below the requirement.
Assumes that a ghost covers the covering number of pixels and that the peak pixel of a
point source contains fpeak fraction of the total counts. An offset between the V-band
and VIS band is applied as VIS = V + offset.
:param log: logger instance
:param magnitude: magnitude limit of the objects to be detected
:param exptime: exposure time of an individual exposure in seconds
:param exposures: number of exposures combined in the data analysis
:param fpeak: PSF peak fraction
:param offset: offset between the V-band and the VIS band, VIS = V + offset
:param covering: covering fraction of a single ghost in pixels
:param ghostlevels: a tuple of ghost levels to inspect
:param ghostlevels: tuple
:return: None
"""
info = VISinformation()
ghoste, ghoste2 = ETC.galaxyDetection(info,
magnitude=magnitude,
exptime=exptime,
exposures=exposures)
print '-' * 100
print '\n\n\nObject Detection, a ghost covers %i pixels' % covering
print '-' * 100
res = []
for ghostreq in ghostlevels:
maglimit = info['zeropoint'] - 5 / 2. * np.log10(
(ghoste) / (exptime * exposures * fpeak * ghostreq))
txt = 'Limiting VIS magnitude for object detection = %.2f if %.2f extra electrons from ghost of ratio %.1e' % \
(maglimit, ghoste, ghostreq)
print txt
log.info(txt)
res.append(maglimit)
_numberOfStarsAreaLoss(
log,
res,
r'Object Detection Area Loss Because of Ghosts from Stars',
offset=offset,
covering=covering)
def plotSNRfromCatalog(catalogname):
#read in data
catalog = np.loadtxt(catalogname, usecols=(2, 3))
st = catalog[:, 0][catalog[:, 1] < 1] #stars, magnitudes
gal = catalog[:, 0][catalog[:, 1] > 7] #galaxies, mags
bins = np.linspace(0, 700, 31)
df = bins[1] - bins[0]
weight = 1. / (2048 * 2 * 2066 * 2. * 0.1 * 0.1 * 7.71604938e-8
) / df #how many square degrees one CCD is on sky
SNRs = ETC.SNR(VISinformation(), magnitude=st, exposures=1, galaxy=False)
SNRg = ETC.SNR(VISinformation(), magnitude=gal, exposures=1)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(SNRs,
bins=bins,
alpha=0.5,
log=True,
weights=[
weight,
] * len(st),
label='Stars')
ax.hist(SNRg,
bins=bins,
alpha=0.2,
log=True,
weights=[
weight,
] * len(gal),
label='Galaxies')
ax.set_xlabel('SNR [assuming 565s exposure]')
ax.set_ylabel(r'N [deg$^{-2}$ dex$^{-1}$]')
plt.legend(shadow=True, fancybox=True)
plt.savefig(catalogname + 'SNRs.pdf')
plt.close()
def pixelsImpacted(magnitude,
exptime=565,
pixelFractions=(0.65, 0.4, 0.35, 0.18, 0.09, 0.05),
star=False,
lookup=True):
"""
This potentially overestimates because does not consider the fact that bleeding is along the column
and hence some saturated pixels may be double counted.
"""
if lookup:
#use a lookup table
data = [(0, 311609), (1, 251766), (2, 181504), (3, 119165), (4, 75173),
(5, 46298), (6, 28439), (7, 18181), (8, 12491), (9, 7552),
(10, 4246), (11, 1652), (12, 636), (13, 247), (14, 93),
(15, 29), (16, 8), (17, 2), (18, 1), (19, 0), (20, 0)]
data.sort()
pos = bisect.bisect_left(data, (magnitude - 0.99, ))
return data[pos][1]
else:
#try to calculate
info = VISinformation()
zp = info['zeropoint']
fw = info['fullwellcapacity']
electrons = 10**(-.4 * (magnitude - zp)) * exptime
mask = 0
for x in pixelFractions:
mask += np.round(
electrons * x / fw -
0.4) #0.4 as we don't want to mask if say 175k pixels...
if star:
mask += (20 * 20)
if mask > 2000**2:
mask = 2000**2
return mask
def plotSNR(deg=60, kdes=True, log=False):
CCDs = 1000
fudge = 47.0
#cumulative distribution of stars for different galactic latitudes
if deg == 30:
tmp = 1
sfudge = 0.79
elif deg == 60:
tmp = 2
sfudge = 0.79
else:
tmp = 3
sfudge = 0.78
#stars
d = np.loadtxt('data/stars.dat', usecols=(0, tmp))
stmags = d[:, 0]
stcounts = d[:, 1]
#fit a function and generate finer sample
z = np.polyfit(stmags, np.log10(stcounts), 4)
p = np.poly1d(z)
starmags = np.arange(1, 30.2, 0.2)
starcounts = 10**p(starmags)
cpdf = (starcounts - np.min(starcounts)) / (np.max(starcounts) -
np.min(starcounts))
starcounts /= 3600. #convert to square arcseconds
nstars = int(np.max(starcounts) * fudge * sfudge) * CCDs
magStars = cr.drawFromCumulativeDistributionFunction(
cpdf, starmags, nstars)
SNRsStars = ETC.SNR(ETC.VISinformation(),
magnitude=magStars,
exposures=1,
galaxy=False)
print 'Assuming Galactic Lattitude = %i deg' % deg
print 'Number of stars within a pointing (36CCDs) with 70 < SNR < 700 (single 565s exposure):', \
int((SNRsStars[(SNRsStars > 70) & (SNRsStars < 700)]).size * 36. / CCDs)
print 'Number of stars within a pointing (36CCDs) with 60 < SNR < 80 (single 565s exposure):', \
int((SNRsStars[(SNRsStars > 60) & (SNRsStars < 80)]).size * 36. / CCDs)
print 'Number of stars within a pointing (36CCDs) with 690 < SNR < 710 (single 565s exposure):', \
int((SNRsStars[(SNRsStars > 690) & (SNRsStars < 710)]).size * 36. / CCDs)
print 'Number of stars within a pointing (36CCDs) with 18 < mag < 22 (single 565s exposure):', \
int((SNRsStars[(magStars > 18) & (magStars < 22)]).size * 36. / CCDs)
print 'Number of stars within a pointing (36CCDs) with 18 < mag < 23 (single 565s exposure):', \
int((SNRsStars[(magStars > 18) & (magStars < 23)]).size * 36. / CCDs)
print 'Number of stars within a pointing (36CCDs) with 17.9 < mag < 18.1 (single 565s exposure):', \
int((SNRsStars[(magStars > 17.9) & (magStars < 18.1)]).size * 36. / CCDs)
print 'Number of stars within a pointing (36CCDs) with 21 < mag < 23 (single 565s exposure):', \
int((SNRsStars[(magStars > 21) & (magStars < 23)]).size * 36. / CCDs)
#calculate Gaussian KDE with statsmodels package (for speed)
if kdes:
kn = SNRsStars[SNRsStars < 1000]
kdeStars = KDE(kn)
kdeStars.fit(adjust=2)
nst = kn.size / 10. / 1.38
#galaxies
#cumulative distribution of galaxies
d = np.loadtxt('data/cdf_galaxies.dat', usecols=(0, 1))
gmags = d[:, 0]
gcounts = d[:, 1]
nums = int(np.max(gcounts) / 3600. * fudge * CCDs)
z = np.polyfit(gmags, np.log10(gcounts), 4)
p = np.poly1d(z)
galaxymags = np.arange(10.0, 30.2, 0.2)
galaxycounts = 10**p(galaxymags)
cumulative = (galaxycounts - np.min(galaxycounts)) / (
np.max(galaxycounts) - np.min(galaxycounts))
magGalaxies = cr.drawFromCumulativeDistributionFunction(
cumulative, galaxymags, nums)
SNRsGalaxies = ETC.SNR(VISinformation(),
magnitude=magGalaxies,
exposures=1)
#calculate Gaussian KDE, this time with scipy to save memory, and evaluate it
if kdes:
kn = SNRsGalaxies[SNRsGalaxies < 1000]
#pos = np.linspace(1, 810, num=70)
#kdegal = gaussian_kde(kn)
#gals = kdegal(pos)
#ngl = kn.size #/ df
kdeGalaxy = KDE(kn)
kdeGalaxy.fit(adjust=10)
ngl = kn.size / 10. / 1.38
#histogram binning and weighting
bins = np.linspace(0., 1000., 101)
df = bins[1] - bins[0]
weight = 1. / (2048 * 2 * 2066 * 2 * 0.1 * 0.1 * 7.71604938e-8 * CCDs) / df
weightsS = np.ones(magStars.size) * weight
weightsG = np.ones(magGalaxies.size) * weight
#simple magnitude distribution plot for stars
stars = np.loadtxt('data/stars.dat')
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hist(magStars,
bins=30,
cumulative=True,
log=True,
alpha=0.3,
weights=weightsS * df,
label='Random Draws')
ax.semilogy(stars[:, 0], stars[:, 1], label='Stars (30deg)')
ax.semilogy(stars[:, 0], stars[:, 2], label='Stars (60deg)')
ax.semilogy(stars[:, 0], stars[:, 3], label='Stars (90deg)')
ax.set_xlabel(r'$M_{AB}$')
ax.set_ylabel(r'Cumulative Number of Objects [deg$^{-2}$]')
plt.legend(shadow=True, fancybox=True, loc='upper left')
plt.savefig('stars%ideg.pdf' % deg)
plt.close()
#make a plot
txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())
ax = host_subplot(111, axes_class=AA.Axes)
hist1 = ax.hist(SNRsStars,
bins=bins,
alpha=0.2,
log=True,
weights=weightsS,
label='Stars [%i deg]' % deg,
color='r')
hist2 = ax.hist(SNRsGalaxies,
bins=bins,
alpha=0.2,
log=True,
weights=weightsG,
label='Galaxies',
color='blue')
if kdes:
ax.plot(kdeStars.support,
kdeStars.density * nst,
'r-',
label='Gaussian KDE (stars)')
#ax.plot(pos, gals*ngl, 'b-', label='Gaussian KDE (galaxies)')
ax.plot(kdeGalaxy.support,
kdeGalaxy.density * ngl,
'b-',
label='Gaussian KDE (galaxies)')
#calculate magnitude scale, top-axis
if log:
mags = np.asarray([17, 18, 19, 20, 21, 22, 23, 24])
SNRs = ETC.SNR(VISinformation(),
magnitude=mags,
exposures=1,
galaxy=False)
else:
mags = np.asarray([17, 17.5, 18, 18.5, 19, 20, 21, 22.5])
SNRs = ETC.SNR(VISinformation(),
magnitude=mags,
exposures=1,
galaxy=False)
ax2 = ax.twin() # ax2 is responsible for "top" axis and "right" axis
ax2.set_xticks(SNRs)
ax2.set_xticklabels([str(tmp) for tmp in mags])
ax2.set_xlabel('$M(R+I)_{AB}$ [mag]')
ax2.axis['right'].major_ticklabels.set_visible(False)
ax.set_ylim(1e-1, 1e5)
ax.set_ylabel('Number of Objects [deg$^{-2}$ dex$^{-1}$]')
ax.set_xlabel('Signal-to-Noise Ratio [assuming a single 565s exposure]')
plt.text(0.8,
1.12,
txt,
ha='left',
va='top',
fontsize=9,
transform=ax.transAxes,
alpha=0.2)
plt.legend(shadow=True, fancybox=True)
if log:
ax.set_xscale('log')
plt.savefig('SNRtheoretical%ideglog.pdf' % deg)
else:
ax.set_xlim(1, 1e3)
plt.savefig('SNRtheoretical%ideglin.pdf' % deg)
plt.close()
#write output
if not log:
mid = df / 2.
#output to file
fh = open('SNRsSTARS%ideg.txt' % deg, 'w')
fh.write('#These values are for stars at %ideg (%s)\n' % (deg, txt))
fh.write('#SNR number_of_stars N\n')
fh.write('#bin_centre per_square_degree per_pointing\n')
for a, b in zip(hist1[0], hist1[1]):
fh.write('%i %f %f\n' % (b + mid, a * df, a * df * 0.496))
fh.close()
fh = open('SNRsGALAXIES.txt', 'w')
fh.write('#These values are for galaxies (%s)\n' % txt)
fh.write('#SNR number_of_galaxies N\n')
fh.write('#bin_centre per_square_degree per_pointing\n')
for a, b in zip(hist2[0], hist2[1]):
fh.write('%i %f %f\n' % (b + mid, a * df, a * df * 0.496))
fh.close()
file + 'CTIresidual.fits',
unsigned16bit=False)
self.compressAndRemoveFile(file + 'CTIresidual.fits')
# store the result, not really necessary in this case, but for info...
str = '\nFinished processing %s.fits, took about %.1f minutes to run' % (
file, -(start_time - time.time()) / 60.)
self.result_queue.put(str)
if __name__ == '__main__':
#how many processes to use?
num_processes = 12
#input values that are used in processing and save to the FITS headers
values = VISinformation()
values.update({
'ystart': 560,
'xstart': 560,
'ystop': 4692,
'xstop': 4656,
'cutoff': 1e11,
'ceil': 1e11
})
#find all files to be processed
inputs = g.glob('*.fits')
needed = []
#check if CTI FITS file already exists, skip these
for input in inputs:
ax.set_xlabel(r'Ghost Contribution $[e^{-}]$')
ax.set_xlim(-0.01, 200.01)
plt.legend(shadow=True, fancybox=True, loc='best', numpoints=1)
plt.savefig('ObjectDetection.pdf')
plt.close()
return maxn1, maxn2
if __name__ == '__main__':
magnitude = 24.5
exptime = 565.0
info = VISinformation()
print 'VIS zero point = %f' % info['zeropoint']
exp = exposureTime(info, magnitude, exposures=1)
limit = limitingMagnitude(info, exp=exptime)
snrS = SNR(info,
magnitude=magnitude,
exptime=exptime,
exposures=1,
galaxy=False)
snrG = SNR(info, magnitude=magnitude, exptime=exptime, exposures=3)
print 'Exposure time required to reach SNR=10/14.29 for a %.2f magnitude galaxy is %.1f' % (
magnitude, exp)
print 'SNR=%f for %.2fmag star if exposure time is %.2f seconds' % (
snrS, magnitude, exptime)
def compareSNR(catalog, max=33, noNoise=False):
"""
Compare SExtracted SNR to radiometric model from ETC module.
"""
txt = '%s' % datetime.datetime.isoformat(datetime.datetime.now())
#calculate input SNRs
info = VISinformation()
if noNoise:
info.update(dict(sky_background=0.0, dark=0.0, readnoise=0.0, zodiacal=0.0))
SNRs = ETC.SNR(info, magnitude=catalog.mag_input, exposures=1, galaxy=False, background=False)
else:
SNRs = ETC.SNR(info, magnitude=catalog.mag_input, exposures=1, galaxy=False)
#print SNRs
Sextracted = catalog.flux_aper / catalog.fluxerr_aper
fig = plt.figure(frameon=False)
left, width = 0.1, 0.8
rect1 = [left, 0.3, width, 0.65]
rect2 = [left, 0.1, width, 0.2]
ax1 = fig.add_axes(rect1, title='VIS Simulator SNR Comparison')
ax2 = fig.add_axes(rect2) #left, bottom, width, height
ax1.plot([0, max], [0, max], 'k--')
ax1.scatter(SNRs, Sextracted, c='b', marker='o', s=10, edgecolor='None', label='r=0.65 Aperture')
ax2.plot([0, max], [1, 1], 'k--')
ax2.plot([0, max], [0.7, 0.7], 'r:')
ax2.scatter(SNRs, Sextracted/SNRs.copy(), c='b', marker='o', s=10, edgecolor='None')
ax2.set_xlabel('Input SNR')
ax1.set_ylabel('Extracted SNR')
ax2.set_ylabel(r'$\frac{SE}{Input}$')
ax1.set_xticklabels([])
#ax1.set_yticks(ax1.get_yticks()[1:])
#ax2.set_yticks(ax2.get_yticks()[::2])
ax1.set_xlim(0, max)
ax1.set_ylim(0, max)
ax2.set_xlim(0, max)
ax2.set_ylim(0.2, 1.13)
ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)
ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0, loc='upper left')
plt.savefig('SNRs.pdf')
plt.close()
#for "best" setting
#Sextr = catalog.flux_best / catalog.fluxerr_best
#Sextr = 1./(catalog.magerr_auto/1.0857)
Sextr = 1./catalog.magerr_aper
fig = plt.figure(frameon=False)
left, width = 0.1, 0.8
rect1 = [left, 0.3, width, 0.65]
rect2 = [left, 0.1, width, 0.2]
ax1 = fig.add_axes(rect1, title='VIS Simulator SNR Comparison')
ax2 = fig.add_axes(rect2) #left, bottom, width, height
ax1.plot([0, max], [0, max], 'k--')
ax1.scatter(SNRs, Sextr, c='b', marker='o', s=10, edgecolor='None', label='r=0.65 Aperture')
ax2.plot([0, max], [1, 1], 'k--')
ax2.plot([0, max], [0.7, 0.7], 'r:')
ax2.scatter(SNRs, Sextr/SNRs.copy(), c='b', marker='o', s=10, edgecolor='None')
ax2.set_xlabel('Input SNR')
ax1.set_ylabel('Extracted SNR')
ax2.set_ylabel(r'$\frac{SE}{Input}$')
ax1.set_xticklabels([])
ax1.set_yticks(ax1.get_yticks()[1:])
ax2.set_yticks(ax2.get_yticks()[::2])
ax1.set_xlim(0, max)
ax1.set_ylim(0, max)
ax2.set_xlim(0, max)
ax2.set_ylim(0.2, 1.2)
ax1.text(0.83, 1.12, txt, ha='left', va='top', fontsize=9, transform=ax1.transAxes, alpha=0.2)
ax1.legend(shadow=True, fancybox=True, numpoints=1, scatterpoints=1, markerscale=1.0, loc='upper left')
plt.savefig('SNRs2.pdf')
plt.close()