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