def do_propagation(self, parameters=PropagationParameters()):
wavefront = parameters.get_wavefront()
if not wavefront is None:
is_generic_wavefront = isinstance(wavefront, GenericWavefront1D)
else:
is_generic_wavefront = False
try:
if not is_generic_wavefront and not wavefront is None:
if isinstance(wavefront, WiserWavefront):
pass
except Exception as e:
QMessageBox.critical(self, "Wavefront cannot be managed by this propagator", str(e), QMessageBox.Ok)
self.setStatusMessage("Wavefront cannot be managed by this propagator")
if is_generic_wavefront:
wavefront = WiserWavefront.fromGenericWavefront(wavefront)
wise_propagation_elements = parameters.get_PropagationElements()
beamline = wise_propagation_elements.get_wise_propagation_elements()
beamline.ComputationSettings.NPools = int(parameters.get_additional_parameter("NPools"))
# Element -1 is the last element of the array
optical_element_end = wise_propagation_elements.get_propagation_element(-1).get_optical_element()
oeEnd = optical_element_end.native_optical_element
if parameters.get_additional_parameter("single_propagation"):
oeStart = oeEnd.GetParent(SameOrientation=True, OnlyReference=False)
else:
oeStart = wise_propagation_elements.get_wise_propagation_element(0)
# oeEnd = optical_element_end.native_optical_element
# oeStart is the first element [0], or the previous element [-2]
# print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
# print(wise_propagation_elements.get_wise_propagation_element(-2 if parameters.get_additional_parameter("single_propagation") else 0).Name, type(wise_propagation_elements.get_wise_propagation_element(-2 if parameters.get_additional_parameter("single_propagation") else 0)))
# print(oeStart.Name, oeEnd.Name)
# print(oeStart.CoreOptics.Orientation, oeEnd.CoreOptics.Orientation)
# print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
# oeStart =wise_propagation_elements.get_wise_propagation_element(-2 if parameters.get_additional_parameter("single_propagation") else 0)# oeEnd.GetParent(SameOrientation=True)
if PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.STEP_BY_STEP or parameters.get_additional_parameter("is_full_propagator"):
beamline.RefreshPositions()
beamline.ComputeFields(oeStart=oeStart, oeEnd=oeEnd, Verbose=False)
result = WiserWavefront(wiser_computation_results=oeEnd.ComputationData)
elif PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.WHOLE_BEAMLINE:
result = wavefront
else:
result = None
if is_generic_wavefront:
return None if result is None else result.toGenericWavefront()
else:
return result
def set_wise_live_propagation_mode(self):
self.wise_live_propagation_mode = "Element by Element" if PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.STEP_BY_STEP else \
"Whole beamline at Detector" if PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.WHOLE_BEAMLINE else \
"Unknown"
palette = QPalette(self.le_wise_live_propagation_mode.palette())
color = 'dark green' if PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.STEP_BY_STEP else \
'dark red' if PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.WHOLE_BEAMLINE else \
'black'
palette.setColor(QPalette.Text, QColor(color))
palette.setColor(QPalette.Base, QColor(243, 240, 140))
self.le_wise_live_propagation_mode.setPalette(palette)
def do_propagation(self, parameters=PropagationParameters()):
wavefront = parameters.get_wavefront()
if not wavefront is None:
is_generic_wavefront = isinstance(wavefront, GenericWavefront1D)
else:
is_generic_wavefront = False
if not is_generic_wavefront and not wavefront is None:
if not isinstance(wavefront, WiseWavefront):
raise ValueError(
"Wavefront cannot be managed by this propagator")
if is_generic_wavefront:
wavefront = WiseWavefront.fromGenericWavefront(wavefront)
wise_propagation_elements = parameters.get_PropagationElements()
beamline = wise_propagation_elements.get_wise_propagation_elements()
beamline.ComputationSettings.NPools = int(
parameters.get_additional_parameter("NPools"))
optical_element_end = wise_propagation_elements.get_propagation_element(
-1).get_optical_element()
oeEnd = optical_element_end.wise_optical_element
oeStart = wise_propagation_elements.get_wise_propagation_element(
-2 if parameters.get_additional_parameter("single_propagation"
) else 0)
if PropagationManager.Instance().get_propagation_mode(
WISE_APPLICATION
) == PropagationMode.STEP_BY_STEP or parameters.get_additional_parameter(
"is_full_propagator"):
beamline.RefreshPositions()
beamline.ComputeFields(oeStart=oeStart, oeEnd=oeEnd, Verbose=False)
result = WiseWavefront(
wise_computation_results=oeEnd.ComputationResults)
elif PropagationManager.Instance().get_propagation_mode(
WISE_APPLICATION) == PropagationMode.WHOLE_BEAMLINE:
result = wavefront
else:
result = None
if is_generic_wavefront:
return None if result is None else result.toGenericWavefront()
else:
return result
def KBv(input_wavefront):
optical_element = WOIdealLens(name='', focal_x=0.099946, focal_y=None)
#
# 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('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_single_mode(af, i, beamline):
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
from wofry.propagator.wavefront2D.generic_wavefront import GenericWavefront2D
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen
mi = af.coherentMode(i)
evi = af.eigenvalue(i)
print("propagating mode index", i, evi, mi.shape)
input_wavefront = GenericWavefront2D.initialize_wavefront_from_arrays(
x_array=af.xCoordinates(),
y_array=af.yCoordinates(),
z_array=mi * numpy.sqrt(evi),
)
i0 = input_wavefront.get_integrated_intensity()
input_wavefront.set_photon_energy(17226.0)
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoomXY2D())
except:
pass
wfp = beamline.propagate(input_wavefront, propagator)
i1 = wfp[-1].get_integrated_intensity()
return wfp, i1 / i0
def set_is_final_screen(self):
propagation_mode = PropagationManager.Instance().get_propagation_mode(SRW_APPLICATION)
self.cb_is_final_screen.setEnabled(propagation_mode == SRWPropagationMode.WHOLE_BEAMLINE)
self.view_type = self.is_final_screen
self.set_PlotQuality()
def set_srw_live_propagation_mode(self):
if PropagationManager.Instance().get_propagation_mode(
SRW_APPLICATION) == SRWPropagationMode.WHOLE_BEAMLINE:
raise ValueError(
"Propagation Mode not supported, switch to Element by Element")
else:
super(OWThicknessErrorPhaseShift,
self).set_srw_live_propagation_mode()
def initialize_default_propagator_2D():
propagator = PropagationManager.Instance()
propagator.add_propagator(Fraunhofer2D())
propagator.add_propagator(Fresnel2D())
propagator.add_propagator(FresnelConvolution2D())
propagator.add_propagator(Integral2D())
propagator.add_propagator(FresnelZoomXY2D())
def executeAction_3(self, action):
try:
PropagationManager.Instance().set_propagation_mode(SRW_APPLICATION, SRWPropagationMode.WHOLE_BEAMLINE)
showWarningMessage("Propagation Mode: Whole beamline at Final Screen (SRW Native)")
self.set_srw_live_propagation_mode()
except Exception as exception:
showCriticalMessage(exception.args[0])
def executeAction_2(self, action):
try:
PropagationManager.Instance().set_propagation_mode(SRW_APPLICATION, SRWPropagationMode.STEP_BY_STEP)
showWarningMessage("Propagation Mode: Element by Element (SRW Native)")
self.set_srw_live_propagation_mode()
except Exception as exception:
showCriticalMessage(exception.args[0])
def executeAction_1(self, action):
try:
PropagationManager.Instance().set_propagation_mode(WISE_APPLICATION, PropagationMode.STEP_BY_STEP)
showWarningMessage("Propagation Mode: Element by Element")
self.set_wise_live_propagation_mode()
except Exception as exception:
showCriticalMessage(exception.args[0])
def set_wise_live_propagation_mode(self):
for node in self.canvas_main_window.current_document().scheme().nodes:
widget = self.canvas_main_window.current_document().scheme().widget_for_node(node)
if hasattr(widget, "wise_live_propagation_mode"):
widget.set_wise_live_propagation_mode()
if not isinstance(widget, OWDetector) and (PropagationManager.Instance().get_propagation_mode(WISE_APPLICATION) == PropagationMode.WHOLE_BEAMLINE):
widget.view_type = 0
widget.set_ViewType()
def executeAction_2(self, action):
try:
PropagationManager.Instance().set_propagation_mode(WISE_APPLICATION, PropagationMode.WHOLE_BEAMLINE)
showWarningMessage("Propagation Mode: Whole beamline at Detector")
self.set_wise_live_propagation_mode()
except Exception as exception:
showCriticalMessage(exception.args[0])
raise exception
def initialize_propagator_1D():
propagation_manager = PropagationManager.Instance()
if not propagation_manager.is_initialized(WISE_APPLICATION):
if not propagation_manager.has_propagator(WisePropagator.HANDLER_NAME, WavefrontDimension.ONE): propagation_manager.add_propagator(WisePropagator())
propagation_manager.set_propagation_mode(WISE_APPLICATION, PropagationMode.STEP_BY_STEP)
propagation_manager.set_initialized(True)
def propagate_in_vacuum(input_wavefront,magnification_x=10.0,propagator_flag='z'):
#
# 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.propagators1D.fresnel_zoom import FresnelZoom1D
from wofry.propagator.propagators1D.integral import Integral1D
#
# info on current oe
#
#
# -------WOScreen1D---------
# -------BoundaryShape---------
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen1D
optical_element = WOScreen1D()
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(optical_element=optical_element,
coordinates=ElementCoordinates(p=15.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('magnification_x', magnification_x)
#
propagator = PropagationManager.Instance()
try:
propagator.add_propagator(FresnelZoom1D())
propagator.add_propagator(Integral1D())
except:
pass
if propagator_flag == 'z':
handler_name = 'FRESNEL_ZOOM_1D'
elif propagator_flag == 'i':
handler_name = 'INTEGRAL_1D'
output_wavefront = propagator.do_propagation(propagation_parameters=propagation_parameters,
handler_name=handler_name)
return output_wavefront
def initialize_default_propagator_1D():
propagator = PropagationManager.Instance()
propagator.add_propagator(Fraunhofer1D())
propagator.add_propagator(Fresnel1D())
propagator.add_propagator(FresnelConvolution1D())
propagator.add_propagator(Integral1D())
propagator.add_propagator(FresnelZoom1D())
propagator.add_propagator(FresnelZoomScaling1D())
def propagate_from_M1_to_M3(wf_in, magnification_x=2.0):
#
# ===== 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.propagators1D.fresnel_zoom import FresnelZoom1D
input_wavefront = wf_in.duplicate()
#
# info on current oe
#
#
# -------WOScreen1D---------
# -------BoundaryShape---------
#
#
# define current oe
#
from wofry.beamline.optical_elements.ideal_elements.screen import WOScreen1D
optical_element = WOScreen1D()
#
# propagating (*** ONLY THE ZOOM PROPAGATOR IS IMPLEMENTED ***)
#
#
propagation_elements = PropagationElements()
beamline_element = BeamlineElement(optical_element=optical_element,
coordinates=ElementCoordinates(p=0.000000, q=13.599000,
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', magnification_x)
#
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 apply_M3_focusing(wf_in,focal_x=2.407000):
#
# ===== 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.propagators1D.fresnel_zoom import FresnelZoom1D
input_wavefront = wf_in.duplicate()
#
# info on current oe
#
#
# -------WOIdealLens---------
# focal_x: 2.407 m # Focal length in x [horizontal]
# focal_y: None 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=focal_x, focal_y=None)
#
# 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('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 __init__(self):
super().__init__(name="WISEr Tools")
self.openContainer()
self.addContainer("Propagation Mode")
self.addSubMenu("Element by Element")
self.addSubMenu("Whole beamline at Detector")
self.closeContainer()
PropagationManager.Instance().set_propagation_mode(WISE_APPLICATION, PropagationMode.STEP_BY_STEP)
def initialize_propagator_2D():
propagation_manager = PropagationManager.Instance()
if not propagation_manager.is_initialized(SRW_APPLICATION):
if not propagation_manager.has_propagator(FresnelSRWNative.HANDLER_NAME, WavefrontDimension.TWO): propagation_manager.add_propagator(FresnelSRWNative())
if not propagation_manager.has_propagator(FresnelSRWWofry.HANDLER_NAME, WavefrontDimension.TWO): propagation_manager.add_propagator(FresnelSRWWofry())
propagation_manager.set_propagation_mode(SRW_APPLICATION, SRWPropagationMode.STEP_BY_STEP)
propagation_manager.set_initialized(True)
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 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 executeAction_4(self, action):
try:
for node in self.canvas_main_window.current_document().scheme().nodes:
widget = self.canvas_main_window.current_document().scheme().widget_for_node(node)
if isinstance(widget, OWSRWScreen):
if hasattr(widget, "is_final_screen") and hasattr(widget, "set_is_final_screen"):
if (PropagationManager.Instance().get_propagation_mode(SRW_APPLICATION) != SRWPropagationMode.WHOLE_BEAMLINE):
raise Exception("Action possibile only while Propagation Mode: Whole beamline at Final Screen (SRW Native)")
if hasattr(widget, "show_view_box") and getattr(widget, "show_view_box"):
widget.is_final_screen = 0
widget.set_is_final_screen()
except Exception as exception:
showCriticalMessage(exception.args[0])
def executeAction_6(self, action):
try:
for node in self.canvas_main_window.current_document().scheme().nodes:
widget = self.canvas_main_window.current_document().scheme().widget_for_node(node)
if isinstance(widget, SRWWidget) and not (isinstance(widget, OWSRWIntensityPlotter) or
isinstance(widget, OWSRWDegCohPlotter) or
isinstance(widget, OWSRWAccumulationPoint)):
if hasattr(widget, "view_type") and hasattr(widget, "set_PlotQuality"):
if (PropagationManager.Instance().get_propagation_mode(SRW_APPLICATION) == SRWPropagationMode.WHOLE_BEAMLINE):
raise Exception("Action not possibile while Propagation Mode: Whole beamline at Final Screen (SRW Native)")
if hasattr(widget, "show_view_box") and getattr(widget, "show_view_box"):
widget.view_type = 1
widget.set_PlotQuality()
except Exception as exception:
showCriticalMessage(exception.args[0])
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 set_srw_live_propagation_mode(self):
for node in self.canvas_main_window.current_document().scheme().nodes:
widget = self.canvas_main_window.current_document().scheme().widget_for_node(node)
if hasattr(widget, "set_srw_live_propagation_mode"):
widget.set_srw_live_propagation_mode()
if (PropagationManager.Instance().get_propagation_mode(SRW_APPLICATION) == SRWPropagationMode.WHOLE_BEAMLINE):
if not (isinstance(widget, OWSRWScreen) or
isinstance(widget, OWSRWIntensityPlotter) or
isinstance(widget, OWSRWDegCohPlotter) or
isinstance(widget, OWSRWAccumulationPoint)) \
or getattr(widget, "is_final_screen") == False:
if hasattr(widget, "view_type") and hasattr(widget, "set_PlotQuality"):
if hasattr(widget, "show_view_box") and getattr(widget, "show_view_box"):
widget.view_type = 0
widget.set_PlotQuality()
if isinstance(widget, OWSRWScreen): widget.set_is_final_screen()
def set_srw_live_propagation_mode(self):
propagation_mode = PropagationManager.Instance().get_propagation_mode(SRW_APPLICATION)
self.srw_live_propagation_mode = "Element by Element (Native)" if propagation_mode == SRWPropagationMode.STEP_BY_STEP else \
"Whole beamline at Final Screen (Native)" if propagation_mode == SRWPropagationMode.WHOLE_BEAMLINE else \
"Element by Element (Wofry)" if propagation_mode == SRWPropagationMode.STEP_BY_STEP_WOFRY else \
"Unknown"
palette = QPalette(self.le_srw_live_propagation_mode.palette())
color = 'dark green' if propagation_mode == SRWPropagationMode.STEP_BY_STEP else \
'dark red' if propagation_mode == SRWPropagationMode.WHOLE_BEAMLINE else \
'dark blue' if propagation_mode == SRWPropagationMode.STEP_BY_STEP_WOFRY else \
'black'
palette.setColor(QPalette.Text, QColor(color))
palette.setColor(QPalette.Base, QColor(243, 240, 140))
self.le_srw_live_propagation_mode.setPalette(palette)
if self.show_view_box and propagation_mode==SRWPropagationMode.WHOLE_BEAMLINE: self.view_type = 0
def do_propagation(self, parameters=PropagationParameters()):
wavefront = parameters.get_wavefront()
is_generic_wavefront = isinstance(wavefront, GenericWavefront2D)
if is_generic_wavefront:
wavefront = SRWWavefront.fromGenericWavefront(wavefront)
else:
if not isinstance(wavefront, SRWWavefront):
raise ValueError(
"wavefront cannot be managed by this propagator")
srw_oe_array = []
srw_pp_array = []
propagation_mode = PropagationManager.Instance().get_propagation_mode(
SRW_APPLICATION)
if propagation_mode == SRWPropagationMode.STEP_BY_STEP:
self.add_optical_element(parameters, 0, srw_oe_array, srw_pp_array,
wavefront)
elif propagation_mode == SRWPropagationMode.WHOLE_BEAMLINE:
srw_beamline = parameters.get_additional_parameter(
"working_beamline")
for index in range(srw_beamline.get_beamline_elements_number()):
self.add_optical_element_from_beamline(srw_beamline, index,
srw_oe_array,
srw_pp_array, wavefront)
else:
raise ValueError(
"Propagation Mode not supported by this Propagator")
if len(srw_oe_array) > 0:
optBL = SRWLOptC(srw_oe_array, srw_pp_array)
srwl.PropagElecField(wavefront, optBL)
if is_generic_wavefront:
return wavefront.toGenericWavefront()
else:
return wavefront
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 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