예제 #1
0
    def p_electron(self,
                   nq,
                   *,
                   alpha=1.280,
                   zeta=0.045,
                   beta=273 * .9e-4,
                   gamma=0.0141,
                   delta=0.062,
                   drift_field=81):
        """Fraction of detectable NR quanta that become electrons,
        slightly adjusted from Lenardo et al.'s global fit
        (https://arxiv.org/abs/1412.4417).

        Penning quenching is accounted in the photon detection efficiency.
        """
        # TODO: so to make field pos-dependent, override this entire f?
        # could be made easier...

        # prevent /0  # TODO can do better than this
        nq = nq + 1e-9

        # Note: final term depends on nq now, not energy
        # this means beta is different from lenardo et al
        nexni = alpha * drift_field**-zeta * (1 - tf.exp(-beta * nq))
        ni = nq * 1 / (1 + nexni)

        # Fraction of ions NOT participating in recombination
        squiggle = gamma * drift_field**-delta
        fnotr = tf.math.log(1 + ni * squiggle) / (ni * squiggle)

        # Finally, number of electrons produced..
        n_el = ni * fnotr

        return fd.safe_p(n_el / nq)
예제 #2
0
 def p_electron(nq,
                *,
                er_pel_a=15,
                er_pel_b=-27.7,
                er_pel_c=32.5,
                er_pel_e0=5.):
     """Fraction of ER quanta that become electrons
     Simplified form from Jelle's thesis
     """
     # The original model depended on energy, but in flamedisx
     # it has to be a direct function of nq.
     e_kev_sortof = nq * 13.7e-3
     eps = fd.tf_log10(e_kev_sortof / er_pel_e0 + 1e-9)
     qy = (er_pel_a * eps**2 + er_pel_b * eps + er_pel_c)
     return fd.safe_p(qy * 13.7e-3)
예제 #3
0
    def p_electron(nq, W=13.8e-3, mean_nexni=0.135,  q0=1.13, q1=0.47, 
                   gamma_er=0.031 , omega_er=31.): 
        # gamma_er from paper 0.124/4

        F = tf.constant(81.,dtype=fd.float_type())
        
        e_kev = nq * W
        fi = 1. / (1. + mean_nexni)
        ni, nex = nq * fi, nq * (1. - fi)
        wiggle_er = gamma_er * tf.exp(-e_kev / omega_er) * F ** (-0.24) 
        # delta_er and gamma_er are highly correlated
        # F **(-delta_er) set to constant
        r_er = 1. - tf.math.log(1. + ni * wiggle_er) / (ni * wiggle_er)
        r_er /= (1. + tf.exp(-(e_kev - q0) / q1))
        p_el = ni * (1. - r_er) / nq
        
        return fd.safe_p(p_el)