def  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

    t07t13 = time()

    logger.debug('TOTAL consumed time (sec) = %.6f' % (t07t13-t00)\
                +info_ndarr(factor, '\n  calib_epix10ka factor')\
                +info_ndarr(pedest, '\n  calib_epix10ka pedest'))

    timesreturn =res, (t00, t01, t02, t03, t04, t05, t06, t07
, t08, t09, t10, returnt11, rest12, times

 t13)