//  [python]
def _tab_eta(self):
        """
        Correction factor for MAR.

        \eta(z) \int_{M_{\min}}^{\infty} \dot{M}_{\mathrm{acc}}(z,M) n(z,M) dM
            = \bar{\rho}_m^0 \frac{df_{\mathrm{coll}}}{dt}|_{M_{\min}}

        """

        # Prepare to compute eta
        if not hasattr(self, '_tab_eta_'):

            if self.pf['pop_MAR_corr'] == 'integral':

                _rhs = np.zeros_like(self.halos.tab_z)
                _lhs = np.zeros_like(self.halos.tab_z)
                _tab_eta_ = np.ones_like(self.halos.tab_z)

                for i, z in enumerate(self.halos.tab_z):

                    # eta = rhs / lhs

                    Mmin = self._tab_Mmin[i]

                    # My Eq. 3
                    rhs = self.cosm.rho_cdm_z0 * self.dfcolldt(z)
                    rhs *= (s_per_yr / g_per_msun) * cm_per_mpc**3

                    # Accretion onto all halos (of mass M) at this redshift
                    # This is *matter*, not *baryons*
                    MAR = self._tab_MAR[i]

                    # Find Mmin in self.halos.tab_M
                    j1 = np.argmin(np.abs(Mmin - self.halos.tab_M))
                    if Mmin > self.halos.tab_M[j1]:
                        j1 -= 1

                    integ = self.halos.tab_dndlnm[i] * MAR

                    p0 = simpson(integ[j1-1:], x=np.log(self.halos.tab_M)[j1-1:])
                    p1 = simpson(integ[j1:], x=np.log(self.halos.tab_M)[j1:])
                    p2 = simpson(integ[j1+1:], x=np.log(self.halos.tab_M)[j1+1:])
                    p3 = simpson(integ[j1+2:], x=np.log(self.halos.tab_M)[j1+2:])

                    interp = interp1d(np.log(self.halos.tab_M)[j1-1:j1+3], [p0,p1,p2,p3],
                        kind=self.pf['pop_interp_MAR'])

                    lhs = interp(np.log(Mmin))

                    _lhs[i] = lhs
                    _rhs[i] = rhs

                    _tab_eta_[i] = rhs / lhs

                # Re-shape to be (z, Mh)
                self._tab_eta_ = np.reshape(np.tile(_tab_eta_, self.halos.tab_M.size),
                    (self.halos.tab_z.size, self.halos.tab_M.size))

                ok = np.isfinite(self._tab_eta)
                self._tab_eta[~ok] = 0

            elif self.pf['pop_MAR_corr'] == 'slope':

                # In this case, we have the same shape as _tab_MAR
                self._tab_eta_ = np.ones_like(self.halos.tab_MAR)

                # Compute power-law slope as function of mass at all redshifts.
                # Prevent dramatic deviations from this slope, and instead
                # extrapolate from high-mass end downward.
                logM = np.log(self.halos.tab_M)
                logMAR = np.log(self.halos.tab_MAR)

                alpha = np.diff(logMAR, axis=1) / np.diff(logM)
                self._tab_alpha = alpha

                Ms = self.halos.tab_M.size - 1

                # Figure out where alpha < 0, use slope well above this
                # juncture to extrapolate.
                negative = np.zeros_like(self.halos.tab_z)
                for i in range(self.halos.tab_z.size):
                    huge = np.argwhere(alpha[i,:-5] > 2.)
                    if not np.any(huge):
                        continue

                    ilt0 = int(huge[-1])

                    # Extrapolate
                    _Msafe = min(self.halos.tab_M[ilt0] * 10, 1e13)
                    iM = np.argmin(np.abs(_Msafe - self.halos.tab_M))
                    Msafe = self.halos.tab_M[iM]

                    new = self.halos.tab_MAR[i,iM] \
                        * (self.halos.tab_M / Msafe)**alpha[i,iM]

                    # Only apply extrapolation at low mass
                    self._tab_eta_[i,0:iM] = \
                        new[0:iM] / self.halos.tab_MAR[i,0:iM]


            else:
                self._tab_eta_ = np.ones_like(self.halos.tab_dndm)

        return self._tab_eta_