def test_spherical_wave(self, do_plot=do_plot): # # plane wave # print("# ") print("# Tests for a 1D spherical wave ") print("# ") wavelength = 1.24e-10 wavefront_length_x = 400e-6 npixels_x = 1024 wavefront_x = numpy.linspace(-0.5 * wavefront_length_x, 0.5 * wavefront_length_x, npixels_x) wf1 = GenericWavefront1D.initialize_wavefront_from_steps( x_start=wavefront_x[0], x_step=numpy.abs(wavefront_x[1] - wavefront_x[0]), number_of_points=npixels_x, wavelength=wavelength) wf2 = GenericWavefront1D.initialize_wavefront_from_steps( x_start=wavefront_x[0], x_step=numpy.abs(wavefront_x[1] - wavefront_x[0]), number_of_points=npixels_x, wavelength=wavelength) # an spherical wavefront is obtained 1) by creation, 2) focusing a planewave wf1.set_spherical_wave(radius=-5.0, complex_amplitude=3 + 0j) wf1.clip(-50e-6, 10e-6) wf2.set_plane_wave_from_complex_amplitude(3 + 0j) ideal_lens = WOIdealLens1D("test", 5.0) ideal_lens.applyOpticalElement(wf2) wf2.clip(-50e-6, 10e-6) if do_plot: from srxraylib.plot.gol import plot plot(wf1.get_abscissas(), wf1.get_phase(), title="Phase of spherical wavefront", show=0) plot(wf2.get_abscissas(), wf2.get_phase(), title="Phase of focused plane wavefront", show=0) plot(wf1.get_abscissas(), wf1.get_phase(from_minimum_intensity=0.1), title="Phase of spherical wavefront (for intensity > 0.1)", show=0) plot( wf2.get_abscissas(), wf2.get_phase(from_minimum_intensity=0.1), title="Phase of focused plane wavefront (for intensity > 0.1)", show=1) numpy.testing.assert_almost_equal(wf1.get_phase(), wf2.get_phase(), 5)
def test_initializers(self, do_plot=do_plot): print("# ") print("# Tests for initializars (1D) ") print("# ") x = numpy.linspace(-100, 100, 50) y = numpy.abs(x)**1.5 + 1j * numpy.abs(x)**1.8 wf0 = GenericWavefront1D.initialize_wavefront_from_steps( x[0], numpy.abs(x[1] - x[0]), y.size) wf0.set_complex_amplitude(y) wf1 = GenericWavefront1D.initialize_wavefront_from_range( x[0], x[-1], y.size) wf1.set_complex_amplitude(y) wf2 = GenericWavefront1D.initialize_wavefront_from_arrays(x, y) print("wavefront sizes: ", wf1.size(), wf1.size(), wf2.size()) if do_plot: from srxraylib.plot.gol import plot plot(wf0.get_abscissas(), wf0.get_intensity(), title="initialize_wavefront_from_steps", show=0) plot(wf1.get_abscissas(), wf1.get_intensity(), title="initialize_wavefront_from_range", show=0) plot(wf2.get_abscissas(), wf2.get_intensity(), title="initialize_wavefront_from_arrays", show=1) numpy.testing.assert_almost_equal(wf0.get_intensity(), numpy.abs(y)**2, 5) numpy.testing.assert_almost_equal(wf1.get_intensity(), numpy.abs(y)**2, 5) numpy.testing.assert_almost_equal(x, wf1.get_abscissas(), 11) numpy.testing.assert_almost_equal(x, wf2.get_abscissas(), 11)
def test_interpolator(self, do_plot=do_plot): # # interpolator # print("# ") print("# Tests for 1D interpolator ") print("# ") x = numpy.linspace(-10, 10, 100) sigma = 3.0 Z = numpy.exp(-1.0 * x**2 / 2 / sigma**2) print("shape of Z", Z.shape) wf = GenericWavefront1D.initialize_wavefront_from_steps( x[0], numpy.abs(x[1] - x[0]), number_of_points=100) print("wf shape: ", wf.size()) wf.set_complex_amplitude(Z) x1 = 3.2 z1 = numpy.exp(x1**2 / -2 / sigma**2) print("complex ampl at (%g): %g+%gi (exact=%g)" % (x1, wf.get_interpolated_complex_amplitude(x1).real, wf.get_interpolated_complex_amplitude(x1).imag, z1)) self.assertAlmostEqual( wf.get_interpolated_complex_amplitude(x1).real, z1, 4) print("intensity at (%g): %g (exact=%g)" % (x1, wf.get_interpolated_intensity(x1), z1**2)) self.assertAlmostEqual(wf.get_interpolated_intensity(x1), z1**2, 4) if do_plot: from srxraylib.plot.gol import plot plot(wf.get_abscissas(), wf.get_intensity(), title="Original", show=1) xx = wf.get_abscissas() yy = wf.get_interpolated_intensities(wf.get_abscissas() - 1e-5) plot(xx, yy, title="interpolated on same grid", show=1)
def test_gaussianhermite_mode(self, do_plot=do_plot): # # plane wave # print("# ") print("# Tests for a 1D Gaussian Hermite mode ") print("# ") wavelength = 1.24e-10 # 2D sigma_x = 100e-6 mode_x = 0 npixels_x = 100 wavefront_length_x = 10 * sigma_x x = numpy.linspace(-0.5 * wavefront_length_x, 0.5 * wavefront_length_x, npixels_x) wf1 = GenericWavefront1D.initialize_wavefront_from_steps( x_start=x[0], x_step=numpy.abs(x[1] - x[0]), number_of_points=npixels_x, wavelength=wavelength) wf1.set_gaussian_hermite_mode(sigma_x, mode_x, amplitude=1.0) numpy.testing.assert_almost_equal(wf1.get_amplitude()[30], 23.9419082194, 5) if do_plot: from srxraylib.plot.gol import plot plot(wf1.get_abscissas(), wf1.get_amplitude(), title="Amplitude of gaussianhermite", show=0)
def test_plane_wave(self, do_plot=do_plot): # # plane wave # print("# ") print("# Tests for a 1D plane wave ") print("# ") wavelength = 1.24e-10 wavefront_length_x = 400e-6 npixels_x = 1024 wavefront_x = numpy.linspace(-0.5 * wavefront_length_x, 0.5 * wavefront_length_x, npixels_x) wavefront = GenericWavefront1D.initialize_wavefront_from_steps( x_start=wavefront_x[0], x_step=numpy.abs(wavefront_x[1] - wavefront_x[0]), number_of_points=npixels_x, wavelength=wavelength) numpy.testing.assert_almost_equal(wavefront_x, wavefront.get_abscissas(), 9) # possible modifications wavefront.set_plane_wave_from_amplitude_and_phase(5.0, numpy.pi / 2) numpy.testing.assert_almost_equal(wavefront.get_intensity(), 25, 5) wavefront.set_plane_wave_from_complex_amplitude(2.0 + 3j) numpy.testing.assert_almost_equal(wavefront.get_intensity(), 13, 5) phase_before = wavefront.get_phase() wavefront.add_phase_shift(numpy.pi / 2) phase_after = wavefront.get_phase() numpy.testing.assert_almost_equal(phase_before + numpy.pi / 2, phase_after, 5) intensity_before = wavefront.get_intensity() wavefront.rescale_amplitude(10.0) intensity_after = wavefront.get_intensity() numpy.testing.assert_almost_equal(intensity_before * 100, intensity_after, 5) # interpolation wavefront.set_plane_wave_from_complex_amplitude(2.0 + 3j) test_value1 = wavefront.get_interpolated_complex_amplitude(0.01) self.assertAlmostEqual((2.0 + 3j).real, test_value1.real, 5) self.assertAlmostEqual((2.0 + 3j).imag, test_value1.imag, 5) if do_plot: from srxraylib.plot.gol import plot plot(wavefront.get_abscissas(), wavefront.get_intensity(), title="Intensity (plane wave)", show=0) plot(wavefront.get_abscissas(), wavefront.get_phase(), title="Phase (plane wave)", show=1)
def get_wavefront(self): # # If making changes here, don't forget to do changes in to_python_code() as well... # if self._initialize_from == 0: if self._dimension == 1: wf = GenericWavefront1D.initialize_wavefront_from_range( x_min=self._range_from_h, x_max=self._range_to_h, number_of_points=self._number_of_points_h) elif self._dimension == 2: wf = GenericWavefront2D.initialize_wavefront_from_range( x_min=self._range_from_h, x_max=self._range_to_h, y_min=self._range_from_v, y_max=self._range_to_v, number_of_points=(self._number_of_points_h, self._number_of_points_v)) else: if self._dimension == 1: wf = GenericWavefront1D.initialize_wavefront_from_steps( x_start=self._steps_start_h, x_step=self._steps_step_h, number_of_points=self._number_of_points_h) elif self._dimension == 2: wf = GenericWavefront2D.initialize_wavefront_from_steps( x_start=self._steps_start_h, x_step=self._steps_step_h, y_start=self._steps_start_v, y_step=self._steps_step_v, number_of_points=(self._number_of_points_h, self._number_of_points_v)) if self._units == 0: wf.set_photon_energy(self._energy) else: wf.set_wavelength(self._wavelength) if self._kind_of_wave == 0: # plane if self._dimension == 1: if self._initialize_amplitude == 0: wf.set_plane_wave_from_complex_amplitude( complex_amplitude=complex(self._complex_amplitude_re, self._complex_amplitude_im), inclination=self._inclination) else: wf.set_plane_wave_from_amplitude_and_phase( amplitude=self._amplitude, phase=self._phase, inclination=self._inclination) elif self._dimension == 2: if self._initialize_amplitude == 0: wf.set_plane_wave_from_complex_amplitude( complex_amplitude=complex(self._complex_amplitude_re, self._complex_amplitude_im)) else: wf.set_plane_wave_from_amplitude_and_phase( amplitude=self._amplitude, phase=self._phase) elif self._kind_of_wave == 1: # spheric if self._dimension == 1: wf.set_spherical_wave(radius=self._radius, center=self._center, complex_amplitude=complex( self._complex_amplitude_re, self._complex_amplitude_im)) elif self._dimension == 2: wf.set_spherical_wave(radius=self._radius, complex_amplitude=complex( self._complex_amplitude_re, self._complex_amplitude_im)) elif self._kind_of_wave == 2: # gaussian if self._dimension == 1: wf.set_gaussian(sigma_x=self._sigma_h, amplitude=self._amplitude, shift=self._gaussian_shift) elif self._dimension == 2: wf.set_gaussian(sigma_x=self._sigma_h, sigma_y=self._sigma_v, amplitude=self._amplitude) elif self._kind_of_wave == 3: # g.s.m. if self._dimension == 1: wf.set_gaussian_hermite_mode( sigma_x=self._sigma_h, mode_x=self._n_h, amplitude=self._amplitude, beta=self._beta_h, shift=self._gaussian_shift, ) elif self._dimension == 2: wf.set_gaussian_hermite_mode( sigma_x=self._sigma_h, sigma_y=self._sigma_v, amplitude=self._amplitude, nx=self._n_h, ny=self._n_v, betax=self._beta_h, betay=self._beta_v, ) if self._add_random_phase: wf.add_phase_shifts(2 * numpy.pi * numpy.random.random(wf.size())) return wf