def get_Wavefront1D_from_profile(self, axis, coordinate):
# swap axis - changed giovanni+manuel
if axis == 1: # fixed X
index = numpy.argmin(numpy.abs(self._electric_field_matrix.x_coord - coordinate))
return GenericWavefront1D(wavelength=self._wavelength,
electric_field_array=ScaledArray(scale=self._electric_field_matrix.y_coord,
np_array=self._electric_field_matrix.z_values[index, :]))
elif axis == 0:
index = numpy.argmin(numpy.abs(self._electric_field_matrix.y_coord - coordinate))
return GenericWavefront1D(wavelength=self._wavelength,
electric_field_array=ScaledArray(scale=self._electric_field_matrix.x_coord,
np_array=self._electric_field_matrix.z_values[:, index]))
def propagate_wavefront(cls,
wavefront,
propagation_distance,
magnification_x=1.0,
magnification_N=1.0):
method = 0
wavenumber = numpy.pi * 2 / wavefront.get_wavelength()
x = wavefront.get_abscissas()
if magnification_N != 1.0:
npoints_exit = int(magnification_N * x.size)
else:
npoints_exit = x.size
detector_abscissas = numpy.linspace(magnification_x * x[0],
magnification_x * x[-1],
npoints_exit)
if method == 0:
# calculate via loop pver detector coordinates
x1 = wavefront.get_abscissas()
x2 = detector_abscissas
fieldComplexAmplitude = numpy.zeros_like(x2, dtype=complex)
for ix, x in enumerate(x2):
r = numpy.sqrt(
numpy.power(x1 - x, 2) +
numpy.power(propagation_distance, 2))
distances_array = numpy.exp(1.j * wavenumber * r)
fieldComplexAmplitude[ix] = (
wavefront.get_complex_amplitude() * distances_array).sum()
elif method == 1:
# calculate via outer product, it spreads over a lot of memory, but it is OK for 1D
x1 = numpy.outer(wavefront.get_abscissas(),
numpy.ones(detector_abscissas.size))
x2 = numpy.outer(numpy.ones(wavefront.size()), detector_abscissas)
r = numpy.sqrt(
numpy.power(x1 - x2, 2) + numpy.power(propagation_distance, 2))
distances_matrix = numpy.exp(1.j * wavenumber * r)
fieldComplexAmplitude = numpy.dot(
wavefront.get_complex_amplitude(), distances_matrix)
wavefront_out = GenericWavefront1D(
wavefront.get_wavelength(),
ScaledArray.initialize_from_steps(
fieldComplexAmplitude, detector_abscissas[0],
detector_abscissas[1] - detector_abscissas[0]))
# added [email protected] 2018-03-23 to conserve energy - TODO: review method!
# wavefront_out.rescale_amplitude( numpy.sqrt(wavefront.get_intensity().sum() /
# wavefront_out.get_intensity().sum()
# / magnification_x))
wavefront_out.rescale_amplitude( (1/numpy.sqrt(1j*wavefront.get_wavelength()*propagation_distance))*(x1[1]-x1[0]) * \
numpy.exp(1j * wavenumber * propagation_distance))
return wavefront_out
def __init__(self, wofry_wavefront=GenericWavefront1D()):
self.wofry_wavefront = wofry_wavefront
wavelength = wofry_wavefront.get_wavelength()
waist0 = fwhm(wofry_wavefront.get_abscissas(),
wofry_wavefront.get_intensity()) * numpy.sqrt(2) / 1.66
print("WAIST", waist0)
super(DummyElement, self).__init__(Lambda=wavelength, Waist0=waist0)
def propagate_wavefront(cls, wavefront, propagation_distance):
fft_scale = numpy.fft.fftfreq(wavefront.size()) / wavefront.delta()
fft = numpy.fft.fft(wavefront.get_complex_amplitude())
fft *= numpy.exp((-1.0j) * numpy.pi * wavefront.get_wavelength() *
propagation_distance * fft_scale**2)
ifft = numpy.fft.ifft(fft)
return GenericWavefront1D(
wavefront.get_wavelength(),
ScaledArray.initialize_from_steps(ifft, wavefront.offset(),
wavefront.delta()))
def _back_propagation_for_size_calculation(self,theta,radiation_flux,photon_energy,
distance=100.0,magnification=0.010000):
"""
Calculate the radiation_flux vs theta at a "distance"
Back propagate to -distance
The result is the size distrubution
:param theta:
:param radiation_flux:
:param photon_energy:
:param distance:
:param magnification:
:return: None; stores results in self._photon_size_distribution
"""
from wofry.propagator.wavefront1D.generic_wavefront import GenericWavefront1D
from wofry.propagator.propagator import PropagationManager, PropagationElements, PropagationParameters
from syned.beamline.beamline_element import BeamlineElement
from syned.beamline.element_coordinates import ElementCoordinates
from wofry.propagator.propagators1D.fresnel_zoom import FresnelZoom1D
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen1D
input_wavefront = GenericWavefront1D().initialize_wavefront_from_arrays(theta*distance,numpy.sqrt(radiation_flux)+0j)
input_wavefront.set_photon_energy(photon_energy)
input_wavefront.set_spherical_wave(radius=distance,complex_amplitude=numpy.sqrt(radiation_flux)+0j)
# input_wavefront.save_h5_file("tmp2.h5","wfr")
optical_element = WOScreen1D()
#
# propagating
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(optical_element=optical_element,
coordinates=ElementCoordinates(p=0.0,q=-distance,
angle_radial=numpy.radians(0.000000),
angle_azimuthal=numpy.radians(0.000000)))
propagation_elements.add_beamline_element(beamline_element)
propagation_parameters = PropagationParameters(wavefront=input_wavefront.duplicate(),propagation_elements = propagation_elements)
propagation_parameters.set_additional_parameters('magnification_x', magnification)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoom1D())
except:
pass
output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,handler_name='FRESNEL_ZOOM_1D')
self._result_photon_size_distribution = {"x":output_wavefront.get_abscissas(),"y":output_wavefront.get_intensity()}
def __init__(self, wofry_wavefront=GenericWavefront1D(), ZOrigin = 0, YOrigin = 0, Theta = 0, units_converter=1e-2):
self.wofry_wavefront=wofry_wavefront
self.Lambda = self.wofry_wavefront._wavelength
self.Name = 'Wofry Wavefront @ %0.2fnm' % (self.Lambda *1e9)
self.ZOrigin = ZOrigin
self.YOrigin = YOrigin
self.ThetaPropagation = Theta
parameters, covariance_matrix_pv = WofryWavefrontSource_1d.gaussian_fit(self.wofry_wavefront.get_intensity(), self.wofry_wavefront.get_abscissas())
self.Waist0 = parameters[3]
self.units_converter = units_converter
def propagate_wavefront(cls, wavefront, propagation_distance):
kernel = numpy.exp(1j * 2 * numpy.pi / wavefront.get_wavelength() *
wavefront.get_abscissas()**2 / 2 /
propagation_distance)
kernel *= numpy.exp(1j * 2 * numpy.pi / wavefront.get_wavelength() *
propagation_distance)
kernel /= 1j * wavefront.get_wavelength() * propagation_distance
tmp = numpy.convolve(wavefront.get_complex_amplitude(),
kernel,
mode='same')
wavefront_out = GenericWavefront1D(
wavefront.get_wavelength(),
ScaledArray.initialize_from_steps(tmp, wavefront.offset(),
wavefront.delta()))
# added [email protected] 2018-03-23 to conserve energy - TODO: review method!
wavefront_out.rescale_amplitude(
numpy.sqrt(wavefront.get_intensity().sum() /
wavefront_out.get_intensity().sum()))
return wavefront_out
TODO: remove this file
"""
from wofry.propagator.wavefront1D.generic_wavefront import GenericWavefront1D
from srxraylib.plot.gol import plot
#
# Import section
#
import numpy
from wofry.propagator.propagator import PropagationManager, PropagationElements, PropagationParameters
from syned.beamline.beamline_element import BeamlineElement
from shadow4.syned.element_coordinates import ElementCoordinates
from wofry.propagator.propagators1D.fresnel_zoom import FresnelZoom1D
input_wavefront = GenericWavefront1D()
input_wavefront = input_wavefront.load_h5_file(
"/users/srio/OASYS1.1/minishadow/minishadow/undulator/tmp.h5", "wfr")
# input_wavefront.rescale_amplitude( 1.0/numpy.sqrt(input_wavefront.get_intensity().max()))
# input_wavefront.set_spherical_wave(radius=100,complex_amplitude=numpy.abs(input_wavefront.get_intensity()) )
# plot(input_wavefront.get_abscissas()*1e6,input_wavefront.get_intensity())
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen1D
optical_element = WOScreen1D()
#
# propagating
#
