RadiationFactory.py 文件源码

def energy_radiated_near_field(self, trajectory, gamma, x, y, distance):
        # N = trajectory.shape[1]
        N = trajectory.nb_points()
        n_chap = np.array(
            [x - trajectory.x * codata.c, y - trajectory.y * codata.c, distance - trajectory.z * codata.c])
        R = np.sqrt(n_chap[0] ** 2 + n_chap[1] ** 2 + n_chap[2] ** 2)
        n_chap[0, :] /= R
        n_chap[1, :] /= R
        n_chap[2, :] /= R

        E = np.zeros((3,), dtype=np.complex)
        integrand = np.zeros((3, N), dtype=np.complex)

        A1 = (n_chap[1] * trajectory.v_z - n_chap[2] * trajectory.v_y)
        A2 = (-n_chap[0] * trajectory.v_z + n_chap[2] * trajectory.v_x)
        A3 = (n_chap[0] * trajectory.v_y - n_chap[1] * trajectory.v_x)
        Alpha1 = np.exp(
            0. + 1j * self.photon_frequency * (trajectory.t + R/codata.c))
        Alpha2 = codata.c / (gamma ** 2 * R)
        integrand[0] -= ((n_chap[1] * A3 - n_chap[2] * A2) * self.photon_frequency* 1j
                         + Alpha2 * (n_chap[0] - trajectory.v_x)
                         ) * Alpha1
        integrand[1] -= ((-n_chap[0] * A3 + n_chap[2] * A1) * self.photon_frequency * 1j
                         + Alpha2 * (n_chap[1] - trajectory.v_y)
                         ) * Alpha1
        integrand[2] -= ((n_chap[0] * A2 - n_chap[1] * A1) * self.photon_frequency * 1j
                         + Alpha2 * (n_chap[2] - trajectory.v_z)
                         ) * Alpha1
        for k in range(3):
            E[k] = np.trapz(integrand[k], trajectory.t)
            #E[k] = integrate.simps(integrand[k], trajectory.t)

        terme_bord = np.full((3), 0. + 1j * 0., dtype=np.complex)
        Alpha_1 = (1.0 / (1.0 - n_chap[0][-1] * trajectory.v_x[-1]
                         - n_chap[1][-1] * trajectory.v_y[-1] - n_chap[2][-1] * trajectory.v_z[-1]))
        Alpha_0 = (1.0 / (1.0 - n_chap[0][0] * trajectory.v_x[0]
                          - n_chap[1][0] * trajectory.v_y[0] - n_chap[2][0] * trajectory.v_z[0]))

        terme_bord += ((n_chap[1][-1] * A3[-1] - n_chap[2][-1] * A2[-1]) * Alpha_1*
                       np.exp(1j * self.photon_frequency * (trajectory.t[-1] +R[-1]/codata.c) ))
        terme_bord -= ((n_chap[1][0] * A3[0] - n_chap[2][0] * A2[0]) * Alpha_0*
                       np.exp(1j * self.photon_frequency * (trajectory.t[0] + R[0]/codata.c)))
        # E += terme_bord
        return E