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 metatron(data, center, phi, dp, sp, pixelsize):
'''
Description:
metatron uses the relevant physical parameters from the laser bench
setup and computes a transform that goes from the detector plane
(what we measure) to the screen plane (what we want to measure).
It is a helper function only intended to be called by fat_angel.
Inputs:
data - ndarray
The data to be transformed. This is only used to make
sure the transform has the right dimensions.
center - Tuple
The center of the ring in pixels
phi - Float
The angle between the detector normal and the screen normal
in radians.
dp - Float
The distance from the center of the screen to the front
glass of the camera lens, in millimeters.
sp - Float
The image distance given the object distance and lens focal
length, in millimeters.
pixelsize - Float
The size of the detector pixels, in microns.
Output:
The output is a ndarray that contains the real physical distance of
each pixel from the center of the ring at the SCREEN PLANE. In other
words, all the pixels of the same value correspond to a perfect
circle on the screen.
'''
'''first get the distances in the detector plane'''
r = ADE.dist_gen(data,center)*pixelsize
alpha = ADE.angle_gen(data,center)
'''now transform. See my notebook pages 101-103 for an explanation'''
# den = sp**2*(np.cos(2*alpha) - 2*np.cos(alpha)**2*np.cos(2*phi))\
# + 4*r**2 - 3*sp**2
# bignum = 2*dp*r*(\
# (sp-r)*(sp+r)\
# *(3 + np.cos(2*phi) - 2*np.cos(2*alpha)*np.sin(phi)**2)\
# )**0.5
# t_dist = (4*dp*r**2*np.cos(alpha)*np.sin(phi) - bignum)/den
den = sp*(np.cos(alpha)**2*np.cos(phi)**2 + np.sin(alpha)**2)**0.5 \
+ r*np.cos(alpha)*np.sin(phi)
t_dist = dp*r/den
return t_dist
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 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:]
@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)
