def propagate_wavefront_scaling_new(wavefront,
distance,
handler_name=Fresnel1D.HANDLER_NAME,
zoom=0.005,
using_radius=None):
wavefront_inside = wavefront.duplicate()
#
# if R of curvature to be remove is not defined, guess it
#
if using_radius is None:
plot_scan = True
if plot_scan:
radii, fig_of_mer = wavefront_inside.scan_wavefront_curvature(
rmin=-1000, rmax=1000, rpoints=100)
plot(radii, fig_of_mer)
using_radius = wavefront_inside.guess_wavefront_curvature(rmin=-1000,
rmax=1000,
rpoints=100)
#
# propagate flattened wavefront to a new distance: distance/magnification
#
slit = WOSlit1D(name="PIRRONE2",
boundary_shape=Rectangle(
-0.00005,
0.00005,
-0.00005,
0.00005,
))
coordinates = ElementCoordinates(p=0.0, q=0.0)
propagation_elements = PropagationElements()
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=slit, coordinates=coordinates))
parameters = PropagationParameters(
wavefront=wavefront_inside, propagation_elements=propagation_elements)
parameters.set_additional_parameters("shift_half_pixel", 1)
parameters.set_additional_parameters("magnification_x", zoom)
output_wf_1 = propagator.do_propagation(propagation_parameters=parameters,
handler_name=handler_name)
screen = WOScreen(name="PIRRONE")
coordinates = ElementCoordinates(p=0.0, q=distance)
propagation_elements = PropagationElements()
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=screen, coordinates=coordinates))
parameters = PropagationParameters(
wavefront=output_wf_1, propagation_elements=propagation_elements)
parameters.set_additional_parameters("shift_half_pixel", 1)
parameters.set_additional_parameters("magnification_x", zoom)
parameters.set_additional_parameters("radius", using_radius)
output_wf_2 = propagator.do_propagation(propagation_parameters=parameters,
handler_name=handler_name)
return output_wf_2
def set_rectangle(self,
width=3e-3,
height=4e-3,
center_x=0.0,
center_y=0.0):
self._boundary_shape = Rectangle(-0.5 * width + center_x,
0.5 * width + center_x,
-0.5 * height + center_y,
0.5 * height + center_y)
def Screen_v(input_wavefront, fresnel=True):
boundary_shape = Rectangle(x_left=-0.5,
x_right=0.5,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit1D
optical_element = WOSlit1D(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.050000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('magnification_x',
0.000020)
#
propagator = PropagationManager.Instance()
try:
if fresnel:
propagator.add_propagator(FresnelZoom1D())
else:
propagator.add_propagator(Integral1D())
except:
pass
if fresnel:
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_1D')
else:
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='INTEGRAL_1D')
return output_wavefront
def __init__(self,
name = "Undefined",
optical_element_displacement = None,
orientation_of_reflection_plane = Orientation.UP,
invert_tangent_component = False,
d_spacing = 0.0,
psi_0r = 0.0,
psi_0i = 0.0,
psi_hr = 0.0,
psi_hi = 0.0,
psi_hbr = 0.0,
psi_hbi = 0.0,
asymmetry_angle = 0.0,
thickness = 0.0,
diffraction_geometry = DiffractionGeometry.BRAGG,
incident_angle = 0.0
):
SRWOpticalElement.__init__(self, optical_element_displacement=optical_element_displacement)
Crystal.__init__(self,
name,
surface_shape=Plane(),
boundary_shape=Rectangle(x_left=0.0,
x_right=0.0,
y_bottom=0.0,
y_top=0.0),
material="Unknown",
diffraction_geometry=diffraction_geometry,
asymmetry_angle = asymmetry_angle,
thickness = thickness
)
self.orientation_of_reflection_plane = orientation_of_reflection_plane
self.invert_tangent_component = invert_tangent_component
self.d_spacing = d_spacing
self.psi_0r = psi_0r
self.psi_0i = psi_0i
self.psi_hr = psi_hr
self.psi_hi = psi_hi
self.psi_hbr = psi_hbr
self.psi_hbi = psi_hbi
self.asymmetry_angle = asymmetry_angle
self.thickness = thickness
self.diffraction_geometry = diffraction_geometry
self.grazing_angle = incident_angle
if diffraction_geometry == DiffractionGeometry.LAUE: raise NotImplementedError("Laue Geometry is not yet supported")
def get_optical_element(self):
if self.shape == 0:
boundary_shape = Rectangle(
x_left=-0.5 * self.width + self.horizontal_shift,
x_right=0.5 * self.width + self.horizontal_shift,
y_bottom=-0.5 * self.height + self.vertical_shift,
y_top=0.5 * self.height + self.vertical_shift)
elif self.shape == 1:
boundary_shape = Ellipse(
a_axis_min=-self.radius + self.horizontal_shift,
a_axis_max=self.radius + self.horizontal_shift,
b_axis_min=-self.radius + self.vertical_shift,
b_axis_max=self.radius + self.vertical_shift)
return self.get_srw_object(boundary_shape=boundary_shape)
def __init__(self,
name="Undefined",
optical_element_displacement=None,
tangential_size=1.2,
sagittal_size=0.01,
vertical_position_of_mirror_center=0.0,
horizontal_position_of_mirror_center=0.0,
grazing_angle=0.003,
orientation_of_reflection_plane=Orientation.UP,
invert_tangent_component=False,
add_acceptance_slit=False,
height_profile_data_file="mirror.dat",
height_profile_data_file_dimension=1,
height_amplification_coefficient=1.0):
SRWOpticalElementWithAcceptanceSlit.__init__(
self,
optical_element_displacement=optical_element_displacement,
tangential_size=tangential_size,
sagittal_size=sagittal_size,
grazing_angle=grazing_angle,
vertical_position_of_mirror_center=
vertical_position_of_mirror_center,
horizontal_position_of_mirror_center=
horizontal_position_of_mirror_center,
orientation_of_reflection_plane=orientation_of_reflection_plane,
invert_tangent_component=invert_tangent_component,
add_acceptance_slit=add_acceptance_slit)
Mirror.__init__(self,
name=name,
boundary_shape=Rectangle(
x_left=horizontal_position_of_mirror_center -
0.5 * sagittal_size,
x_right=horizontal_position_of_mirror_center +
0.5 * sagittal_size,
y_bottom=vertical_position_of_mirror_center -
0.5 * tangential_size,
y_top=vertical_position_of_mirror_center +
0.5 * tangential_size),
surface_shape=self.get_shape())
self.height_profile_data_file = height_profile_data_file
self.height_profile_data_file_dimension = height_profile_data_file_dimension
self.height_amplification_coefficient = height_amplification_coefficient
def Aperture_40m(input_wavefront):
# from syned.beamline.shape import Rectangle
# note that wavefront 1d will be clipped using the first two coordinates!
boundary_shape = Rectangle(x_left=-2.5e-05,
x_right=2.5e-05,
y_bottom=-2.5e-05,
y_top=2.5e-05)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit1D
optical_element = WOSlit1D(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=11.700000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('magnification_x',
0.010000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoom1D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_1D')
return output_wavefront
def get_boundary_shape(self):
if self.plane_of_focusing == PlaneOfFocusing.BOTH:
return Ellipse(a_axis_min=self.horizontal_center_coordinate -
self.horizontal_aperture_size / 2,
a_axis_max=self.horizontal_center_coordinate +
self.horizontal_aperture_size / 2,
b_axis_min=self.vertical_center_coordinate +
self.vertical_aperture_size / 2,
b_axis_max=self.vertical_center_coordinate +
self.vertical_aperture_size / 2)
else:
return Rectangle(x_left=self.horizontal_center_coordinate -
self.horizontal_aperture_size / 2,
x_right=self.horizontal_center_coordinate +
self.horizontal_aperture_size / 2,
y_bottom=self.vertical_center_coordinate +
self.vertical_aperture_size / 2,
y_top=self.vertical_center_coordinate +
self.vertical_aperture_size / 2)
def fromSRWLOpt(self, srwlopt=SRWLOptA()):
if not isinstance(srwlopt, SRWLOptA):
raise ValueError("SRW object is not a SRWLOptA object")
if not srwlopt.ap_or_ob == self.get_srw_ap_or_ob():
raise ValueError("SRW object not compatible")
if srwlopt.shape == 'r':
boundary_shape = Rectangle(x_left=srwlopt.x - 0.5 * srwlopt.Dx,
x_right=srwlopt.x + 0.5 * srwlopt.Dx,
y_bottom=srwlopt.y - 0.5 * srwlopt.Dy,
y_top=srwlopt.y + 0.5 * srwlopt.Dy)
elif srwlopt.shape == 'c':
boundary_shape = Ellipse(min_ax_left=srwlopt.x - 0.5 * srwlopt.Dx,
min_ax_right=srwlopt.x + 0.5 * srwlopt.Dx,
maj_ax_bottom=srwlopt.y -
0.5 * srwlopt.Dy,
maj_ax_top=srwlopt.y + 0.5 * srwlopt.Dy)
self.__init__(boundary_shape=boundary_shape)
def ML_size(input_wavefront):
# note that wavefront 1d will be clipped using the first two coordinates!
boundary_shape = Rectangle(x_left=-0.0018849,
x_right=0.0018849,
y_bottom=-0.0018849,
y_top=0.0018849)
optical_element = WOSlit1D(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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',
1.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoom1D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_1D')
return output_wavefront
def propagate_wavefront(wavefront,
distance,
handler_name=Fresnel1D.HANDLER_NAME,
zoom=0.005):
wavefront_inside = wavefront.duplicate()
slit = WOSlit1D(name="PIRRONE2",
boundary_shape=Rectangle(
-0.00005,
0.00005,
-0.00005,
0.00005,
))
coordinates = ElementCoordinates(p=0.0, q=0.0)
propagation_elements = PropagationElements()
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=slit, coordinates=coordinates))
parameters = PropagationParameters(
wavefront=wavefront_inside, propagation_elements=propagation_elements)
parameters.set_additional_parameters("shift_half_pixel", 1)
parameters.set_additional_parameters("magnification_x", zoom)
output_wf_1 = propagator.do_propagation(propagation_parameters=parameters,
handler_name=handler_name)
screen = WOScreen(name="PIRRONE")
coordinates = ElementCoordinates(p=0.0, q=distance)
propagation_elements = PropagationElements()
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=screen, coordinates=coordinates))
parameters = PropagationParameters(
wavefront=output_wf_1, propagation_elements=propagation_elements)
parameters.set_additional_parameters("shift_half_pixel", 1)
parameters.set_additional_parameters("magnification_x", zoom)
output_wf_2 = propagator.do_propagation(propagation_parameters=parameters,
handler_name=handler_name)
return output_wf_2
def Aperture_40m_V_open(input_wavefront):
boundary_shape = Rectangle(x_left=-0.5,
x_right=0.5,
y_bottom=-0.5,
y_top=0.5)
optical_element = WOSlit1D(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=11.700000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('magnification_x',
0.640000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoom1D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_1D')
return output_wavefront
def test_propagate_2D_fraunhofer_phase(self,do_plot=do_plot,aperture_type='square',
aperture_diameter=40e-6,
pixelsize_x=1e-6,pixelsize_y=1e-6,npixels_x=1024,npixels_y=1024,
propagation_distance=30.0,wavelength=1.24e-10):
print("\n# ")
print("# far field 2D (fraunhofer) diffraction from a square aperture ")
print("# ")
method = "fraunhofer"
print("Fraunhoffer diffraction valid for distances > > a^2/lambda = %f m"%((aperture_diameter/2)**2/wavelength))
wf = GenericWavefront2D.initialize_wavefront_from_range(x_min=-pixelsize_x*npixels_x/2,x_max=pixelsize_x*npixels_x/2,
y_min=-pixelsize_y*npixels_y/2,y_max=pixelsize_y*npixels_y/2,
number_of_points=(npixels_x,npixels_y),wavelength=wavelength)
wf.set_plane_wave_from_complex_amplitude((1.0+0j))
propagation_elements = PropagationElements()
slit = None
if aperture_type == 'square':
slit = WOSlit(boundary_shape=Rectangle(-aperture_diameter/2, aperture_diameter/2, -aperture_diameter/2, aperture_diameter/2))
elif aperture_type == 'gaussian':
slit = WOGaussianSlit(boundary_shape=Rectangle(-aperture_diameter/2, aperture_diameter/2, -aperture_diameter/2, aperture_diameter/2))
else:
raise Exception("Not implemented! (accepted: circle, square, gaussian)")
propagation_elements.add_beamline_element(BeamlineElement(optical_element=slit,
coordinates=ElementCoordinates(p=0, q=propagation_distance)))
propagator = PropagationManager.Instance()
propagation_parameters = PropagationParameters(wavefront=wf,
propagation_elements=propagation_elements)
propagation_parameters.set_additional_parameters("shift_half_pixel", True)
wf1_fraunhofer = propagator.do_propagation(propagation_parameters, Fraunhofer2D.HANDLER_NAME)
propagation_parameters.set_additional_parameters("shift_half_pixel", True)
propagation_parameters.set_additional_parameters("magnification_x", 1.5)
propagation_parameters.set_additional_parameters("magnification_y", 2.5)
wf1_zoom = propagator.do_propagation(propagation_parameters, FresnelZoomXY2D.HANDLER_NAME)
if aperture_type == 'circle':
wf.clip_circle(aperture_diameter/2)
elif aperture_type == 'square':
wf.clip_square(-aperture_diameter/2, aperture_diameter/2,-aperture_diameter/2, aperture_diameter/2)
elif aperture_type == 'gaussian':
X = wf.get_mesh_x()
Y = wf.get_mesh_y()
window = numpy.exp(- (X*X + Y*Y)/2/(aperture_diameter/2.35)**2)
wf.rescale_amplitudes(window)
else:
raise Exception("Not implemented! (accepted: circle, square, gaussian)")
if do_plot:
plot_image(wf.get_intensity(),1e6*wf.get_coordinate_x(),1e6*wf.get_coordinate_y(),
title="aperture intensity (%s), Diameter=%5.1f um"%
(aperture_type,1e6*aperture_diameter),xtitle="X [um]",ytitle="Y [um]",
show=0)
plot_image(wf1_fraunhofer.get_intensity(),1e6*wf1_fraunhofer.get_coordinate_x(),1e6*wf1_fraunhofer.get_coordinate_y(),
title="2D Diffracted intensity (%s) by a %s slit of aperture %3.1f um"%
(aperture_type,"Fraunhofer",1e6*aperture_diameter),
xtitle="X [urad]",ytitle="Y [urad]",
show=0)
plot_image(wf1_zoom.get_intensity(),1e6*wf1_zoom.get_coordinate_x(),1e6*wf1_zoom.get_coordinate_y(),
title="2D Diffracted intensity (%s) by a %s slit of aperture %3.1f um"%
(aperture_type,"Zoom",1e6*aperture_diameter),
xtitle="X [urad]",ytitle="Y [urad]",
show=0)
intensity_calculated_fraunhofer = wf1_fraunhofer.get_intensity()[:,int(wf1_fraunhofer.size()[1]/2)]
intensity_calculated_fraunhofer /= intensity_calculated_fraunhofer.max()
intensity_calculated_zoom = wf1_zoom.get_intensity()[:,int(wf1_fraunhofer.size()[1]/2)]
intensity_calculated_zoom /= intensity_calculated_zoom.max()
phase_calculated_fraunhofer = wf1_fraunhofer.get_phase()[:,int(wf1_fraunhofer.size()[1]/2)]
phase_calculated_fraunhofer = numpy.unwrap(phase_calculated_fraunhofer)
phase_calculated_zoom = wf1_zoom.get_phase()[:,int(wf1_zoom.size()[1]/2)]
phase_calculated_zoom = numpy.unwrap(phase_calculated_zoom)
if do_plot:
plot(wf1_fraunhofer.get_coordinate_x()*1e6/propagation_distance, intensity_calculated_fraunhofer,
wf1_zoom.get_coordinate_x()*1e6 /propagation_distance, intensity_calculated_zoom,
legend=["Fraunhofer H profile","Zoom H profile"],legend_position=(0.95, 0.95),
title="2D Diffraction of a %s slit of %3.1f um at wavelength of %3.1f A"%
(aperture_type,aperture_diameter*1e6,wavelength*1e10),
xtitle="X (urad)", ytitle="Intensity",xrange=[-80,80],show=0)
plot(wf1_fraunhofer.get_coordinate_x()*1e6/propagation_distance, phase_calculated_fraunhofer,
wf1_zoom.get_coordinate_x()*1e6 /propagation_distance, phase_calculated_zoom,
legend=["Fraunhofer H profile","Zoom H profile"],legend_position=(0.95, 0.95),
title="2D Diffraction of a %s slit of %3.1f um at wavelength of %3.1f A"%
(aperture_type,aperture_diameter*1e6,wavelength*1e10),
xtitle="X (urad)", ytitle="Phase",xrange=[-80,80])
numpy.testing.assert_almost_equal(1e-3*intensity_calculated_fraunhofer,1e-3*intensity_calculated_zoom,1)
def propagate_2D_fresnel(self,do_plot=do_plot,method='fft',
wavelength=1.24e-10,aperture_type='square',aperture_diameter=40e-6,
pixelsize_x=1e-6,pixelsize_y=1e-6,npixels_x=1024,npixels_y=1024,
propagation_distance = 30.0,show=1,
use_additional_parameters_input_way=1, # 0=default (common), 1=new (specific))
):
method_label = "fresnel (%s)"%method
print("\n# ")
print("# 2D near field fresnel (%s) diffraction from a %s aperture "%(method_label,aperture_type))
print("# ")
# wf = Wavefront2D.initialize_wavefront_from_steps(x_start=-pixelsize_x*npixels_x/2,
# x_step=pixelsize_x,
# y_start=-pixelsize_y*npixels_y/2,
# y_step=pixelsize_y,
# wavelength=wavelength,
# number_of_points=(npixels_x,npixels_y))
wf = GenericWavefront2D.initialize_wavefront_from_range(x_min=-pixelsize_x*npixels_x/2,x_max=pixelsize_x*npixels_x/2,
y_min=-pixelsize_y*npixels_y/2,y_max=pixelsize_y*npixels_y/2,
number_of_points=(npixels_x,npixels_y),wavelength=wavelength)
wf.set_plane_wave_from_complex_amplitude((1.0+0j))
propagation_elements = PropagationElements()
slit = None
if aperture_type == 'square':
slit = WOSlit(boundary_shape=Rectangle(-aperture_diameter/2, aperture_diameter/2, -aperture_diameter/2, aperture_diameter/2))
elif aperture_type == 'gaussian':
slit = WOGaussianSlit(boundary_shape=Rectangle(-aperture_diameter/2, aperture_diameter/2, -aperture_diameter/2, aperture_diameter/2))
else:
raise Exception("Not implemented! (accepted: circle, square, gaussian)")
if use_additional_parameters_input_way == 0:
propagation_elements.add_beamline_element(BeamlineElement(optical_element=slit,
coordinates=ElementCoordinates(p=0, q=propagation_distance)))
propagator = PropagationManager.Instance()
propagation_parameters = PropagationParameters(wavefront=wf,
propagation_elements=propagation_elements)
if method == 'fft':
propagation_parameters.set_additional_parameters("shift_half_pixel", True)
wf1 = propagator.do_propagation(propagation_parameters, Fresnel2D.HANDLER_NAME)
elif method == 'convolution':
propagation_parameters.set_additional_parameters("shift_half_pixel", True)
wf1 = propagator.do_propagation(propagation_parameters, FresnelConvolution2D.HANDLER_NAME)
elif method == 'integral':
propagation_parameters.set_additional_parameters("shuffle_interval", 0)
propagation_parameters.set_additional_parameters("calculate_grid_only", 1)
wf1 = propagator.do_propagation(propagation_parameters, Integral2D.HANDLER_NAME)
elif method == 'zoom':
propagation_parameters.set_additional_parameters("shift_half_pixel", True)
propagation_parameters.set_additional_parameters("magnification_x", 2.0)
propagation_parameters.set_additional_parameters("magnification_y", 0.5)
wf1 = propagator.do_propagation(propagation_parameters, FresnelZoomXY2D.HANDLER_NAME)
else:
raise Exception("Not implemented method: %s"%method)
else:
if method == 'fft':
additional_parameters = {"shift_half_pixel":True}
elif method == 'convolution':
additional_parameters = {"shift_half_pixel":True}
elif method == 'integral':
additional_parameters = {"shuffle_interval":0,
"calculate_grid_only":1}
elif method == 'zoom':
additional_parameters = {"shift_half_pixel":True,
"magnification_x":2.0,
"magnification_y":0.5}
else:
raise Exception("Not implemented method: %s"%method)
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=slit,coordinates=ElementCoordinates(p=0, q=propagation_distance)),
element_parameters=additional_parameters)
propagator = PropagationManager.Instance()
propagation_parameters = PropagationParameters(wavefront=wf,
propagation_elements=propagation_elements)
if method == 'fft':
wf1 = propagator.do_propagation(propagation_parameters, Fresnel2D.HANDLER_NAME)
elif method == 'convolution':
wf1 = propagator.do_propagation(propagation_parameters, FresnelConvolution2D.HANDLER_NAME)
elif method == 'integral':
wf1 = propagator.do_propagation(propagation_parameters, Integral2D.HANDLER_NAME)
elif method == 'zoom':
wf1 = propagator.do_propagation(propagation_parameters, FresnelZoomXY2D.HANDLER_NAME)
else:
raise Exception("Not implemented method: %s"%method)
if do_plot:
from srxraylib.plot.gol import plot_image
plot_image(wf.get_intensity(),1e6*wf.get_coordinate_x(),1e6*wf.get_coordinate_y(),
title="aperture intensity (%s), Diameter=%5.1f um"%
(aperture_type,1e6*aperture_diameter),xtitle="X [um]",ytitle="Y [um]",
show=0)
plot_image(wf1.get_intensity(),
1e6*wf1.get_coordinate_x()/propagation_distance,
1e6*wf1.get_coordinate_y()/propagation_distance,
title="Diffracted intensity (%s) by a %s slit of aperture %3.1f um"%
(aperture_type,method_label,1e6*aperture_diameter),
xtitle="X [urad]",ytitle="Y [urad]",
show=0)
# get the theoretical value
angle_x = wf1.get_coordinate_x() / propagation_distance
intensity_theory = get_theoretical_diffraction_pattern(angle_x,aperture_type=aperture_type,aperture_diameter=aperture_diameter,
wavelength=wavelength,normalization=True)
intensity_calculated = wf1.get_intensity()[:,int(wf1.size()[1]/2)]
intensity_calculated /= intensity_calculated.max()
if do_plot:
from srxraylib.plot.gol import plot
plot(wf1.get_coordinate_x()*1e6/propagation_distance,intensity_calculated,
angle_x*1e6,intensity_theory,
legend=["%s H profile"%method_label,"Theoretical (far field)"],
legend_position=(0.95, 0.95),
title="%s diffraction of a %s slit of %3.1f um at wavelength of %3.1f A"%
(method_label,aperture_type,aperture_diameter*1e6,wavelength*1e10),
xtitle="X (urad)", ytitle="Intensity",xrange=[-20,20],
show=show)
return wf1.get_coordinate_x()/propagation_distance,intensity_calculated,angle_x,intensity_theory
def run_wofry():
#
# create/import your input_wavefront (THIS IS A PLACEHOLDER - REPLACE WITH YOUR SOURCE)
#
#
from wofry.propagator.wavefront2D.generic_wavefront import GenericWavefront2D
input_wavefront = GenericWavefront2D.load_h5_file(
"/users/srio/Working/paper-hierarchical/WORKSPACES/tmp.h5", "wfr")
# initialize_wavefront_from_range(-10e-6,10e-6,-100e-6,100e-6,(200,100),1e-10)
#
# info on current oe
#
#
# -------WOScreen---------
# -------BoundaryShape---------
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen
optical_element = WOScreen()
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=28.300000,
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)
#self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
8.000000)
propagation_parameters.set_additional_parameters('magnification_y',
10.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.0018849 m # x (width) minimum (signed)
# x_right: 0.0018849 m # x (width) maximum (signed)
# y_bottom: -0.0018849 m # y (length) minimum (signed)
# y_top: 0.0018849 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.0018849,
x_right=0.0018849,
y_bottom=-0.0018849,
y_top=0.0018849)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
#self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
1.000000)
propagation_parameters.set_additional_parameters('magnification_y',
1.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 8.319 m # Focal length in x [horizontal]
# focal_y: 99999999999999.0 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=8.319000,
focal_y=99999999999999.000000)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
#self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
1.000000)
propagation_parameters.set_additional_parameters('magnification_y',
1.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -2.5e-05 m # x (width) minimum (signed)
# x_right: 2.5e-05 m # x (width) maximum (signed)
# y_bottom: -0.5 m # y (length) minimum (signed)
# y_top: 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-2.5e-05,
x_right=2.5e-05,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=11.700000,
q=0.000000,
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)
#self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
0.010000)
propagation_parameters.set_additional_parameters('magnification_y',
1.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
#
# ######################### KB #########################################
#
#
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.025 m # x (width) minimum (signed)
# x_right: 0.025 m # x (width) maximum (signed)
# y_bottom: -0.00045 m # y (length) minimum (signed)
# y_top: 0.00045 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.025,
x_right=0.025,
y_bottom=-0.00045,
y_top=0.00045)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=144.900000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
440.000000)
propagation_parameters.set_additional_parameters('magnification_y',
5.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 100000000.0 m # Focal length in x [horizontal]
# focal_y: 0.09994594594594594 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=100000000.000000,
focal_y=0.099946)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
1.000000)
propagation_parameters.set_additional_parameters('magnification_y',
1.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.000195 m # x (width) minimum (signed)
# x_right: 0.000195 m # x (width) maximum (signed)
# y_bottom: -0.0065 m # y (length) minimum (signed)
# y_top: 0.0065 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.000195,
x_right=0.000195,
y_bottom=-0.0065,
y_top=0.0065)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.050000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
1.000000)
propagation_parameters.set_additional_parameters('magnification_y',
0.500000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 0.049982758620701014 m # Focal length in x [horizontal]
# focal_y: 100000000.0 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=0.049983,
focal_y=100000000.000000)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
1.000000)
propagation_parameters.set_additional_parameters('magnification_y',
1.000000)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.5 m # x (width) minimum (signed)
# x_right: 0.5 m # x (width) maximum (signed)
# y_bottom: -0.5 m # y (length) minimum (signed)
# y_top: 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.5,
x_right=0.5,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.050000,
q=0.000000,
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)
# self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
0.000070)
propagation_parameters.set_additional_parameters('magnification_y',
0.000090)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
input_wavefront = output_wavefront
return input_wavefront
def propagate_1D(
self,
do_plot=do_plot,
method='fft',
wavelength=1.24e-10,
aperture_type='square',
aperture_diameter=40e-6,
wavefront_length=100e-6,
npoints=500,
propagation_distance=30.0,
normalization=True, # TODO put False
show=1,
amplitude=(0.0 + 1.0j)):
print(
"\n# ")
print("# 1D (%s) propagation from a %s aperture " %
(method, aperture_type))
print("# ")
wf = GenericWavefront1D.initialize_wavefront_from_range(
x_min=-wavefront_length / 2,
x_max=wavefront_length / 2,
number_of_points=npoints,
wavelength=wavelength)
wf.set_plane_wave_from_complex_amplitude(
amplitude) # an arbitraty value
deltax = wf.get_abscissas()[1] - wf.get_abscissas()[0]
propagation_elements = PropagationElements()
slit = None
if aperture_type == 'square':
slit = WOSlit1D(boundary_shape=Rectangle(-aperture_diameter /
2, aperture_diameter /
2, 0, 0))
elif aperture_type == 'gaussian':
slit = WOGaussianSlit1D(
boundary_shape=Rectangle(-aperture_diameter /
2, aperture_diameter / 2, 0, 0))
else:
raise Exception(
"Not implemented! (accepted: circle, square, gaussian)")
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=slit,
coordinates=ElementCoordinates(
p=0, q=propagation_distance)))
propagator = PropagationManager.Instance()
propagation_parameters = PropagationParameters(
wavefront=wf, propagation_elements=propagation_elements)
print("Using propagator method: ", method)
fresnel_analytical = True
if method == 'fft':
wf1 = propagator.do_propagation(propagation_parameters,
Fresnel1D.HANDLER_NAME)
elif method == 'convolution':
wf1 = propagator.do_propagation(propagation_parameters,
FresnelConvolution1D.HANDLER_NAME)
elif method == 'integral':
propagation_parameters.set_additional_parameters(
"magnification_x", 1.5)
propagation_parameters.set_additional_parameters(
"magnification_N", 2.0)
wf1 = propagator.do_propagation(propagation_parameters,
Integral1D.HANDLER_NAME)
elif method == 'fraunhofer':
fresnel_analytical = False
# propagation_parameters.set_additional_parameters("shift_half_pixel", 0)
wf1 = propagator.do_propagation(propagation_parameters,
Fraunhofer1D.HANDLER_NAME)
elif method == 'zoom':
propagation_parameters.set_additional_parameters(
"magnification_x", 1.5)
wf1 = propagator.do_propagation(propagation_parameters,
FresnelZoom1D.HANDLER_NAME)
else:
raise Exception("Not implemented method: %s" % method)
if fresnel_analytical:
xx, alpha = fresnel_analytical_rectangle(
fresnel_number=None,
propagation_distance=propagation_distance,
aperture_half=0.5 * aperture_diameter,
wavelength=wavelength,
detector_array=wf1.get_abscissas(),
npoints=None)
else:
xx, alpha = fraunhofer_analytical_rectangle(
fresnel_number=None,
propagation_distance=propagation_distance,
aperture_half=0.5 * aperture_diameter,
wavelength=wavelength,
detector_array=wf1.get_abscissas(),
npoints=None)
angle_x = xx / propagation_distance
intensity_theory = numpy.abs(amplitude * alpha)**2
intensity_calculated = wf1.get_intensity()
if normalization:
intensity_calculated /= intensity_calculated.max()
intensity_theory /= intensity_theory.max()
if do_plot:
from srxraylib.plot.gol import plot
plot(
wf1.get_abscissas() * 1e6 / propagation_distance,
intensity_calculated,
angle_x * 1e6,
intensity_theory,
legend=["%s " % method, "analytical"],
legend_position=(0.95, 0.95),
title=
"1D (%s) diffraction from a %s aperture of %3.1f um at \n wavelength of %3.1f A"
% (method, aperture_type, aperture_diameter * 1e6,
wavelength * 1e10),
xtitle="X (urad)",
ytitle="Intensity",
xrange=[-20, 20],
ylog=True,
show=show)
plot(
wf1.get_abscissas() * 1e6,
wf1.get_phase(unwrap=True),
1e6 * xx,
numpy.unwrap(numpy.angle(alpha)),
legend=["%s " % method, "analytical"],
title=
"1D (%s) diffraction from a %s aperture of %3.1f um at \n wavelength of %3.1f A NOT ASSERTED!!"
% (method, aperture_type, aperture_diameter * 1e6,
wavelength * 1e10),
xtitle="X (urad)",
ytitle="Phase",
# xrange=[-20, 20],
)
return wf1.get_abscissas(
) / propagation_distance, intensity_calculated, intensity_theory
def get_wofry_beamline_elements():
BEAMLINE_ELEMENTS = []
HANDLERS = []
SPECIFIC = []
#
# info on current oe
#
#
# -------WOScreen---------
# -------BoundaryShape---------
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen
optical_element = WOScreen()
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=28.300000,
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)
# #self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 8.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 10.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters, handler_name='FRESNEL_ZOOM_XY_2D')
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 8.0,
'magnification_y': 8.0
})
# input_wavefront = output_wavefront
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.0018849 m # x (width) minimum (signed)
# x_right: 0.0018849 m # x (width) maximum (signed)
# y_bottom: -0.0018849 m # y (length) minimum (signed)
# y_top: 0.0018849 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.0018849,
x_right=0.0018849,
y_bottom=-0.0018849,
y_top=0.0018849)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
# #self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 1.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 1.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters, handler_name='FRESNEL_ZOOM_XY_2D')
#
#
#
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 8.319 m # Focal length in x [horizontal]
# focal_y: 99999999999999.0 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=8.319000,
focal_y=99999999999999.000000)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
# #self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 1.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 1.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters, handler_name='FRESNEL_ZOOM_XY_2D')
#
#
#
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -2.5e-05 m # x (width) minimum (signed)
# x_right: 2.5e-05 m # x (width) maximum (signed)
# y_bottom: -0.5 m # y (length) minimum (signed)
# y_top: 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-2.5e-05,
x_right=2.5e-05,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=11.700000,
q=0.000000,
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)
# #self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 0.010000)
# propagation_parameters.set_additional_parameters('magnification_y', 1.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters, handler_name='FRESNEL_ZOOM_XY_2D')
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 0.01,
'magnification_y': 1.0
})
#
#
# ######################### KB #########################################
#
#
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.025 m # x (width) minimum (signed)
# x_right: 0.025 m # x (width) maximum (signed)
# y_bottom: -0.00045 m # y (length) minimum (signed)
# y_top: 0.00045 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.025,
x_right=0.025,
y_bottom=-0.00045,
y_top=0.00045)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=144.900000,
q=0.000000,
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)
# # self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 440.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 5.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,
# handler_name='FRESNEL_ZOOM_XY_2D')
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 440.0,
'magnification_y': 5.0
})
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 100000000.0 m # Focal length in x [horizontal]
# focal_y: 0.09994594594594594 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=100000000.000000,
focal_y=0.099946)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
# # self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 1.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 1.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,
# handler_name='FRESNEL_ZOOM_XY_2D')
#
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.000195 m # x (width) minimum (signed)
# x_right: 0.000195 m # x (width) maximum (signed)
# y_bottom: -0.0065 m # y (length) minimum (signed)
# y_top: 0.0065 m # y (length) maximum (signed)
#
#
# define current oe
#
# from syned.beamline.shape import Rectangle
# boundary_shape = Rectangle(x_left=-0.000195, x_right=0.000195, y_bottom=-0.0065, y_top=0.0065)
#
# from wofry.beamline.optical_elements.absorbers.slit import WOSlit
# optical_element = WOSlit(boundary_shape=boundary_shape)
#
# #
# # propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
# #
# #
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.050000,
q=0.000000,
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)
# # self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 1.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 0.500000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,
# handler_name='FRESNEL_ZOOM_XY_2D')
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 0.05
})
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 0.049982758620701014 m # Focal length in x [horizontal]
# focal_y: 100000000.0 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=0.049983,
focal_y=100000000.000000)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.000000,
q=0.000000,
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)
# # self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 1.000000)
# propagation_parameters.set_additional_parameters('magnification_y', 1.000000)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,
# handler_name='FRESNEL_ZOOM_XY_2D')
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.5 m # x (width) minimum (signed)
# x_right: 0.5 m # x (width) maximum (signed)
# y_bottom: -0.5 m # y (length) minimum (signed)
# y_top: 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.5,
x_right=0.5,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
# propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.050000,
q=0.000000,
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)
# # self.set_additional_parameters(propagation_parameters)
# #
# propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
# propagation_parameters.set_additional_parameters('magnification_x', 0.000070)
# propagation_parameters.set_additional_parameters('magnification_y', 0.000090)
# #
# propagator = PropagationManager.Instance()
# try:
# propagator.add_propagator(FresnelZoomXY2D())
# except:
# pass
# output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,
# handler_name='FRESNEL_ZOOM_XY_2D')
#
#
# input_wavefront = output_wavefront
BEAMLINE_ELEMENTS.append(beamline_element)
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 0.000070,
'magnification_y': 0.000090
})
return BEAMLINE_ELEMENTS, HANDLERS, SPECIFIC
from syned.beamline.beamline import Beamline
from syned.beamline.beamline_element import BeamlineElement
from syned.beamline.element_coordinates import ElementCoordinates
if __name__ == "__main__":
src1 = ElectronBeam.initialize_as_pencil_beam(energy_in_GeV=6.0,current=0.2)
src2 = Undulator()
screen1 = Screen("screen1")
lens1 = IdealLens(name="lens1",focal_y=6.0,focal_x=None,)
filter1 = Filter("filter1","H2O",3.0e-6)
slit1 = Slit(name="slit1",boundary_shape=Rectangle(-0.5e-3,0.5e-3,-2e-3,2e-3))
stopper1 = BeamStopper(name="stopper1",boundary_shape=Rectangle(-0.5e-3,0.5e-3,-2e-3,2e-3))
mirror1 = Mirror(name="mirror1",boundary_shape=Rectangle(-0.5e-3,0.5e-3,-2e-3,2e-3))
crystal1 = Crystal(name="crystal1",surface_shape=Plane())
grating1 = Grating(name="grating1",surface_shape=Conic())
mylist = [src1,src2,screen1,lens1,filter1,slit1, stopper1, mirror1, grating1, crystal1]
#
# test individual elements
#
for i,element in enumerate(mylist):
element.to_json("tmp_%d.json"%i)
for i,element in enumerate(mylist):
def set_rectangle(self,width=3e-3,height=4e-3):
self._boundary_shape=Rectangle(-0.5*width,0.5*width,-0.5*height,0.5*height)
def __init__(
self,
name="Undefined",
optical_element_displacement=None,
tangential_size=1.2,
sagittal_size=0.01,
grazing_angle=0.003,
vertical_position_of_mirror_center=0.0,
horizontal_position_of_mirror_center=0.0,
orientation_of_reflection_plane=Orientation.UP,
invert_tangent_component=False,
add_acceptance_slit=False,
height_profile_data_file="mirror.dat",
height_profile_data_file_dimension=1,
height_amplification_coefficient=1.0,
diffraction_order=1,
grooving_density_0=800, # groove density [lines/mm] (coefficient a0 in the polynomial groove density: a0 + a1*y + a2*y^2 + a3*y^3 + a4*y^4)
grooving_density_1=0.0, # groove density polynomial coefficient a1 [lines/mm^2]
grooving_density_2=0.0, # groove density polynomial coefficient a2 [lines/mm^3]
grooving_density_3=0.0, # groove density polynomial coefficient a3 [lines/mm^4]
grooving_density_4=0.0, # groove density polynomial coefficient a4 [lines/mm^5]
grooving_angle=0.0 # angle between the grove direction and the sagittal direction of the substrate
):
SRWOpticalElementWithAcceptanceSlit.__init__(
self,
optical_element_displacement=optical_element_displacement,
tangential_size=tangential_size,
sagittal_size=sagittal_size,
grazing_angle=grazing_angle,
vertical_position_of_mirror_center=
vertical_position_of_mirror_center,
horizontal_position_of_mirror_center=
horizontal_position_of_mirror_center,
orientation_of_reflection_plane=orientation_of_reflection_plane,
invert_tangent_component=invert_tangent_component,
add_acceptance_slit=add_acceptance_slit)
Grating.__init__(self,
name=name,
boundary_shape=Rectangle(
x_left=horizontal_position_of_mirror_center -
0.5 * sagittal_size,
x_right=horizontal_position_of_mirror_center +
0.5 * sagittal_size,
y_bottom=vertical_position_of_mirror_center -
0.5 * tangential_size,
y_top=vertical_position_of_mirror_center +
0.5 * tangential_size),
surface_shape=self.get_shape(),
ruling=grooving_density_0 * 1e3)
self.height_profile_data_file = height_profile_data_file
self.height_profile_data_file_dimension = height_profile_data_file_dimension
self.height_amplification_coefficient = height_amplification_coefficient
self.diffraction_order = diffraction_order
self.grooving_density_0 = grooving_density_0
self.grooving_density_1 = grooving_density_1
self.grooving_density_2 = grooving_density_2
self.grooving_density_3 = grooving_density_3
self.grooving_density_4 = grooving_density_4
self.grooving_angle = grooving_angle
def test_propagate_2D_fraunhofer(self,do_plot=do_plot,aperture_type='square',aperture_diameter=40e-6,
pixelsize_x=1e-6,pixelsize_y=1e-6,npixels_x=1024,npixels_y=1024,wavelength=1.24e-10):
"""
:param do_plot: 0=No plot, 1=Do plot
:param aperture_type: 'circle' 'square' 'gaussian' (Gaussian sigma = aperture_diameter/2.35)
:param aperture_diameter:
:param pixelsize_x:
:param pixelsize_y:
:param npixels_x:
:param npixels_y:
:param wavelength:
:return:
"""
print("\n# ")
print("# far field 2D (fraunhofer) diffraction from a square aperture ")
print("# ")
method = "fraunhofer"
print("Fraunhoffer diffraction valid for distances > > a^2/lambda = %f m"%((aperture_diameter/2)**2/wavelength))
wf = GenericWavefront2D.initialize_wavefront_from_range(x_min=-pixelsize_x*npixels_x/2,x_max=pixelsize_x*npixels_x/2,
y_min=-pixelsize_y*npixels_y/2,y_max=pixelsize_y*npixels_y/2,
number_of_points=(npixels_x,npixels_y),wavelength=wavelength)
wf.set_plane_wave_from_complex_amplitude((1.0+0j))
propagation_elements = PropagationElements()
slit = None
if aperture_type == 'square':
slit = WOSlit(boundary_shape=Rectangle(-aperture_diameter/2, aperture_diameter/2, -aperture_diameter/2, aperture_diameter/2))
elif aperture_type == 'gaussian':
slit = WOGaussianSlit(boundary_shape=Rectangle(-aperture_diameter/2, aperture_diameter/2, -aperture_diameter/2, aperture_diameter/2))
else:
raise Exception("Not implemented! (accepted: circle, square, gaussian)")
propagation_elements.add_beamline_element(BeamlineElement(optical_element=slit,
coordinates=ElementCoordinates(p=0, q=1.0)))
propagator = PropagationManager.Instance()
propagation_parameters = PropagationParameters(wavefront=wf,
propagation_elements=propagation_elements)
propagation_parameters.set_additional_parameters("shift_half_pixel", True)
wf1 = propagator.do_propagation(propagation_parameters, Fraunhofer2D.HANDLER_NAME)
if aperture_type == 'circle':
wf.clip_circle(aperture_diameter/2)
elif aperture_type == 'square':
wf.clip_square(-aperture_diameter/2, aperture_diameter/2,-aperture_diameter/2, aperture_diameter/2)
elif aperture_type == 'gaussian':
X = wf.get_mesh_x()
Y = wf.get_mesh_y()
window = numpy.exp(- (X*X + Y*Y)/2/(aperture_diameter/2.35)**2)
wf.rescale_amplitudes(window)
else:
raise Exception("Not implemented! (accepted: circle, square, gaussian)")
if do_plot:
plot_image(wf.get_intensity(),1e6*wf.get_coordinate_x(),1e6*wf.get_coordinate_y(),
title="aperture intensity (%s), Diameter=%5.1f um"%
(aperture_type,1e6*aperture_diameter),xtitle="X [um]",ytitle="Y [um]",
show=0)
plot_image(wf1.get_intensity(),1e6*wf1.get_coordinate_x(),1e6*wf1.get_coordinate_y(),
title="2D Diffracted intensity (%s) by a %s slit of aperture %3.1f um"%
(aperture_type,method,1e6*aperture_diameter),
xtitle="X [urad]",ytitle="Y [urad]",
show=0)
angle_x = wf1.get_coordinate_x() # + 0.5*wf1.delta()[0] # shifted of half-pixel!!!
intensity_theory = get_theoretical_diffraction_pattern(angle_x,
aperture_type=aperture_type,aperture_diameter=aperture_diameter,
wavelength=wavelength,normalization=True)
intensity_calculated = wf1.get_intensity()[:,int(wf1.size()[1]/2)]
intensity_calculated /= intensity_calculated.max()
if do_plot:
plot(wf1.get_coordinate_x()*1e6,intensity_calculated,
angle_x*1e6,intensity_theory,
legend=["Calculated (FT) H profile","Theoretical"],legend_position=(0.95, 0.95),
title="2D Fraunhofer Diffraction of a %s slit of %3.1f um at wavelength of %3.1f A"%
(aperture_type,aperture_diameter*1e6,wavelength*1e10),
xtitle="X (urad)", ytitle="Intensity",xrange=[-80,80])
numpy.testing.assert_almost_equal(intensity_calculated,intensity_theory,1)
electron_beam.set_sigmas_all(sigma_x=0.2529e-3,
sigma_xp=0.02881e-3,
sigma_y=0.01844e-3,
sigma_yp=5.235e-6)
bm = Shadow3BendingMagnetLightSource(
electron_beam=electron_beam,
bending_magnet_magnetic_structure=BendingMagnet(radius=0.0,
magnetic_field=1.2,
length=0.0),
bending_magnet_parameters=Shadow3BendingMagnetParameters(NPOINT=50000))
slit = Shadow3Slit(name="first slit",
boundary_shape=Rectangle(x_left=-0.0001,
x_right=0.0001,
y_bottom=-0.0005,
y_top=0.0005),
slit_parameters=Shadow3SlitParameters())
slit_coordinates = ElementCoordinates(p=10.0, q=0.0)
elements = RaytracingElements()
elements.add_beamline_element(
BeamlineElement(optical_element=slit, coordinates=slit_coordinates))
raytracing_parameters = RaytracingParameters(beam=bm.generate_source(),
raytracing_elements=elements)
beam = raytracing_manager.do_raytracing(
raytracing_parameters=raytracing_parameters,
handler_name=Shadow3Raytracer.HANDLER_NAME)
def slit_schermo(input_wavefront):
#
# ===== Example of python code to create propagate current element =====
#
#
# Import section
#
import numpy
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.propagators2D.fresnel_zoom_xy import FresnelZoomXY2D
#
# info on current oe
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left : -0.5 m # x (width) minimum (signed)
# x_right : 0.5 m # x (width) maximum (signed)
# y_bottom : -0.5 m # y (length) minimum (signed)
# y_top : 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.500000,
x_right=0.500000,
y_bottom=-0.500000,
y_top=0.500000)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
#
# propagating
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(
optical_element=optical_element,
coordinates=ElementCoordinates(
p=0.050000,
q=0.000000,
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)
#self.set_additional_parameters(propagation_parameters)
#
propagation_parameters.set_additional_parameters('shift_half_pixel', 1)
propagation_parameters.set_additional_parameters('magnification_x',
0.000070)
propagation_parameters.set_additional_parameters('magnification_y',
0.000090)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
output_wavefront = propagator.do_propagation(
propagation_parameters=propagation_parameters,
handler_name='FRESNEL_ZOOM_XY_2D')
return output_wavefront, beamline_element
def test_propagate_1D_fraunhofer_phase(self, do_plot=do_plot):
# aperture_type="square"
# aperture_diameter = 40e-6
# wavefront_length = 800e-6
# wavelength = 1.24e-10
# npoints=1024
# propagation_distance=40
show = 1
aperture_type = "square"
aperture_diameter = 40e-6
wavefront_length = 800e-6
wavelength = 1.24e-10
propagation_distance = 30.0
npoints = 1024
print(
"\n# ")
print(
"# far field 1D (fraunhofer and zoom) diffraction from a %s aperture "
% aperture_type)
print("# ")
wf = GenericWavefront1D.initialize_wavefront_from_range(
x_min=-wavefront_length / 2,
x_max=wavefront_length / 2,
number_of_points=npoints,
wavelength=wavelength)
wf.set_plane_wave_from_complex_amplitude(
(2.0 + 1.0j)) # an arbitraty value
propagation_elements = PropagationElements()
if aperture_type == 'square':
slit = WOSlit1D(boundary_shape=Rectangle(-aperture_diameter /
2, aperture_diameter /
2, 0, 0))
else:
raise Exception("Not implemented! ")
propagation_elements.add_beamline_element(
BeamlineElement(optical_element=slit,
coordinates=ElementCoordinates(
p=0, q=propagation_distance)))
propagator = PropagationManager.Instance()
propagation_parameters = PropagationParameters(
wavefront=wf, propagation_elements=propagation_elements)
wf1_franuhofer = propagator.do_propagation(propagation_parameters,
Fraunhofer1D.HANDLER_NAME)
propagation_parameters.set_additional_parameters(
"shift_half_pixel", True)
propagation_parameters.set_additional_parameters(
"magnification_x", 1.5)
wf1_zoom = propagator.do_propagation(propagation_parameters,
FresnelZoom1D.HANDLER_NAME)
intensity_fraunhofer = wf1_franuhofer.get_intensity(
) / wf1_franuhofer.get_intensity().max()
intensity_zoom = wf1_zoom.get_intensity() / wf1_zoom.get_intensity(
).max()
if do_plot:
from srxraylib.plot.gol import plot
plot(
wf1_franuhofer.get_abscissas() * 1e6 / propagation_distance,
intensity_fraunhofer,
wf1_zoom.get_abscissas() * 1e6 / propagation_distance,
intensity_zoom,
legend=["Fraunhofer", "Zoom"],
legend_position=(0.95, 0.95),
title=
"1D INTENSITY diffraction from aperture of %3.1f um at wavelength of %3.1f A"
% (aperture_diameter * 1e6, wavelength * 1e10),
xtitle="X (urad)",
ytitle="Intensity",
xrange=[-20, 20],
show=show)
plot(
wf1_franuhofer.get_abscissas() * 1e6 / propagation_distance,
wf1_franuhofer.get_phase(unwrap=1),
wf1_zoom.get_abscissas() * 1e6 / propagation_distance,
wf1_zoom.get_phase(unwrap=1),
legend=["Fraunhofer", "Zoom"],
legend_position=(0.95, 0.95),
title=
"1D diffraction from a %s aperture of %3.1f um at wavelength of %3.1f A"
% (aperture_type, aperture_diameter * 1e6, wavelength * 1e10),
xtitle="X (urad)",
ytitle="Intensity",
xrange=[-20, 20],
show=show)
def get_wofry_beamline_elements():
ELEMENTS = []
COORDINATES = []
HANDLERS = []
SPECIFIC = []
#
# info on current oe 0
#
#
# -------WOScreen---------
# -------BoundaryShape---------
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen
optical_element = WOScreen()
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.0,
q=28.30,
angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 8.0,
'magnification_y': 10.0
})
#
# info on current oe 1
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.0018849 m # x (width) minimum (signed)
# x_right: 0.0018849 m # x (width) maximum (signed)
# y_bottom: -0.0018849 m # y (length) minimum (signed)
# y_top: 0.0018849 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.0018849,
x_right=0.0018849,
y_bottom=-0.0018849,
y_top=0.0018849)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.0, q=0.0, angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe 2
#
#
# -------WOIdealLens---------
# focal_x: 8.319 m # Focal length in x [horizontal]
# focal_y: 99999999999999.0 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=8.319000,
focal_y=99999999999999.000000)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.0, q=0.0, angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe 3
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -2.5e-05 m # x (width) minimum (signed)
# x_right: 2.5e-05 m # x (width) maximum (signed)
# y_bottom: -0.5 m # y (length) minimum (signed)
# y_top: 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-2.5e-05,
x_right=2.5e-05,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=11.70,
q=0.0,
angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 0.01,
'magnification_y': 1.0
})
#
#
# ######################### KB #########################################
#
#
#
# info on current oe 4
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.025 m # x (width) minimum (signed)
# x_right: 0.025 m # x (width) maximum (signed)
# y_bottom: -0.00045 m # y (length) minimum (signed)
# y_top: 0.00045 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.025,
x_right=0.025,
y_bottom=-0.00045,
y_top=0.00045)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=144.9,
q=0.0,
angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 440.0,
'magnification_y': 5.0
})
#
# info on current oe 5
#
#
# -------WOIdealLens---------
# focal_x: 100000000.0 m # Focal length in x [horizontal]
# focal_y: 0.09994594594594594 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=100000000.000000,
focal_y=0.099946)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.0, q=0.0, angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe 6
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.000195 m # x (width) minimum (signed)
# x_right: 0.000195 m # x (width) maximum (signed)
# y_bottom: -0.0065 m # y (length) minimum (signed)
# y_top: 0.0065 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.000195,
x_right=0.000195,
y_bottom=-0.0065,
y_top=0.0065)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.05,
q=0.0,
angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 0.5
})
#
# info on current oe 7
#
#
# -------WOIdealLens---------
# focal_x: 0.049982758620701014 m # Focal length in x [horizontal]
# focal_y: 100000000.0 m # Focal length in y [vertical]
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.lens import WOIdealLens
optical_element = WOIdealLens(name='',
focal_x=0.049983,
focal_y=100000000.000000)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.0, q=0.0, angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 1.0,
'magnification_y': 1.0
})
#
# info on current oe 8
#
#
# -------WOSlit---------
# -------Rectangle---------
# x_left: -0.5 m # x (width) minimum (signed)
# x_right: 0.5 m # x (width) maximum (signed)
# y_bottom: -0.5 m # y (length) minimum (signed)
# y_top: 0.5 m # y (length) maximum (signed)
#
#
# define current oe
#
from syned.beamline.shape import Rectangle
boundary_shape = Rectangle(x_left=-0.5,
x_right=0.5,
y_bottom=-0.5,
y_top=0.5)
from wofry.beamline.optical_elements.absorbers.slit import WOSlit
optical_element = WOSlit(boundary_shape=boundary_shape)
ELEMENTS.append(optical_element)
COORDINATES.append(
ElementCoordinates(p=0.05,
q=0.0,
angle_radial=0.0,
angle_azimuthal=0.0))
HANDLERS.append('FRESNEL_ZOOM_XY_2D')
SPECIFIC.append({
'shift_half_pixel': 1,
'magnification_x': 0.000070,
'magnification_y': 0.000090
})
return ELEMENTS, COORDINATES, HANDLERS, SPECIFIC
