def zion(findstr, catfile, outstr, EXTEN=0):
file_list = glob.glob(findstr)
catData = np.loadtxt(catfile, skiprows=1)
sort_idx = np.argsort(catData[:,0])
catData = catData[sort_idx]
for i in range(len(file_list)):
print(file_list[i])
hdu = pyfits.open(file_list[i])
image = hdu[EXTEN].data
imAngle = hdu[EXTEN].header['ANGLE']
idx = np.where(catData[:,0] == imAngle)[0]
radius = np.average(catData[:,3][idx])
width = np.average(catData[:,4][idx])
cent = ADE.centroid(image)
dims = image.shape
imRad = radius + width
cutIm = image[cent[0] - imRad:cent[0] + imRad,\
cent[1] - imRad:cent[1] + imRad]
bigIm = pl.imresize(cutIm, (1028,1028))
frameNumber = idx[0]
name = str(frameNumber).zfill(3)+'_'+str(imAngle)+outstr+'.fits'
if len(glob.glob(name)) == 0: pyfits.PrimaryHDU(bigIm).writeto(name)
return
def get_stats():
level_list = [4,5,6,7,8,9,10,11,12]
fits_vals = np.array([])
fits_err = np.array([])
for level in level_list:
fits_list = glob.glob('PD_{}_*_ds.fits'.format(level))
imarray = np.array([])
for image in fits_list:
print image
data = pyfits.open(image)[0].data
center = ADE.centroid(data)
dist = ADE.dist_gen(data,center) * 0.024
idx = np.where(dist < 6.75)
fits_data = data[idx]
imarray = np.append(imarray,np.mean(fits_data))
fits_vals = np.append(fits_vals,np.mean(imarray))
fits_err = np.append(fits_err,np.std(imarray))
return fits_vals, fits_err
def gen_resp():
# level_list = [4,5,6,7,8,9,10,11,12]
level_list = [1,2,3,4,5,6,7]
PD_vals = np.array([])
fits_vals = np.array([])
PD_err = np.array([])
fits_err = np.array([])
for level in level_list:
PD_signal = np.loadtxt('PD_{}.txt'.format(level),usecols=(1,),unpack=True)
fits_raw = pyfits.open('PD_{}_FINAL.fits'.format(level))[0].data
center = ADE.centroid(fits_raw)
dist = ADE.dist_gen(fits_raw,center) * 0.024
idx = np.where(dist < 6.75)
fits_data = fits_raw[idx]
PD_vals = np.append(PD_vals,np.mean(PD_signal))
PD_err = np.append(PD_err,np.std(PD_signal))
fits_vals = np.append(fits_vals,np.mean(fits_data))
fits_err = np.append(fits_err,np.std(fits_data))
level_vec = np.array(level_list)/12.
fig = plt.figure()
ax1 = fig.add_subplot(211)
PD_plot = PD_vals/PD_vals[-1]
PD_err_plot = PD_err/PD_vals[-1]
fits_plot = fits_vals/fits_vals[-1]
fits_err_plot = fits_err/fits_vals[-1]
# ax1.errorbar(PD_vals,fits_vals,xerr=PD_err,yerr=fits_err,linestyle='x')
ax1.plot(fits_vals,PD_vals,'.')
# ax1.axhline(y=95693.7799/2,linestyle=':')
# ax1.text(1.,95000,'Full Well')
ax1.set_ylabel('PD Voltage')
ax1.set_xlabel('CCD Mean Counts')
# ax1.set_xscale('log')
# ax1.set_yscale('log')
ax2 = fig.add_subplot(212)
ax2.plot(fits_vals,fits_vals/PD_vals,'.')
ax2.set_xlabel('CCD Mean Counts')
ax2.set_ylabel('CCD/PD')
# ax2.set_xscale('log')
# ax2.set_yscale('log')
fig.show()
return level_vec, fits_vals, fits_err, PD_vals, PD_err
def jump_test(inifile):
''' to be run in /d/monk/eigenbrot/MANGA/20121015 '''
options = ConfigParser()
options.read(inifile)
finald = []
for d in ['d1','d2','d3','d4']:
nood = N(options)
nood.get_darks()
nood.fill_dict(d,nood.direct)
nood.sub_darks(nood.direct)
nood.ratios = {'direct': {'data': {'V':{}}}}
nood.direct_to_ratios(nood.direct)
nood.combine()
finald.append(nood.ratios['direct']['data']['V']['direct']['final'])
os.system('rm *_ds.fits')
print "reduction finished"
countarr = np.array([])
voltarr = np.array([])
pot = thePot(options)
for image in finald:
hdu = pyfits.open(image)[0]
fits_raw = hdu.data
center = ADE.centroid(fits_raw)
dist = ADE.dist_gen(fits_raw,center) * 0.024
idx = np.where(dist < 6.75)
fits_data = fits_raw[idx]
countarr = np.append(countarr,np.mean(fits_data))
stime = hdu.header['STARTIME']
etime = hdu.header['ENDTIME']
voltage = pot.get_voltage(stime,etime,'V')
voltarr = np.append(voltarr,voltage)
print "\nImage :{:>15}{:>15}{:>15}{:>15}\nCounts :{:15.3E}{:15.3E}{:15.3E}{:15.3E}\nVoltage:{:15.2f}{:15.2f}{:15.2f}{:15.2f}".format(*finald+countarr.tolist()+voltarr.tolist())
print "-"*(4*15+8)
print "Ratio :{:15.3E}{:15.3E}{:15.3E}{:15.3E}\n".format(*(countarr/voltarr).tolist())
return countarr, voltarr, countarr/voltarr
def cent_test(data,phi,dp,sp,pixelsize):
'''
Description:
cent_test really trys hard to find the center of a ring image that
has been disorted because it is on a screen. It uses your favorite
non-derivative minimization algorithm to find where the FWHM of the
annulized ring is smallest. The logic here is that as we go off center
the FWHM gets larger because each TRUE ring annulus is sampled at a
few differet radii. The reason we can't use a trasform produced by
metatron is that the transform itself is heavily dependant on knowing
the correct center.
Inputs:
data - ndarray
The ring data
phi - Float
The angle between the detector normal and the screen normal,
in radians.
dp - Float
The distance from the screen center to the front glass of the
camera lens, in millimeters.
sp - Float
The image distance of the lense, in millimeters.
Output:
A tuple containing the x and y coordinates of the best fit center,
in pixel units.
'''
'a centroid is still a good starting point'
cent = ADE.centroid(data)
if debug: print "initial center: "+str(cent[0])+','+str(cent[1])
'''here is where the actual minimization happens, the values for xtol
and ftol were chosen with speed in mind (also, we don't really need
precision to better than 0.1 pixels).'''
lstsq = spo.fmin_powell(func,np.array([cent[0],cent[1]])\
,args=(data,phi,dp,sp,pixelsize)\
,xtol=0.01,ftol=0.01)
return lstsq
def disc2rings(image,angles):
HDU = pyfits.open(image)[0]
data = np.float32(HDU.data)
FL = HDU.header['FOCALLEN']
print FL
dims = data.shape
cent = ADE.centroid(data)
dist = ADE.dist_gen(data,cent)
ring_stack = np.zeros((1,dims[0],dims[1]),dtype=np.float32)
sangles = np.sort(angles)
sangles *= np.pi/180
for i in range(sangles.size):
r_mid = FL*np.tan(sangles[i])/24e-3
if i == 0: r0_mid = -1*FL*np.tan(sangles[i])/24e-3
else: r0_mid = FL*np.tan(sangles[i-1])/24e-3
try:r2_mid = FL*np.tan(sangles[i+1])/24e-3
except IndexError:r2_mid = r_mid + (r_mid - r0_mid)
r1 = (r_mid + r0_mid)/2
r2 = (r_mid + r2_mid)/2
print r1, r2, r2 - r1
idx = np.where((dist > r1) & (dist <= r2))
temp = np.zeros(dims,dtype=np.float32)
temp[idx] = data[idx]
ring_stack = np.vstack((ring_stack,np.array([temp])))
return ring_stack[1:]
return np.array([rarr,outarr,stdarr])
@jit(argtypes=[int16],restype=float32[:])
def test(num):
l = np.array([],dtype=np.float32)
for i in range(num):
l = np.append(l,i)
# x = np.array(l,dtype=np.float32)
return l
print 'Running test...'
data = pyfits.open('scratch/test.fits')['SB'].data
ddata = np.array(data,dtype=np.float32)
cent = ADE.centroid(ddata)
dist = ADE.dist_gen(ddata,cent)
at1 = time.time()
aderes = ADE.annulize(ddata,300)
at2 = time.time()
nt1 = time.time()
nres = numba_cent(ddata,dist,dist.max(),300)
nt2 = time.time()
print np.mean(nres - aderes,axis=1)
print np.std(nres - aderes,axis=1)
print 'ADE time was: {:4.5f} s\nNumba time was: {:4.5f} s'.format(at2 - at1, nt2-nt1)
