def runSimulation(self): try: self.error(self.error_id) self.setStatusMessage("") self.progressBarInit() if not self.beamline_parameters is None: driver = ShadowDriver() sys.stdout = EmittingStream(textWritten=self.writeStdOut) self.setStatusMessage("Running SHADOW simulation") self.progressBarSet(50) ########################################### # TODO: TO BE ADDED JUST IN CASE OF BROKEN # ENVIRONMENT: MUST BE FOUND A PROPER WAY # TO TEST SHADOW self.fixWeirdShadowBug() ########################################### ShadowGui.checkStrictlyPositiveNumber(self.beamline_parameters._energy_min, "Energy Min") ShadowGui.checkStrictlyPositiveNumber(self.beamline_parameters._energy_max, "Energy Max") shadow_beam = driver.calculate_radiation(self.beamline_parameters._electron_beam, self.beamline_parameters._magnetic_structure, self.beamline_parameters._beamline, self.beamline_parameters._energy_min, self.beamline_parameters._energy_max) self.setStatusMessage("Plotting Results") self.plot_results(shadow_beam) self.setStatusMessage("") self.send("Beam", shadow_beam) except Exception as exception: QtGui.QMessageBox.critical(self, "QMessageBox.critical()", str(exception), QtGui.QMessageBox.Ok) self.error_id = self.error_id + 1 self.error(self.error_id, "Exception occurred: " + str(exception)) self.progressBarFinished()
def run_bending_magnet_shadow3(example_index):# example_index=0 is infrared example, example_index=1 is xrays example ################################################################################################### # Main idea: abstract definition of the setting (electron beam, radiation source, beamline) # We want to put everything in generic classes that is independent of a specific implementation. # These are basically the information a scientist would need to physically build the beamline. # # Then, we need extra information/settings to perform a calculation. And the extra settings # vary for different programs. We provide these extra information by attaching program depended # "settings". ################################################################################################### # Specify to use Shadow driver = ShadowDriver() # # 1) define first the electron beam # if example_index == 0: energy_in_GeV = 3.0 electron_beam = ElectronBeamPencil(energy_in_GeV=energy_in_GeV,energy_spread=0.89e-3,current=0.5) # electron_beam = ElectronBeam(energy_in_GeV=energy_in_GeV, # energy_spread=0.89e-03, # current=0.5, # electrons_per_bunch=500, # moment_xx = (127.346e-6)**2 , # moment_xxp = 0. , # moment_xpxp = 100*(91.88e-6)**2, # moment_yy = (92.3093e-6)**2 , # moment_yyp = 0 , # moment_ypyp = 100*(7.94e-6)**2 ) else: energy_in_GeV = 6.0 #electron_beam = ElectronBeamPencil(energy_in_GeV=energy_in_GeV,energy_spread=0.89e-3,current=0.2) electron_beam = ElectronBeam(energy_in_GeV=energy_in_GeV, energy_spread=0.89e-03, current=0.2, electrons_per_bunch=500, moment_xx = (77.9e-06)**2 , moment_xxp = 0. , moment_xpxp = (110.9e-06)**2, moment_yy = (12.9e-06)**2 , moment_yyp = 0 , moment_ypyp = (0.5e-06)**2 ) # # 2) define the magnetic structure # if example_index == 0: fan_divergence = 0.1 magnetic_field = 0.4 else: fan_divergence = 0.004 magnetic_field = 0.8 radius = 3.334728 * energy_in_GeV / magnetic_field bending_magnet = BendingMagnet(radius=radius,magnetic_field=magnetic_field,length=radius*fan_divergence) # Attach SHADOW bending magnet settings. shadow_bending_magnet_settings = ShadowBendingMagnetSetting() if example_index == 0: shadow_bending_magnet_settings._number_of_rays = 5000 shadow_bending_magnet_settings._calculation_mode = 1 shadow_bending_magnet_settings._max_vertical_half_divergence_from = 0.01 shadow_bending_magnet_settings._max_vertical_half_divergence_to = 0.01 else: shadow_bending_magnet_settings._number_of_rays = 26000 calculation_mode = 1 # exact calculation if calculation_mode == 1: #for exact calculations, the max divergence has to be set to reasonable values shadow_bending_magnet_settings._calculation_mode = 1 shadow_bending_magnet_settings._max_vertical_half_divergence_from = 0.04 shadow_bending_magnet_settings._max_vertical_half_divergence_to = 0.04 else: #for pre-computer calculations, the max divergence can be set to a very large value (1rad~infinity) shadow_bending_magnet_settings._calculation_mode = 0 shadow_bending_magnet_settings._max_vertical_half_divergence_from = 1.0 shadow_bending_magnet_settings._max_vertical_half_divergence_to = 1.0 bending_magnet.add_settings(shadow_bending_magnet_settings) # # 3) define beamline containing the optical elements # In this case, create a beamline that only has one lens attached plus an image (detector) plane # # beamline = Beamline() if example_index == 0: lens_focal_length = 2.5 else: lens_focal_length = 12.5 # First create the lens. lens=LensIdeal("focus lens", focal_x=lens_focal_length, focal_y=lens_focal_length) # Specify the position of the lens (could set extra parameters for: off-axis and inclination) lens_position = BeamlinePosition(2*lens_focal_length) # Attach the component at its position to the beamline. beamline.attach_component_at(lens, lens_position) # Attach a screen/image plane. plane_position = BeamlinePosition(4*lens_focal_length) beamline.attach_component_at(ImagePlane("Image screen"), plane_position) # # Print a summary of the elements used # components = [electron_beam,bending_magnet,lens] print("===========================================================================================================") for component_index,component in enumerate(components): tmp = component.to_dictionary() print("Component index %d:"%component_index,inspect.getmodule(component)) for i,var in enumerate(tmp): print(" %20s = %10.5e %5s %s"%(var,tmp[var][0],tmp[var][1],tmp[var][2])) print("===========================================================================================================") # # Calculate the radiation (i.e., run the codes). It returns a native Shadow.Beam() # if example_index == 0: energy = 0.5*0.123984 else: energy = 15000.0 shadow_beam = driver.calculate_radiation(electron_beam=electron_beam, magnetic_structure=bending_magnet, beamline=beamline, energy_min = energy, energy_max = energy) #shadow_beam._beam.write("tmp.01") # # extract and plot the intensity # intensity,dim_x,dim_y = driver.calculate_intensity(shadow_beam) # # clean temporary shadow files # # if example_index == 0: os.remove("SPER00000") os.remove("FLUX") os.remove("SPAR00000") os.remove("STOT00000") else: os.remove("SPER15000") os.remove("FLUX") os.remove("SPAR15000") os.remove("STOT15000") return shadow_beam, dim_x, dim_y, intensity