def calib_epix10ka_any(det, evt, cmpars=None, **kwa): # cmpars=(7,2,10,10), mbits=None, mask=None, nda_raw=None
"""
Returns calibrated epix10ka data
- gets constants
- gets raw data
- evaluates (code - pedestal - offset)
- applys common mode correction if turned on
- apply gain factor
Parameters
- det (psana.Detector) - Detector object
- evt (psana.Event) - Event object
- cmpars (tuple) - common mode parameters
= None - use pars from calib directory
= cmpars=(<alg>, <mode>, <maxcorr>)
alg is not used
mode =0-correction is not applied, =1-in rows, =2-in cols-WORKS THE BEST
i.e: cmpars=(7,0,100) or (7,2,100)
- **kwa - used here and passed to det.mask_comb
- nda_raw - substitute for det.raw(evt)
- mbits - deprecated parameter of the det.mask_comb(...), det.mask_v2 is used by default
- mask - user defined mask passed as optional parameter
"""
t00 = time()
logger.debug('In calib_epix10ka_any')
nda_raw = kwa.get('nda_raw', None)
raw = det.raw(evt) if nda_raw is None else nda_raw # shape:(352, 384) or suppose to be later (<nsegs>, 352, 384) dtype:uint16
if raw is None: return None
t01 = time()
cmp = det.common_mode(evt) if cmpars is None else cmpars
gain = det.gain(evt) # - 4d gains (7, <nsegs>, 352, 384)
peds = det.pedestals(evt) # - 4d pedestals
if gain is None: return None # gain = np.ones_like(peds) # - 4d gains
if peds is None: return None # peds = np.zeros_like(peds) # - 4d gains
t02 = time()
store = ue.dic_store.get(det.name, None)
if store is None:
logger.debug('create store for detector %s' % det.name)
store = ue.dic_store[det.name] = ue.Storage()
# do ONCE this initialization
logger.debug(info_ndarr(raw, '\n raw ')\
+info_ndarr(gain, '\n gain')\
+info_ndarr(peds, '\n peds'))
store.gfac = divide_protected(np.ones_like(gain), gain)
store.arr1 = np.ones_like(raw, dtype=np.int8)
logger.debug(info_ndarr(store.gfac, '\n gfac '))
# 'FH','FM','FL','AHL-H','AML-M','AHL-L','AML-L'
#store.gf4 = np.ones_like(raw, dtype=np.int32) * 0.25 # 0.3333 # M - perefierial
#store.gf6 = np.ones_like(raw, dtype=np.int32) * 1 # L - center
t03 = time()
gfac = store.gfac
gmaps = ue.gain_maps_epix10ka_any(det, raw)
if gmaps is None: return None
gr0, gr1, gr2, gr3, gr4, gr5, gr6 = gmaps
factor = np.select(gmaps,\
(gfac[0,:], gfac[1,:], gfac[2,:], gfac[3,:],\
gfac[4,:], gfac[5,:], gfac[6,:]), default=1) # 2msec
#==================== TEST RETURN MAP OF PIXEL GAIN MODES
#return map_pixel_gain_mode1(gmaps)
#====================
pedest = np.select(gmaps,\
(peds[0,:], peds[1,:], peds[2,:], peds[3,:],\
peds[4,:], peds[5,:], peds[6,:]), default=0)
t04 = time()
store.counter += 1
if not store.counter%100:
logger.debug(ue.info_gain_mode_arrays1(gmaps)\
+'\n'+ue.info_pixel_gain_mode_statistics1(gmaps))
arrf = np.array(raw & ue.M14, dtype=np.float32) - pedest
t05 = time()
if store.mask is None:
store.mask = det.mask_total(evt, **kwa)
mask = store.mask
t06 = time()
logger.debug('common-mode correction pars cmp: %s' % str(cmp))
if cmp is not None:
mode, cormax = int(cmp[1]), cmp[2]
npixmin = cmp[3] if len(cmp)>3 else 10
if mode>0:
t07 = t0_sec_cm = time()
#t2_sec_cm = time()
arr1 = store.arr1 # np.ones_like(mask, dtype=np.uint8)
grhm = np.select((gr0, gr1, gr3, gr4), (arr1, arr1, arr1, arr1), default=0)
gmask = np.bitwise_and(grhm, mask) if mask is not None else grhm
if gmask.ndim == 2: gmask.shape = (1,gmask.shape[-2],gmask.shape[-1])
#logger.debug(info_ndarr(arr1, '\n arr1'))
#logger.debug(info_ndarr(grhm, 'XXXX grhm'))
logger.debug(info_ndarr(gmask, 'gmask')\
+ '\n per panel statistics of cm-corrected pixels: %s'%
str(np.sum(gmask, axis=(1,2), dtype=np.uint32) if gmask is not None else None))
#logger.debug('common-mode mask massaging (sec) = %.6f' % (time()-t2_sec_cm)) # 5msec
t08 = time()
#sh = (nsegs, 352, 384)
hrows = 176 # int(352/2)
for s in range(arrf.shape[0]):
t09 = time()
if mode & 4: # in banks: (352/2,384/8)=(176,48) pixels
ue.common_mode_2d_hsplit_nbanks(arrf[s,:hrows,:], mask=gmask[s,:hrows,:], nbanks=8, cormax=cormax, npix_min=npixmin)
ue.common_mode_2d_hsplit_nbanks(arrf[s,hrows:,:], mask=gmask[s,hrows:,:], nbanks=8, cormax=cormax, npix_min=npixmin)
t10 = time()
if mode & 1: # in rows per bank: 384/8 = 48 pixels # 190ms
ue.common_mode_rows_hsplit_nbanks(arrf[s,], mask=gmask[s,], nbanks=8, cormax=cormax, npix_min=npixmin)
t11 = time()
if mode & 2: # in cols per bank: 352/2 = 176 pixels # 150ms
ue.common_mode_cols(arrf[s,:hrows,:], mask=gmask[s,:hrows,:], cormax=cormax, npix_min=npixmin)
ue.common_mode_cols(arrf[s,hrows:,:], mask=gmask[s,hrows:,:], cormax=cormax, npix_min=npixmin)
logger.debug('TIME common-mode correction = %.6f sec for cmp=%s' % (time()-t0_sec_cm, str(cmp)))
t12 = time()
res = arrf * factor if mask is None else arrf * factor * mask # gain correction
t13 = time()
logger.debug('TOTAL consumed time (sec) = %.6f' % (t13-t00)\
+info_ndarr(factor, '\n calib_epix10ka factor')\
+info_ndarr(pedest, '\n calib_epix10ka pedest'))
return res, (t00, t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13)
