def convertMapToBeam(self, map): number_of_rays = len(map) if number_of_rays == 0: return None beam_out = ShadowBeam(number_of_rays=number_of_rays) for index in range(0, number_of_rays): point = map[index] ray = beam_out._beam.rays[index] E_value = numpy.sqrt(point.value * 0.5) ray[0] = point.x # X ray[1] = point.y # Y ray[2] = point.z # Z ray[3] = 0 # director cos x ray[4] = 1 # director cos y ray[5] = 0 # director cos z ray[6] = 0 # Es_x ray[7] = E_value # Es_y ray[8] = 0 # Es_z ray[9] = 1 # good/lost ray[10] = 2 * numpy.pi / 1.5e-8 ray[11] = index # ray index ray[12] = 1 # good only ray[13] = numpy.pi * 0.5 # Es_phi ray[14] = numpy.pi * 0.5 # Ep_phi ray[15] = 0 # Ep_x ray[16] = E_value # Ep_y ray[17] = 0 # Ep_z return beam_out
def replace_spectro_fig(self, rays_to_plot, var_x, factor_x, xrange, title, color): try: beam = ShadowBeam() beam._beam.rays = rays_to_plot ticket = beam._beam.histo1(var_x, nbins=self.number_of_bins, xrange=xrange, nolost=self.rays, ref=self.weight_column_index) if self.weight_column_index != 0: self.spectro_plot_canvas.setGraphYLabel( "Number of rays weighted by " + ShadowPlot.get_shadow_label(self.weight_column_index)) else: self.spectro_plot_canvas.setGraphYLabel("Number of Rays") histogram = ticket['histogram_path'] bins = ticket['bin_path'] * factor_x self.spectro_plot_canvas.addCurve(bins, histogram, title, symbol='', color=color, replace=False) #'+', '^', ',' except Exception as e: print(e) raise Exception("Data not plottable: No good rays or bad content")
def plot_results(self, beam_out, footprint_beam=None, progressBarValue=80): if not self.view_type == 2: if ShadowCongruence.checkEmptyBeam(beam_out): if ShadowCongruence.checkGoodBeam(beam_out): self.view_type_combo.setEnabled(False) ShadowPlot.set_conversion_active(self.getConversionActive()) if self.isFootprintEnabled() and footprint_beam is None: footprint_beam = ShadowBeam() if beam_out._oe_number < 10: footprint_beam.loadFromFile(file_name="mirr.0" + str(beam_out._oe_number)) else: footprint_beam.loadFromFile(file_name="mirr." + str(beam_out._oe_number)) variables = self.getVariablestoPlot() titles = self.getTitles() xtitles = self.getXTitles() ytitles = self.getYTitles() xums = self.getXUM() yums = self.getYUM() try: if self.view_type == 1: self.plot_xy_fast(beam_out, progressBarValue + 4, variables[0][0], variables[0][1], plot_canvas_index=0, title=titles[0], xtitle=xtitles[0], ytitle=ytitles[0]) self.plot_xy_fast(beam_out, progressBarValue + 8, variables[1][0], variables[1][1], plot_canvas_index=1, title=titles[1], xtitle=xtitles[1], ytitle=ytitles[1]) self.plot_xy_fast(beam_out, progressBarValue + 12, variables[2][0], variables[2][1], plot_canvas_index=2, title=titles[2], xtitle=xtitles[2], ytitle=ytitles[2]) self.plot_xy_fast(beam_out, progressBarValue + 16, variables[3][0], variables[3][1], plot_canvas_index=3, title=titles[3], xtitle=xtitles[3], ytitle=ytitles[3]) self.plot_histo_fast(beam_out, progressBarValue + 20, variables[4], plot_canvas_index=4, title=titles[4], xtitle=xtitles[4], ytitle=ytitles[4]) if self.isFootprintEnabled(): self.plot_xy_fast(footprint_beam, progressBarValue + 20, 2, 1, plot_canvas_index=5, title="Footprint", xtitle="Y [" + self.workspace_units_label +"]", ytitle="X [" + self.workspace_units_label +"]", is_footprint=True) elif self.view_type == 0: self.plot_xy(beam_out, progressBarValue + 4, variables[0][0], variables[0][1], plot_canvas_index=0, title=titles[0], xtitle=xtitles[0], ytitle=ytitles[0], xum=xums[0], yum=yums[0]) self.plot_xy(beam_out, progressBarValue + 8, variables[1][0], variables[1][1], plot_canvas_index=1, title=titles[1], xtitle=xtitles[1], ytitle=ytitles[1], xum=xums[1], yum=yums[1]) self.plot_xy(beam_out, progressBarValue + 12, variables[2][0], variables[2][1], plot_canvas_index=2, title=titles[2], xtitle=xtitles[2], ytitle=ytitles[2], xum=xums[2], yum=yums[2]) self.plot_xy(beam_out, progressBarValue + 16, variables[3][0], variables[3][1], plot_canvas_index=3, title=titles[3], xtitle=xtitles[3], ytitle=ytitles[3], xum=xums[3], yum=yums[3]) self.plot_histo(beam_out, progressBarValue + 20, variables[4], plot_canvas_index=4, title=titles[4], xtitle=xtitles[4], ytitle=ytitles[4], xum=xums[4] ) if self.isFootprintEnabled(): self.plot_xy(footprint_beam, progressBarValue + 20, 2, 1, plot_canvas_index=5, title="Footprint", xtitle="Y [" + self.workspace_units_label +"]", ytitle="X [" + self.workspace_units_label +"]", xum=("Y [" + self.workspace_units_label +"]"), yum=("X [" + self.workspace_units_label +"]"), is_footprint=True) except Exception as e: self.view_type_combo.setEnabled(True) raise Exception("Data not plottable: No good rays or bad content\nexception: " + str(e)) self.view_type_combo.setEnabled(True) else: raise Exception("Beam with no good rays") else: raise Exception("Empty Beam") self.plotted_beam = beam_out
def convert_wavefront(self): try: if not self.wavefront is None: self.send( "ShadowBeam", ShadowBeam(beam=SHADOW3Wavefront.fromGenericWavefront( wavefront=self.wavefront, shadow_to_meters=self.workspace_units_to_m))) except Exception as exception: QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
def read_shadow_beam(shadow_beam, lost=False): cursor_go = np.where(shadow_beam._beam.rays[:, 9] == 1) image_beam_rays = copy.deepcopy(shadow_beam._beam.rays[cursor_go]) image_beam_rays[:, 11] = np.arange(1, len(image_beam_rays) + 1, 1) out_beam_go = ShadowBeam() out_beam_go._beam.rays = image_beam_rays if lost: cursor_lo = np.where(shadow_beam._beam.rays[:, 9] != 1) lost_rays = copy.deepcopy(shadow_beam._beam.rays[cursor_lo]) lost_rays[:, 11] = np.arange(1, len(lost_rays) + 1, 1) out_beam_lo = ShadowBeam() out_beam_lo._beam.rays = lost_rays return out_beam_go, out_beam_lo else: return out_beam_go
def clearResults(self, interactive=True): if not interactive: proceed = True else: proceed = ConfirmDialog.confirmed(parent=self) if proceed: self.input_beam = ShadowBeam() self.cumulated_ticket = None self.plotted_ticket = None self.autosave_prog_id = 0 if not self.autosave_file is None: self.autosave_file.close() self.autosave_file = None self.plot_canvas.clear()
def convertMapToBeam(self, x0s, x1s): number_of_rays = x0s.size if number_of_rays == 0: return None beam_out = ShadowBeam(number_of_rays=number_of_rays) x = x0s - self.image_nparray.shape[0] / 2 z = x1s - self.image_nparray.shape[1] / 2 x *= self.pixel_size * 1e-6 / self.workspace_units_to_m z *= self.pixel_size * 1e-6 / self.workspace_units_to_m for index in range(0, number_of_rays): ray = beam_out._beam.rays[index] ray[0] = x[index] # X ray[1] = 0.0 # Y ray[2] = z[index] # Z ray[3] = 0 # director cos x ray[4] = 1 # director cos y ray[5] = 0 # director cos z ray[6] = 1.0 / numpy.sqrt(2) # Es_x ray[7] = 0.0 # Es_y ray[8] = 0.0 # Es_z ray[9] = 1 # good/lost ray[10] = 2 * numpy.pi / 1e-8 # wavenumber ray[11] = index # ray index ray[12] = 1 # good only ray[13] = 0.0 # Es_phi ray[14] = 0.0 # Ep_phi ray[15] = 0.0 # Ep_x ray[16] = 0.0 # Ep_y ray[17] = 1.0 / numpy.sqrt(2) # Ep_z return beam_out
def read_file(self): self.setStatusMessage("") try: if congruence.checkFileName(self.beam_file_name): beam_out = ShadowBeam() beam_out.loadFromFile(self.beam_file_name) beam_out.history.append(ShadowOEHistoryItem()) # fake Source beam_out._oe_number = 0 # just to create a safe history for possible re-tracing beam_out.traceFromOE(beam_out, self.create_dummy_oe(), history=True) path, file_name = os.path.split(self.beam_file_name) self.setStatusMessage("Current: " + file_name) self.send("Beam", beam_out) except Exception as exception: QtWidgets.QMessageBox.critical(self, "Error", str(exception), QtWidgets.QMessageBox.Ok)
def from_photon_bunch_to_shadow(self): photon_beam = self.incoming_bunch N = photon_beam.getArrayByKey("number of photons") energies = photon_beam.getArrayByKey("energies") S0 = photon_beam.getArrayByKey("s0") S1 = photon_beam.getArrayByKey("s1") S2 = photon_beam.getArrayByKey("s2") S3 = photon_beam.getArrayByKey("s3") vx = photon_beam.getArrayByKey("vx") vy = photon_beam.getArrayByKey("vy") vz = photon_beam.getArrayByKey("vz") beam = Shadow.Beam(N) A2EV = 2.0 * numpy.pi / (codata.h * codata.c / codata.e * 1e2) for i in range(N): s0 = S0[i] s1 = S1[i] s2 = S2[i] s3 = S3[i] energy = energies[i] if (numpy.abs(s1**2 + s2**2 + s3**2 - s0**2) > 1e-4): s0 = numpy.sqrt(s1**2 + s2**2 + s3**2) print("Warning: Beam is not fully polarized.") Ex2 = 0.5 * (s0 + s1) Ez2 = 0.5 * (s0 - s1) Ex = numpy.sqrt(Ex2) Ez = numpy.sqrt(Ez2) if s0 == s1: sin2delta = 0.0 else: sin2delta = -0.5 * ((s2**2 - s3**2) / (4 * Ex2 * Ez2) - 1) delta = numpy.arcsin(numpy.sign(s3) * numpy.sqrt(sin2delta)) beam.rays[i, 0] = 0.0 # x beam.rays[i, 1] = 0.0 # x beam.rays[i, 2] = 0.0 # x beam.rays[i, 3] = vx[i] # v beam.rays[i, 4] = vy[i] # v beam.rays[i, 5] = vz[i] # v beam.rays[i, 6] = Ex # Es beam.rays[i, 7] = 0.0 # Es beam.rays[i, 8] = 0.0 # Es beam.rays[i, 9] = 1.0 # lost ray flag beam.rays[i, 10] = A2EV * energy # k beam.rays[i, 11] = i # ray index beam.rays[i, 12] = 0.0 # path length beam.rays[i, 13] = 0.0 # phase-s beam.rays[i, 14] = delta # phase-ps beam.rays[i, 15] = 0.0 # Ep beam.rays[i, 16] = 0.0 # Ep beam.rays[i, 17] = Ez # Ep beam_out = ShadowBeam(beam=beam) beam_out.history.append(ShadowOEHistoryItem()) # fake Source beam_out._oe_number = 0 # just to create a safe history for possible re-tracing beam_out.traceFromOE(beam_out, self.create_dummy_oe(), history=True) #self.send("Beam", beam_out) return beam_out
def run_shadow4(self): nTrajPoints = 501 # # syned # syned_electron_beam = self.get_syned_electron_beam() print(syned_electron_beam.info()) # B from file if self.magnetic_field_source == 0: syned_wiggler = Wiggler(K_vertical=self.k_value, K_horizontal=0.0, period_length=self.id_period, number_of_periods=self.number_of_periods) elif self.magnetic_field_source == 1: syned_wiggler = MagneticStructure1DField.initialize_from_file( self.file_with_b_vs_y) elif self.magnetic_field_source == 2: raise Exception(NotImplemented) print(syned_wiggler.info()) sw = SourceWiggler() sourcewiggler = SourceWiggler(name="test", syned_electron_beam=syned_electron_beam, syned_wiggler=syned_wiggler, flag_emittance=True, emin=self.e_min, emax=self.e_max, ng_e=100, ng_j=nTrajPoints) if self.e_min == self.e_max: sourcewiggler.set_energy_monochromatic(self.e_min) # sourcewiggler.set_electron_initial_conditions_by_label(velocity_label="value_at_zero", # position_label="value_at_zero",) sourcewiggler.set_electron_initial_conditions( shift_x_flag=self.shift_x_flag, shift_x_value=self.shift_x_value, shift_betax_flag=self.shift_betax_flag, shift_betax_value=self.shift_betax_value) # sourcewiggler.calculate_radiation() print(sourcewiggler.info()) t00 = time.time() print(">>>> starting calculation...") rays = sourcewiggler.calculate_rays(NRAYS=self.n_rays) t11 = time.time() - t00 print(">>>> time for %d rays: %f s, %f min, " % (self.n_rays, t11, t11 / 60)) print(">>> Results of calculate_radiation") print(">>> trajectory.shape: ", sourcewiggler._result_trajectory.shape) print(">>> cdf: ", sourcewiggler._result_cdf.keys()) calculate_spectrum = True if calculate_spectrum: e, f, w = wiggler_spectrum(sourcewiggler._result_trajectory, enerMin=self.e_min, enerMax=self.e_max, nPoints=500, electronCurrent=self.ring_current, outFile="", elliptical=False) # from srxraylib.plot.gol import plot # plot(e, f, xlog=False, ylog=False, show=False, # xtitle="Photon energy [eV]", ytitle="Flux [Photons/s/0.1%bw]", title="Flux") # plot(e, w, xlog=False, ylog=False, show=True, # xtitle="Photon energy [eV]", ytitle="Spectral Power [E/eV]", title="Spectral Power") beam = Beam3.initialize_from_array(rays) # # wiggler plots # self.plot_widget_all(sourcewiggler, e, f, w) self.shadowoui_beam = ShadowBeam(oe_number=0, beam=beam, number_of_rays=0) self.plot_shadow_all() self.send("Beam", self.shadowoui_beam)
def runShadowSource(self): self.setStatusMessage("") self.progressBarInit() # this is to be able to start the widget out of Oasys try: tmp = self.workspace_units except: self.workspace_units = 'm' self.workspace_units_label = 'm' self.workspace_units_to_m = 1.0 self.workspace_units_to_cm = 1e2 self.workspace_units_to_mm = 1e3 self.checkFields() self.progressBarSet(10) self.setStatusMessage("Running SHADOW") sys.stdout = EmittingStream(textWritten=self.writeStdOut) if self.trace_shadow: grabber = TTYGrabber() grabber.start() self.progressBarSet(50) try: self.shadow_output.setText("") su = Undulator.initialize_as_vertical_undulator( K=self.K, period_length=self.period_length, periods_number=int(self.periods_number)) ebeam = ElectronBeam(energy_in_GeV=self.energy_in_GeV, energy_spread=0.0, current=self.current, number_of_bunches=1, moment_xx=(self.sigma_x)**2, moment_xxp=0.0, moment_xpxp=(self.sigma_divergence_x)**2, moment_yy=(self.sigma_z)**2, moment_yyp=0.0, moment_ypyp=(self.sigma_divergence_z)**2) print(ebeam.info()) codes = ["internal", "pySRU", "SRW"] selected_code = codes[self.code_undul_phot] self.sourceundulator = SourceUndulator( name="shadowOui-Full-Undulator", syned_electron_beam=ebeam, syned_undulator=su, flag_emittance=self.use_emittances_combo, flag_size=self.flag_size, emin=1000, # to be set later emax=1001, # to be set later ng_e=2, # to be set later maxangle=self.maxangle_urad * 1e-6, ng_t=self.ng_t, ng_p=self.ng_p, ng_j=self.ng_j, code_undul_phot=selected_code) if self.set_at_resonance == 0: if self.delta_e == 0: self.sourceundulator.set_energy_box( self.photon_energy, self.photon_energy, 1) else: self.sourceundulator.set_energy_box( self.photon_energy - 0.5 * self.delta_e, self.photon_energy + 0.5 * self.delta_e, self.ng_e) else: self.sourceundulator.set_energy_monochromatic_at_resonance( self.harmonic) if self.delta_e > 0.0: e0, e1, ne = self.sourceundulator.get_energy_box() self.sourceundulator.set_energy_box( e0 - 0.5 * self.delta_e, e0 + 0.5 * self.delta_e, self.ng_e) rays = self.sourceundulator.calculate_rays( user_unit_to_m=self.workspace_units_to_m, F_COHER=self.coherent, SEED=self.seed, NRAYS=self.number_of_rays) if self.plot_aux_graph: self.set_PlotAuxGraphs() print(self.sourceundulator.info()) shadow3_beam = Shadow3Beam(N=rays.shape[0]) shadow3_beam.rays = rays if self.file_to_write_out >= 1: shadow3_beam.write("begin.dat") print("File written to disk: begin.dat") if self.file_to_write_out >= 2: SourceUndulatorInputOutput.write_file_undul_phot_h5( self.sourceundulator.get_result_dictionary(), file_out="radiation.h5", mode="w", entry_name="radiation") beam_out = ShadowBeam(beam=shadow3_beam) beam_out.getOEHistory().append(ShadowOEHistoryItem()) if self.add_power: additional_parameters = {} pd, vx, vy = self.sourceundulator.get_power_density_interpolated_cartesian( ) total_power = self.power_step if self.power_step > 0 else pd.sum( ) * (vx[1] - vx[0]) * (vy[1] - vy[0]) additional_parameters["total_power"] = total_power additional_parameters["photon_energy_step"] = self.delta_e beam_out.setScanningData( ShadowBeam.ScanningData("photon_energy", self.photon_energy, "Energy for Power Calculation", "eV", additional_parameters)) if self.delta_e == 0.0: beam_out.set_initial_flux(self.sourceundulator.get_flux()[0]) self.progressBarSet(80) self.plot_results(beam_out) # # create python script for creating the shadow3 beam and display the script in the standard output # dict_parameters = { "K": self.K, "period_length": self.period_length, "periods_number": self.periods_number, "energy_in_GeV": self.energy_in_GeV, "energy_spread": 0.0, "current": self.current, "number_of_bunches": 1, "moment_xx": (self.sigma_x)**2, "moment_xxp": 0.0, "moment_xpxp": (self.sigma_divergence_x)**2, "moment_yy": (self.sigma_z)**2, "moment_yyp": 0.0, "moment_ypyp": (self.sigma_divergence_z)**2, "name": "shadowOui-Full-Undulator", "flag_emittance": self.use_emittances_combo, "flag_size": self.flag_size, "emin": 1000, # to be set later "emax": 1001, # to be set later "ng_e": 2, # to be set later "maxangle": self.maxangle_urad * 1e-6, "ng_t": self.ng_t, "ng_p": self.ng_p, "ng_j": self.ng_j, "code_undul_phot": selected_code, "user_unit_to_m": self.workspace_units_to_m, "F_COHER": self.coherent, "SEED": self.seed, "NRAYS": self.number_of_rays, "EMIN": self.sourceundulator._EMIN, "EMAX": self.sourceundulator._EMAX, "NG_E": self.sourceundulator._NG_E, "MAXANGLE": self.sourceundulator._MAXANGLE, } # write python script in standard output print(self.script_template().format_map(dict_parameters)) self.setStatusMessage("") self.send("Beam", beam_out) except Exception as exception: QtWidgets.QMessageBox.critical(self, "Error", str(exception), QtWidgets.QMessageBox.Ok) if self.IS_DEVELOP: raise exception self.progressBarFinished()
def sh_readsh(shfilename): image_beam = ShadowBeam() image_beam.loadFromFile(congruence.checkFile(shfilename)) return read_shadow_beam(image_beam)
rx_slit[0] = diameter * 1e-4 rz_slit[0] = diameter * 1e-4 cx_slit[0] = 0.0 cz_slit[0] = 0.0 empty_element._oe.set_screens(n_screen, i_screen, i_abs, sl_dis, i_slit, i_stop, k_slit, thick, file_abs, rx_slit, rz_slit, cx_slit, cz_slit, file_scr_ext) zone_plate_beam = ShadowBeam.traceFromOE(input_beam, empty_element, history=False) go = numpy.where(zone_plate_beam._beam.rays[:, 9] == 1) go_input_beam = ShadowBeam() go_input_beam._beam.rays = copy.deepcopy(zone_plate_beam._beam.rays[go]) ################################################### avg_wavelength = ShadowPhysics.getWavelengthFromShadowK( numpy.average(go_input_beam._beam.rays[:, 10])) * 1e-1 #ANGSTROM->nm print("W", avg_wavelength, "nm") focal_distance = (delta_rn * (1000 * diameter) / avg_wavelength) * 1e-7 # cm image_position = focal_distance * source_distance / (source_distance - focal_distance) magnification = numpy.abs(image_position / source_distance) print("FD", focal_distance, "cm")
empty_element._oe.DUMMY = 1.0 # self.workspace_units_to_cm empty_element._oe.T_SOURCE = 0.0 empty_element._oe.T_IMAGE = 0.0 empty_element._oe.T_INCIDENCE = 0.0 empty_element._oe.T_REFLECTION = 180.0 empty_element._oe.ALPHA = 0.0 empty_element._oe.FWRITE = 3 empty_element._oe.F_ANGLE = 0 return empty_element app = QApplication(sys.argv) w = PlotScatter() # load a Beam from orangecontrib.shadow.util.shadow_objects import ShadowOEHistoryItem beam_out = ShadowBeam() beam_out.loadFromFile("/home/manuel/Oasys/mirr.02") beam_out.history.append(ShadowOEHistoryItem()) # fake Source beam_out._oe_number = 0 # just to create a safe history for possible re-tracing beam_out.traceFromOE(beam_out, create_dummy_oe(), history=True) w.workspace_units_to_cm = 1.0 w.setBeam(beam_out) w.show() app.exec() w.saveSettings()