def completeOperations(self, shadow_oe=None):
self.setStatusMessage("Running SHADOW")
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
self.progressBarSet(50)
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
beam_out = ShadowBeam.traceFromOE(self.input_beam, shadow_oe)
self.adjust_divergence_and_intensity(beam_out)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
self.setStatusMessage("Plotting Results")
self.plot_results(beam_out)
self.setStatusMessage("")
self.send("Beam", beam_out)
self.send("Trigger", ShadowTriggerIn(new_beam=True))
def completeOperations(self, shadow_oe=None):
self.setStatusMessage("Running SHADOW")
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
self.progressBarSet(50)
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
beam_out = ShadowBeam.traceFromOE(self.input_beam, shadow_oe)
self.adjust_divergence_and_intensity(beam_out)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
self.setStatusMessage("Plotting Results")
self.plot_results(beam_out)
self.setStatusMessage("")
self.send("Beam", beam_out)
self.send("Trigger", ShadowTriggerIn(new_beam=True))
def retrace(self):
try:
if not self.input_beam is None:
output_beam = self.input_beam.duplicate(history=True)
empty_element = ShadowOpticalElement.create_empty_oe()
empty_element._oe.DUMMY = 1.0 # self.workspace_units_to_cm
empty_element._oe.T_SOURCE = 0.0
empty_element._oe.T_IMAGE = self.retrace_distance
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
output_beam = ShadowBeam.traceFromOE(output_beam, empty_element, history=True)
self.setStatusMessage("Plotting Results")
self.plot_results(output_beam)
self.setStatusMessage("")
self.progressBarFinished()
self.send("Beam", output_beam)
self.send("Trigger", TriggerIn(new_object=True))
except Exception as exception:
QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
if self.IS_DEVELOP: raise exception
def get_zone_plate_beam(self): # WS Units
empty_element = ShadowOpticalElement.create_empty_oe()
empty_element._oe.DUMMY = self.workspace_units_to_cm
empty_element._oe.T_SOURCE = self.source_plane_distance
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
n_screen = 1
i_screen = numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
i_abs = numpy.zeros(10)
i_slit = numpy.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
i_stop = numpy.zeros(10)
k_slit = numpy.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
thick = numpy.zeros(10)
file_abs = numpy.array(['', '', '', '', '', '', '', '', '', ''])
rx_slit = numpy.zeros(10)
rz_slit = numpy.zeros(10)
sl_dis = numpy.zeros(10)
file_scr_ext = numpy.array(['', '', '', '', '', '', '', '', '', ''])
cx_slit = numpy.zeros(10)
cz_slit = numpy.zeros(10)
sl_dis[0] = 0.0
rx_slit[0] = self.diameter*1e-6/self.workspace_units_to_m
rz_slit[0] = self.diameter*1e-6/self.workspace_units_to_m
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)
output_beam = ShadowBeam.traceFromOE(self.input_beam, empty_element, history=True)
go = numpy.where(output_beam._beam.rays[:, 9] == GOOD)
lo = numpy.where(output_beam._beam.rays[:, 9] != GOOD)
print("Zone Plate Beam: ", "GO", len(go[0]), "LO", len(lo[0]))
return output_beam
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:
QtGui.QMessageBox.critical(self, "Error",
str(exception), QtGui.QMessageBox.Ok)
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 get_output_beam(self, focused_beam):
empty_element = ShadowOpticalElement.create_empty_oe()
empty_element._oe.DUMMY = 1.0 # self.workspace_units_to_cm
empty_element._oe.T_SOURCE = 0.0
empty_element._oe.T_IMAGE = self.image_plane_distance
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 ShadowBeam.traceFromOE(focused_beam, empty_element, history=True)
def traceOpticalElement(self):
try:
self.error(self.error_id)
self.setStatusMessage("")
self.progressBarInit()
if ShadowCongruence.checkEmptyBeam(self.input_beam):
if ShadowCongruence.checkGoodBeam(self.input_beam):
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.progressBarSet(10)
self.checkFields()
self.setStatusMessage("Running SHADOW")
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
self.progressBarSet(50)
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
shadow_oe_1 = ShadowOpticalElement.create_screen_slit()
self.populateFields_1(shadow_oe_1)
beam_out = ShadowBeam.traceFromOE(self.input_beam, shadow_oe_1)
self.adjust_first_divergence(beam_out)
self.progressBarSet(60)
shadow_oe_2 = ShadowOpticalElement.create_screen_slit()
self.populateFields_2(shadow_oe_2)
beam_out = ShadowBeam.traceFromOE(beam_out, shadow_oe_2)
self.adjust_second_divergence_and_intensity(beam_out)
self.progressBarSet(70)
shadow_oe_3 = ShadowOpticalElement.create_screen_slit()
self.populateFields_3(shadow_oe_3)
beam_out = ShadowBeam.traceFromOE(beam_out, shadow_oe_3)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
self.setStatusMessage("Plotting Results")
self.plot_results(beam_out)
self.setStatusMessage("")
self.send("Beam", beam_out)
self.send("Trigger", TriggerIn(new_object=True))
else:
raise Exception("Input Beam with no good rays")
else:
raise Exception("Empty Input Beam")
except Exception as exception:
QtWidgets.QMessageBox.critical(self, "QMessageBox.critical()",
str(exception),
QtWidgets.QMessageBox.Ok)
self.error_id = self.error_id + 1
self.error(self.error_id, "Exception occurred: " + str(exception))
self.progressBarFinished()
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
file_scr_ext = numpy.array(['', '', '', '', '', '', '', '', '', ''])
cx_slit = numpy.zeros(10)
cz_slit = numpy.zeros(10)
sl_dis[0] = 0.0
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
def completeOperations(self, shadow_oe):
shadow_oe_temp = shadow_oe.duplicate()
input_beam_temp = self.input_beam.duplicate(history=False)
self.manage_acceptance_slits(shadow_oe_temp)
ShadowBeam.traceFromOE(input_beam_temp,
shadow_oe_temp,
write_start_file=0,
write_end_file=0,
widget_class_name=type(self).__name__)
x, y, z = self.calculate_ideal_surface(shadow_oe_temp)
bender_parameter, z_bender_correction = self.calculate_bender_correction(
y, z, self.kind_of_bender, self.shape)
self.M1_out = round(bender_parameter[0],
int(6 * self.workspace_units_to_mm))
if self.shape == TRAPEZIUM:
self.e_out = round(bender_parameter[1], 5)
if self.kind_of_bender == DOUBLE_MOMENTUM:
self.ratio_out = round(bender_parameter[2], 5)
elif self.shape == RECTANGLE:
if self.kind_of_bender == DOUBLE_MOMENTUM:
self.ratio_out = round(bender_parameter[1], 5)
self.plot3D(x, y, z_bender_correction, 2, "Ideal - Bender Surfaces")
if self.modified_surface > 0:
x_e, y_e, z_e = ShadowPreProcessor.read_surface_error_file(
self.ms_defect_file_name)
if len(x) == len(x_e) and len(y) == len(y_e) and \
x[0] == x_e[0] and x[-1] == x_e[-1] and \
y[0] == y_e[0] and y[-1] == y_e[-1]:
z_figure_error = z_e
else:
z_figure_error = interp2d(y_e, x_e, z_e, kind='cubic')(y, x)
z_bender_correction += z_figure_error
self.plot3D(x, y, z_figure_error, 3, "Figure Error Surface")
self.plot3D(x, y, z_bender_correction, 4,
"Ideal - Bender + Figure Error Surfaces")
ST.write_shadow_surface(z_bender_correction.T, numpy.round(x, 6),
numpy.round(y, 6), self.output_file_name_full)
# Add new surface as figure error
shadow_oe._oe.F_RIPPLE = 1
shadow_oe._oe.F_G_S = 2
shadow_oe._oe.FILE_RIP = bytes(self.output_file_name_full, 'utf-8')
# Redo Raytracing with the new file
super().completeOperations(shadow_oe)
self.send(
"PreProcessor_Data",
ShadowPreProcessorData(
error_profile_data_file=self.output_file_name,
error_profile_x_dim=self.dim_x_plus + self.dim_x_minus,
error_profile_y_dim=self.dim_y_plus + self.dim_y_minus))
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()
def traceOpticalElement(self):
try:
self.error(self.error_id)
self.setStatusMessage("")
self.progressBarInit()
if ShadowCongruence.checkEmptyBeam(self.input_beam):
if ShadowCongruence.checkGoodBeam(self.input_beam):
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.progressBarSet(10)
self.checkFields()
self.setStatusMessage("Running SHADOW")
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
self.progressBarSet(50)
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
shadow_oe_1 = ShadowOpticalElement.create_screen_slit()
self.populateFields_1(shadow_oe_1)
beam_out = ShadowBeam.traceFromOE(self.input_beam, shadow_oe_1)
self.adjust_first_divergence(beam_out)
self.progressBarSet(60)
shadow_oe_2 = ShadowOpticalElement.create_screen_slit()
self.populateFields_2(shadow_oe_2)
beam_out = ShadowBeam.traceFromOE(beam_out, shadow_oe_2)
self.adjust_second_divergence_and_intensity(beam_out)
self.progressBarSet(70)
shadow_oe_3 = ShadowOpticalElement.create_screen_slit()
self.populateFields_3(shadow_oe_3)
beam_out = ShadowBeam.traceFromOE(beam_out, shadow_oe_3)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
self.setStatusMessage("Plotting Results")
self.plot_results(beam_out)
self.setStatusMessage("")
self.send("Beam", beam_out)
self.send("Trigger", ShadowTriggerIn(new_beam=True))
else:
raise Exception("Input Beam with no good rays")
else:
raise Exception("Empty Input 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()
