示例#1
0
    def testStaticElectronDensity(self):
        sigma_x = 3e-6
        sigma_y = 1e-6
        sigma_matrix = SigmaWaist(sigma_x=sigma_x,
                                  sigma_y=sigma_y,
                                  sigma_x_prime=5e-6,
                                  sigma_y_prime=4e-6)
        wavenumber = 1e+11

        density = PhaseSpaceDensity(sigma_matrix, wavenumber)

        x_coordinates = np.linspace(-10e-6, 10e-6, 100)
        y_coordinates = np.linspace(-10e-6, 10e-6, 100)

        prefactor = 1.0 / (2 * np.pi * sigma_matrix.sigma_x()**2 *
                           sigma_matrix.sigma_y()**2 *
                           sigma_matrix.sigma_d()**2)

        #TODO prefactor not correct!
        prefactor = density.staticPart(np.array([0, 0]))

        diff_prefactor = prefactor / density.staticPart(np.array([0, 0]))

        self.assertLess(np.abs(1 - diff_prefactor), 1e-12)

        dy = 0.0
        for dx in x_coordinates:
            dr = np.array([dx, dy])
            diff = density.staticPart(delta_r=dr) / \
                   (prefactor * np.exp(-(dx-dy)**2 * (0.5*wavenumber**2*sigma_matrix.sigma_x_prime()**2)))
            self.assertLess(np.abs(1 - diff), 1e-12)

        dx = 0.0
        for dy in y_coordinates:
            dr = np.array([dx, dy])
            diff = density.staticPart(delta_r=dr) / \
                   (prefactor * np.exp(-(dx-dy)**2 * (0.5*wavenumber**2*sigma_matrix.sigma_y_prime()**2)))
            self.assertLess(np.abs(1 - diff), 1e-12)
示例#2
0
    def testIntegrationPartGaussian(self):
        sigma_x = 3e-6
        sigma_y = 1e-6
        sigma_matrix = SigmaWaist(sigma_x=sigma_x,
                                  sigma_y=sigma_y,
                                  sigma_x_prime=5e-6,
                                  sigma_y_prime=4e-6)
        wavenumber = 1e+11

        density = PhaseSpaceDensity(sigma_matrix, wavenumber)

        x_coordinates = np.linspace(-15e-6, 15e-6, 200)
        y_coordinates = np.linspace(-7e-6, 7e-6, 200)

        for dx in x_coordinates:
            diff = density.integrationPartGaussian(
                delta=0.0, z=0.0, x=dx, y=0.0) - np.exp(
                    -dx**2 / (2 * sigma_matrix.sigma_x()**2))
            self.assertLess(diff, 1e-12)

        for dy in y_coordinates:
            diff = density.integrationPartGaussian(
                delta=0.0, z=0.0, x=0.0, y=dy) - np.exp(
                    -dy**2 / (2 * sigma_matrix.sigma_y()**2))
            self.assertLess(diff, 1e-12)

        rho = np.zeros((x_coordinates.size, y_coordinates.size),
                       dtype=np.complex128)
        for i_x, dx in enumerate(x_coordinates):
            for i_y, dy in enumerate(y_coordinates):
                rho[i_x, i_y] = density.integrationPartGaussian(delta=0.0,
                                                                z=0.0,
                                                                x=dx,
                                                                y=dy)

        norm_1 = np.trapz(np.trapz(np.abs(rho), y_coordinates), x_coordinates)
        self.assertLess(1 - norm_1 / (2 * np.pi * sigma_x * sigma_y), 1e-6)
    def testStaticElectronDensity(self):
        sigma_x = 3e-6
        sigma_y = 1e-6
        sigma_matrix = SigmaWaist(sigma_x=sigma_x,
                                  sigma_y=sigma_y,
                                  sigma_x_prime=5e-6,
                                  sigma_y_prime=4e-6)
        wavenumber = 1e+11

        density = PhaseSpaceDensity(sigma_matrix, wavenumber)

        x_coordinates = np.linspace(-10e-6, 10e-6, 100)
        y_coordinates = np.linspace(-10e-6, 10e-6, 100)

        prefactor = 1.0 / (2 * np.pi * sigma_matrix.sigma_x()**2 * sigma_matrix.sigma_y()**2 * sigma_matrix.sigma_d()**2)

        #TODO prefactor not correct!
        prefactor = density.staticPart(np.array([0,0]))

        diff_prefactor = prefactor / density.staticPart(np.array([0,0]))

        self.assertLess(np.abs(1-diff_prefactor), 1e-12)


        dy = 0.0
        for dx in x_coordinates:
            dr = np.array([dx, dy])
            diff = density.staticPart(delta_r=dr) / \
                   (prefactor * np.exp(-(dx-dy)**2 * (0.5*wavenumber**2*sigma_matrix.sigma_x_prime()**2)))
            self.assertLess(np.abs(1-diff), 1e-12)

        dx = 0.0
        for dy in y_coordinates:
            dr = np.array([dx, dy])
            diff = density.staticPart(delta_r=dr) / \
                   (prefactor * np.exp(-(dx-dy)**2 * (0.5*wavenumber**2*sigma_matrix.sigma_y_prime()**2)))
            self.assertLess(np.abs(1-diff), 1e-12)
