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 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()
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 calculate_footprint(self):
self.setStatusMessage("")
try:
beam_out = self.footprint_beam.duplicate()
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)
total_power = self.input_beam.scanned_variable_data.get_additional_parameter(
"total_power")
additional_parameters = {}
additional_parameters["total_power"] = total_power
additional_parameters[
"photon_energy_step"] = self.input_beam.scanned_variable_data.get_additional_parameter(
"photon_energy_step")
additional_parameters["is_footprint"] = True
n_rays = len(beam_out._beam.rays[:, 0]) # lost and good!
incident_beam = self.input_beam.getOEHistory(
self.input_beam._oe_number)._input_beam
ticket = incident_beam._beam.histo2(1,
3,
nbins=100,
xrange=None,
yrange=None,
nolost=1,
ref=23)
ticket['histogram'] *= (total_power / n_rays) # power
additional_parameters["incident_power"] = ticket['histogram'].sum()
if self.kind_of_power == 0: # incident
beam_out._beam.rays[:, 6] = incident_beam._beam.rays[:, 6]
beam_out._beam.rays[:, 7] = incident_beam._beam.rays[:, 7]
beam_out._beam.rays[:, 8] = incident_beam._beam.rays[:, 8]
beam_out._beam.rays[:, 15] = incident_beam._beam.rays[:, 15]
beam_out._beam.rays[:, 16] = incident_beam._beam.rays[:, 16]
beam_out._beam.rays[:, 17] = incident_beam._beam.rays[:, 17]
elif self.kind_of_power == 1: # absorbed
# need a trick: put the whole intensity of one single component
incident_intensity = incident_beam._beam.rays[:, 6]**2 + incident_beam._beam.rays[:, 7]**2 + incident_beam._beam.rays[:, 8]**2 +\
incident_beam._beam.rays[:, 15]**2 + incident_beam._beam.rays[:, 16]**2 + incident_beam._beam.rays[:, 17]**2
transmitted_intensity = beam_out._beam.rays[:, 6]**2 + beam_out._beam.rays[:, 7]**2 + beam_out._beam.rays[:, 8]**2 +\
beam_out._beam.rays[:, 15]**2 + beam_out._beam.rays[:, 16]**2 + beam_out._beam.rays[:, 17]**2
electric_field = numpy.sqrt(incident_intensity -
transmitted_intensity)
electric_field[numpy.where(electric_field == numpy.nan)] = 0.0
beam_out._beam.rays[:, 6] = electric_field
beam_out._beam.rays[:, 7] = 0.0
beam_out._beam.rays[:, 8] = 0.0
beam_out._beam.rays[:, 15] = 0.0
beam_out._beam.rays[:, 16] = 0.0
beam_out._beam.rays[:, 17] = 0.0
beam_out.setScanningData(
ShadowBeam.ScanningData(
self.input_beam.scanned_variable_data.
get_scanned_variable_name(),
self.input_beam.scanned_variable_data.
get_scanned_variable_value(),
self.input_beam.scanned_variable_data.
get_scanned_variable_display_name(),
self.input_beam.scanned_variable_data.
get_scanned_variable_um(), additional_parameters))
self.send("Beam", beam_out)
except Exception as exception:
QtWidgets.QMessageBox.critical(self, "Error", str(exception),
QtWidgets.QMessageBox.Ok)