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()