示例#4
0
    def testNumerical_f_dzSimgple(self):
        sigma_matrix = SigmaWaist(sigma_x=3e-6,
                                  sigma_y=1e-6,
                                  sigma_x_prime=5e-6,
                                  sigma_y_prime=4e-6)
        wavenumber = 1e+11

        x_coordinates = np.linspace(-10e-6, 10e-6, 15)
        y_coordinates = np.linspace(-10e-6, 10e-6, 10)

        tester = Numerical_f_dz(sigma_matrix, z=0.0, delta=0.0)

        prefactor = 2 * np.pi * sigma_matrix.sigma_x_prime(
        ) * sigma_matrix.sigma_y_prime()

        for x in x_coordinates:
            for y in y_coordinates:
                vec_x_y = np.array([x, y])
                for dx in x_coordinates:
                    for dy in y_coordinates:
                        vec_dr = np.array([dx, dy])

                        result_tester = tester.evaluateAnalytical(
                            k=wavenumber, vec_x_y=vec_x_y, vec_dr=vec_dr)

                        result_analytic = prefactor * \
                                          np.exp(-0.5 * ((x**2/sigma_matrix.sigma_x()**2)+(y**2/sigma_matrix.sigma_y()**2))) * \
                                          np.exp(-0.5 * wavenumber**2 * ((dx**2 * sigma_matrix.sigma_x_prime()**2)+(dy**2 * sigma_matrix.sigma_y_prime()**2)))

                        diff = np.abs(1 - (result_tester / result_analytic))
                        self.assertLess(diff, 1e-12)
    def testNumerical_f_dzSimgple(self):
        sigma_matrix = SigmaWaist(sigma_x=3e-6,
                                            sigma_y=1e-6,
                                            sigma_x_prime=5e-6,
                                            sigma_y_prime=4e-6)
        wavenumber = 1e+11

        x_coordinates = np.linspace(-10e-6, 10e-6, 15)
        y_coordinates = np.linspace(-10e-6, 10e-6, 10)

        tester = Numerical_f_dz(sigma_matrix, z=0.0, delta=0.0)

        prefactor = 2 * np.pi * sigma_matrix.sigma_x_prime() * sigma_matrix.sigma_y_prime()

        for x in x_coordinates:
            for y in y_coordinates:
                vec_x_y = np.array([x, y])
                for dx in x_coordinates:
                    for dy in y_coordinates:
                        vec_dr = np.array([dx, dy])

                        result_tester = tester.evaluateAnalytical(k=wavenumber,
                                                                  vec_x_y=vec_x_y,
                                                                  vec_dr=vec_dr)

                        result_analytic = prefactor * \
                                          np.exp(-0.5 * ((x**2/sigma_matrix.sigma_x()**2)+(y**2/sigma_matrix.sigma_y()**2))) * \
                                          np.exp(-0.5 * wavenumber**2 * ((dx**2 * sigma_matrix.sigma_x_prime()**2)+(dy**2 * sigma_matrix.sigma_y_prime()**2)))

                        diff = np.abs(1 - (result_tester / result_analytic))
                        self.assertLess(diff, 1e-12)
    def testIntegrationPartGaussian(self):
        sigma_x = 3e-6
        sigma_y = 1e-6
        sigma_matrix = SigmaWaist(sigma_x=sigma_x,
                                  sigma_y=sigma_y,
                                  sigma_x_prime=5e-6,
                                  sigma_y_prime=4e-6)
        wavenumber = 1e+11

        density = PhaseSpaceDensity(sigma_matrix, wavenumber)

        x_coordinates = np.linspace(-15e-6, 15e-6, 200)
        y_coordinates = np.linspace(-7e-6, 7e-6, 200)

        for dx in x_coordinates:
            diff = density.integrationPartGaussian(delta=0.0, z=0.0, x=dx, y=0.0) - np.exp(-dx**2/(2*sigma_matrix.sigma_x()**2))
            self.assertLess(diff, 1e-12)

        for dy in y_coordinates:
            diff = density.integrationPartGaussian(delta=0.0, z=0.0, x=0.0, y=dy) - np.exp(-dy**2/(2*sigma_matrix.sigma_y()**2))
            self.assertLess(diff, 1e-12)

        rho = np.zeros((x_coordinates.size, y_coordinates.size), dtype=np.complex128)
        for i_x, dx in enumerate(x_coordinates):
            for i_y, dy in enumerate(y_coordinates):
                rho[i_x, i_y] = density.integrationPartGaussian(delta=0.0, z=0.0, x=dx, y=dy)

        norm_1 = np.trapz(np.trapz(np.abs(rho), y_coordinates), x_coordinates)
        self.assertLess(1-norm_1/(2*np.pi*sigma_x*sigma_y), 1e-6)