def doSpecificSetting(self, shadow_oe):
n_screen = 1
i_screen = numpy.zeros(10) # after
i_abs = numpy.zeros(10)
i_slit = numpy.zeros(10)
i_stop = numpy.zeros(10)
k_slit = numpy.zeros(10)
thick = numpy.zeros(10)
file_abs = ['', '', '', '', '', '', '', '', '', '']
rx_slit = numpy.zeros(10)
rz_slit = numpy.zeros(10)
sl_dis = numpy.zeros(10)
file_scr_ext = ['', '', '', '', '', '', '', '', '', '']
cx_slit = numpy.zeros(10)
cz_slit = numpy.zeros(10)
i_abs[0] = self.absorption
i_slit[0] = self.aperturing
if self.aperturing == 1:
i_stop[0] = self.open_slit_solid_stop
k_slit[0] = self.aperture_shape
if self.aperture_shape == 2:
file_scr_ext[0] = bytes(congruence.checkFileName(self.external_file_with_coordinate), 'utf-8')
else:
rx_slit[0] = self.slit_width_xaxis
rz_slit[0] = self.slit_height_zaxis
cx_slit[0] = self.slit_center_xaxis
cz_slit[0] = self.slit_center_zaxis
if self.absorption == 1:
thick[0] = self.thickness
file_abs[0] = bytes(congruence.checkFileName(self.opt_const_file_name), 'utf-8')
shadow_oe._oe.set_screens(n_screen,
i_screen,
i_abs,
sl_dis,
i_slit,
i_stop,
k_slit,
thick,
numpy.array(file_abs),
rx_slit,
rz_slit,
cx_slit,
cz_slit,
numpy.array(file_scr_ext))
def paste_src_parameters(self):
global shadow_src_to_copy
if not shadow_src_to_copy is None:
try:
if "BendingMagnet" in shadow_src_to_copy.source_type and not "BendingMagnet" in str(self.__class__):
raise Exception("Paste Parameters not allowed:\nDestination Source is not a BendingMagnet")
elif "Undulator" in shadow_src_to_copy.source_type and not "Undulator" in str(self.__class__):
raise Exception("Paste Parameters not allowed:\nDestination Source is not an Undulator")
elif "Geometrical" in shadow_src_to_copy.source_type and not "Geometrical" in str(self.__class__):
raise Exception("Paste Parameters not allowed:\nDestination Source is not a Geometrical Source")
elif "Wiggler" in shadow_src_to_copy.source_type and not "Wiggler" in str(self.__class__):
raise Exception("Paste Parameters not allowed:\nDestination Source is not a Wiggler")
if QMessageBox.information(self, "Confirm Operation",
"Confirm Paste Operation?",
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
shadow_temp_file = congruence.checkFileName("tmp_src_buffer.dat")
shadow_src_to_copy.src.write(shadow_temp_file)
shadow_file, type = ShadowFile.readShadowFile(shadow_temp_file)
self.deserialize(shadow_file)
#os.remove(shadow_temp_file)
except Exception as exception:
QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
def generate_heigth_profile_file(self, not_interactive_mode=False):
if not self.zz is None and not self.yy is None and not self.xx is None:
try:
congruence.checkDir(self.heigth_profile_file_name)
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
ST.write_shadow_surface(self.zz, self.xx, self.yy, outFile=congruence.checkFileName(self.heigth_profile_file_name))
if not not_interactive_mode:
QMessageBox.information(self, "QMessageBox.information()",
"Height Profile file " + self.heigth_profile_file_name + " written on disk",
QMessageBox.Ok)
if self.modify_y == 0:
dimension_y = self.si_to_user_units * (self.server.y[-1] - self.server.y[0])
if self.modify_y == 1:
dimension_y = self.si_to_user_units * (self.server.y[-1] - self.server.y[0]) * self.scale_factor_y
elif self.modify_y == 2:
dimension_y = self.new_length
self.send("PreProcessor_Data", ShadowPreProcessorData(error_profile_data_file=self.heigth_profile_file_name,
error_profile_x_dim=self.dimension_x,
error_profile_y_dim=dimension_y))
except Exception as exception:
QMessageBox.critical(self, "Error",
exception.args[0],
QMessageBox.Ok)
def write_inp_file(self):
try:
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.check_fields()
file_name = congruence.checkFileName(self.waviness_file_name.split(sep=".dat")[0] + ".inp")
dict = {}
dict["npointx"] = self.number_of_points_x
dict["npointy"] = self.number_of_points_y
dict["xlength"] = self.dimension_y
dict["width"] = self.dimension_x
dict["slp"] = self.estimated_slope_error
dict["iseed"] = self.montecarlo_seed
dict["file"] = self.waviness_file_name.strip('\n\r')
dict["nharmonics"] = self.harmonic_maximum_index
dict["c"] = self.to_float_array(self.data["c"])
dict["y"] = self.to_float_array(self.data["y"])
dict["g"] = self.to_float_array(self.data["g"])
ST.waviness_write(dict, file=file_name)
QMessageBox.information(self, "QMessageBox.information()",
"File \'" + file_name + "\' written to disk",
QMessageBox.Ok)
except Exception as exception:
QMessageBox.critical(self, "Error",
exception.args[0],
QMessageBox.Ok)
def populateFields(self, shadow_src):
shadow_src.src.NPOINT = self.number_of_rays
shadow_src.src.ISTAR1 = self.seed
shadow_src.src.PH1 = self.e_min
shadow_src.src.PH2 = self.e_max
shadow_src.src.F_OPD = 1
shadow_src.src.F_SR_TYPE = self.sample_distribution_combo
shadow_src.src.F_POL = 1 + self.generate_polarization_combo
shadow_src.src.SIGMAX = self.sigma_x
shadow_src.src.SIGMAZ = self.sigma_z
shadow_src.src.EPSI_X = self.emittance_x
shadow_src.src.EPSI_Z = self.emittance_z
shadow_src.src.BENER = self.energy
shadow_src.src.EPSI_DX = self.distance_from_waist_x
shadow_src.src.EPSI_DZ = self.distance_from_waist_z
shadow_src.src.R_MAGNET = self.magnetic_radius
shadow_src.src.R_ALADDIN = self.magnetic_radius * 100
shadow_src.src.HDIV1 = self.horizontal_half_divergence_from
shadow_src.src.HDIV2 = self.horizontal_half_divergence_to
shadow_src.src.VDIV1 = self.max_vertical_half_divergence_from
shadow_src.src.VDIV2 = self.max_vertical_half_divergence_to
shadow_src.src.FDISTR = 4 + 2 * self.calculation_mode_combo
shadow_src.src.F_BOUND_SOUR = self.optimize_source
if self.optimize_source > 0:
shadow_src.src.FILE_BOUND = bytes(congruence.checkFileName(self.optimize_file_name), 'utf-8')
shadow_src.src.NTOTALPOINT = self.max_number_of_rejected_rays
def populateFields(self, shadow_src):
shadow_src.src.NPOINT=self.number_of_rays
shadow_src.src.ISTAR1=self.seed
shadow_src.src.CONV_FACT = 1 / self.workspace_units_to_m
shadow_src.src.HDIV1 = 1.00000000000000
shadow_src.src.HDIV2 = 1.00000000000000
shadow_src.src.PH1=self.e_min
shadow_src.src.PH2=self.e_max
shadow_src.src.F_OPD=1
shadow_src.src.F_BOUND_SOUR = self.optimize_source_combo
shadow_src.src.NTOTALPOINT = self.max_number_of_rejected_rays
if self.optimize_source_combo == 1:
shadow_src.src.FILE_BOUND = bytes(congruence.checkFileName(self.file_with_phase_space_volume), 'utf-8')
elif self.optimize_source_combo == 2:
shadow_src.src.FILE_BOUND = bytes(congruence.checkFileName("myslit.dat"), 'utf-8')
f = open(congruence.checkFileName("myslit.dat"), "w")
f.write("%e %e %e %e %e "%(self.slit_distance, self.min_x, self.max_x, self.min_z, self.max_z))
f.write("\n")
f.close()
shadow_src.src.BENER=self.energy
if self.use_emittances_combo == 0:
shadow_src.src.SIGMAX=0
shadow_src.src.SIGMAY=0
shadow_src.src.SIGMAZ=0
shadow_src.src.EPSI_X=0
shadow_src.src.EPSI_Z=0
shadow_src.src.EPSI_DX=0
shadow_src.src.EPSI_DZ=0
else:
shadow_src.src.SIGMAX=self.sigma_x
shadow_src.src.SIGMAY=0
shadow_src.src.SIGMAZ=self.sigma_z
shadow_src.src.EPSI_X=self.emittance_x
shadow_src.src.EPSI_Z=self.emittance_z
shadow_src.src.EPSI_DX=self.distance_from_waist_x
shadow_src.src.EPSI_DZ=self.distance_from_waist_z
def populateFields(self, shadow_oe):
self.dumpSettings()
dimension1_out = self.crystal_1_box.get_dimensions()
dimension2_out = self.crystal_2_box.get_dimensions()
shadow_oe._oe.append_monochromator_double_crystal(p0=self.p,
q0=self.q,
photon_energy_ev=self.photon_energy_ev,
separation=self.separation,
dimensions1=dimension1_out,
dimensions2=dimension2_out,
reflectivity_file=bytes(congruence.checkFileName(self.reflectivity_file), 'utf-8'))
def compute(self):
try:
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.checkFields()
tmp = prerefl(interactive=False,
SYMBOL=self.SYMBOL,
DENSITY=self.DENSITY,
FILE=congruence.checkFileName(self.SHADOW_FILE),
E_MIN=self.E_MIN,
E_MAX=self.E_MAX,
E_STEP=self.E_STEP)
self.send("PreProcessor_Data", ShadowPreProcessorData(prerefl_data_file=self.SHADOW_FILE))
except Exception as exception:
QMessageBox.critical(self, "Error",
str(exception),
QMessageBox.Ok)
def generate_waviness_file(self, not_interactive_mode=False):
if not self.zz is None and not self.yy is None and not self.xx is None:
try:
congruence.checkDir(self.waviness_file_name)
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
ST.write_shadow_surface(self.zz.T, self.xx, self.yy, outFile=congruence.checkFileName(self.waviness_file_name))
if not not_interactive_mode:
QMessageBox.information(self, "QMessageBox.information()",
"Waviness file " + self.waviness_file_name + " written on disk",
QMessageBox.Ok)
self.send("PreProcessor_Data", ShadowPreProcessorData(error_profile_data_file=self.waviness_file_name,
error_profile_x_dim=self.dimension_x,
error_profile_y_dim=self.dimension_y))
except Exception as exception:
QMessageBox.critical(self, "Error",
exception.args[0],
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:
QtGui.QMessageBox.critical(self, "Error",
str(exception), QtGui.QMessageBox.Ok)
def write_file(self):
self.setStatusMessage("")
try:
if ShadowCongruence.checkEmptyBeam(self.input_beam):
if ShadowCongruence.checkGoodBeam(self.input_beam):
if congruence.checkFileName(self.beam_file_name):
self.input_beam.writeToFile(self.beam_file_name)
path, file_name = os.path.split(self.beam_file_name)
self.setStatusMessage("File Out: " + file_name)
self.send("Beam", self.input_beam)
else:
QtGui.QMessageBox.critical(self, "Error",
"No good rays or bad content",
QtGui.QMessageBox.Ok)
except Exception as exception:
QtGui.QMessageBox.critical(self, "Error",
str(exception), QtGui.QMessageBox.Ok)
def compute(self):
try:
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.checkFields()
tmp = bragg(interactive=False,
DESCRIPTOR=self.crystals[self.DESCRIPTOR],
H_MILLER_INDEX=self.H_MILLER_INDEX,
K_MILLER_INDEX=self.K_MILLER_INDEX,
L_MILLER_INDEX=self.L_MILLER_INDEX,
TEMPERATURE_FACTOR=self.TEMPERATURE_FACTOR,
E_MIN=self.E_MIN,
E_MAX=self.E_MAX,
E_STEP=self.E_STEP,
SHADOW_FILE=congruence.checkFileName(self.SHADOW_FILE))
self.send("PreProcessor_Data", ShadowPreProcessorData(bragg_data_file=self.SHADOW_FILE))
except Exception as exception:
QMessageBox.critical(self, "Error",
str(exception),
QMessageBox.Ok)
def get_surface_error_files(self):
if self.has_surface_error == 1:
return bytes(congruence.checkFileName(self.surface_error_files), 'utf-8')
else:
return ""
def get_reflectivity_files(self):
if self.reflectivity_kind != 0:
return bytes(congruence.checkFileName(self.reflectivity_files), 'utf-8')
else:
return ""
def get_prerefl_file(self):
if self.ri_calculation_mode == 1:
return congruence.checkFileName(self.prerefl_file)
else:
return None
def runShadowSource(self):
#self.error(self.error_id)
self.setStatusMessage("")
self.progressBarInit()
try:
self.checkFields()
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
wigFile = bytes(congruence.checkFileName("xshwig.sha"), 'utf-8')
if self.type_combo == 0:
inData = ""
elif self.type_combo == 1:
inData = congruence.checkFileName(self.file_with_b_vs_y)
elif self.type_combo == 2:
inData = congruence.checkFileName(self.file_with_harmonics)
self.progressBarSet(10)
#self.information(0, "Calculate electron trajectory")
self.setStatusMessage("Calculate electron trajectory")
(traj, pars) = srfunc.wiggler_trajectory(b_from=self.type_combo,
inData=inData,
nPer=self.number_of_periods,
nTrajPoints=501,
ener_gev=self.energy,
per=self.id_period,
kValue=self.k_value,
trajFile=congruence.checkFileName("tmp.traj"),
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)
#
# calculate cdf and write file for Shadow/Source
#
self.progressBarSet(20)
#self.information(0, "Calculate cdf and write file for Shadow/Source")
self.setStatusMessage("Calculate cdf and write file for Shadow/Source")
srfunc.wiggler_cdf(traj,
enerMin=self.e_min,
enerMax=self.e_max,
enerPoints=1001,
outFile=wigFile,
elliptical=False)
#self.information(0, "CDF written to file %s \n"%(wigFile))
self.setStatusMessage("CDF written to file %s \n"%(str(wigFile)))
self.progressBarSet(40)
#self.information(0, "Set the wiggler parameters in the wiggler container")
self.setStatusMessage("Set the wiggler parameters in the wiggler container")
shadow_src = ShadowSource.create_wiggler_src()
self.populateFields(shadow_src)
shadow_src.src.FILE_TRAJ = wigFile
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
self.progressBarSet(50)
self.setStatusMessage("Running Shadow/Source")
write_begin_file, write_start_file, write_end_file = self.get_write_file_options()
beam_out = ShadowBeam.traceFromSource(shadow_src,
write_begin_file=write_begin_file,
write_start_file=write_start_file,
write_end_file=write_end_file)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
#self.information(0, "Plotting Results")
self.setStatusMessage("Plotting Results")
self.progressBarSet(80)
self.plot_results(beam_out, 80)
self.setStatusMessage("Plotting Wiggler Data")
self.plot_wiggler_results()
#self.information()
self.setStatusMessage("")
self.send("Beam", beam_out)
except Exception as exception:
QtGui.QMessageBox.critical(self, "Error",
str(exception),
QtGui.QMessageBox.Ok)
#self.error_id = self.error_id + 1
#self.error(self.error_id, "Exception occurred: " + str(exception))
self.progressBarFinished()
def runShadowSource(self):
#self.error(self.error_id)
self.setStatusMessage("")
self.progressBarInit()
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
if self.trace_shadow:
grabber = TTYGrabber()
grabber.start()
try:
self.checkFields()
###########################################
# TODO: TO BE ADDED JUST IN CASE OF BROKEN
# ENVIRONMENT: MUST BE FOUND A PROPER WAY
# TO TEST SHADOW
self.fixWeirdShadowBug()
###########################################
wigFile = bytes(congruence.checkFileName("xshwig.sha"), 'utf-8')
if self.type_combo == 0:
inData = ""
elif self.type_combo == 1:
inData = congruence.checkUrl(self.file_with_b_vs_y)
elif self.type_combo == 2:
inData = congruence.checkUrl(self.file_with_harmonics)
self.progressBarSet(10)
#self.information(0, "Calculate electron trajectory")
self.shadow_output.setText("")
self.setStatusMessage("Calculate electron trajectory")
(traj, pars) = srfunc.wiggler_trajectory(b_from=self.type_combo,
inData=inData,
nPer=self.number_of_periods,
nTrajPoints=501,
ener_gev=self.energy,
per=self.id_period,
kValue=self.k_value,
trajFile=congruence.checkFileName("tmp.traj"),
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)
#
# calculate cdf and write file for Shadow/Source
#
self.progressBarSet(20)
#self.information(0, "Calculate cdf and write file for Shadow/Source")
self.setStatusMessage("Calculate cdf and write file for Shadow/Source")
srfunc.wiggler_cdf(traj,
enerMin=self.e_min,
enerMax=self.e_max,
enerPoints=1001,
outFile=wigFile,
elliptical=False)
#self.information(0, "CDF written to file %s \n"%(wigFile))
self.setStatusMessage("CDF written to file %s \n"%(str(wigFile)))
self.progressBarSet(40)
#self.information(0, "Set the wiggler parameters in the wiggler container")
self.setStatusMessage("Set the wiggler parameters in the wiggler container")
shadow_src = ShadowSource.create_wiggler_src()
self.populateFields(shadow_src)
shadow_src.src.FILE_TRAJ = wigFile
self.progressBarSet(50)
self.setStatusMessage("Running Shadow/Source")
write_begin_file, write_start_file, write_end_file = self.get_write_file_options()
beam_out = ShadowBeam.traceFromSource(shadow_src,
write_begin_file=write_begin_file,
write_start_file=write_start_file,
write_end_file=write_end_file,
widget_class_name=self.__class__.name)
if self.trace_shadow:
grabber.stop()
for row in grabber.ttyData:
self.writeStdOut(row)
#self.information(0, "Plotting Results")
self.setStatusMessage("Plotting Results")
self.progressBarSet(80)
self.plot_results(beam_out, progressBarValue=80)
self.setStatusMessage("Plotting Wiggler Data")
self.plot_wiggler_results()
#self.information()
self.setStatusMessage("")
self.send("Beam", beam_out)
#
# create python script for the preprocessors and display in the standard output
#
dict_parameters = {
"b_from" : self.type_combo,
"inData" : inData,
"nPer" : self.number_of_periods,
"nTrajPoints" : 501,
"ener_gev" : self.energy,
"per" : self.id_period,
"kValue" : self.k_value,
"trajFile" : "tmp.traj",
"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,
"enerMin" : self.e_min,
"enerMax" : self.e_max,
"enerPoints" : 1001,
"outFile" : wigFile,
"elliptical" : False,
"electron_current_mA" : self.electron_current,
}
# write python script in standard output
print(self.script_template().format_map(dict_parameters))
except Exception as exception:
QtWidgets.QMessageBox.critical(self, "Error",
str(exception),
QtWidgets.QMessageBox.Ok)
#self.error_id = self.error_id + 1
#self.error(self.error_id, "Exception occurred: " + str(exception))
self.progressBarFinished()
def generate_reflectivity_file(self):
file_name = congruence.checkFileName(self.data_file_name)
output_data = SRWPreProcessorData(reflectivity_data=SRWReflectivityData(reflectivity_data_file=self.data_file_name))
data_txt = ""
if not self.reflectivity_unpol_data is None:
try:
reflectivity_data = self.reflectivity_unpol_data.get_content("data2D")
energy = self.reflectivity_unpol_data.get_content("dataX")
angle = self.reflectivity_unpol_data.get_content("dataY")*0.001 #to rad
output_data.reflectivity_data.energies_number = len(energy)
output_data.reflectivity_data.angles_number = len(angle)
output_data.reflectivity_data.components_number = 1
output_data.reflectivity_data.energy_start = energy[0]
output_data.reflectivity_data.energy_end = energy[-1]
output_data.reflectivity_data.energy_scale_type = ScaleType.LINEAR
output_data.reflectivity_data.angle_start = angle[0]
output_data.reflectivity_data.angle_end = angle[-1]
output_data.reflectivity_data.angle_scale_type = ScaleType.LINEAR
data_txt = ""
for i in range(0, len(angle)):
for j in range (0, len(energy)):
if not (i==0 and j==0): data_txt += "\n"
data_txt += str(reflectivity_data[j, i]) + "\n0.0"
except:
try:
reflectivity_data = self.reflectivity_unpol_data.get_content("xoppy_data")
labels = self.reflectivity_unpol_data.get_content("labels")
x_col = int(self.reflectivity_unpol_data.get_content("plot_x_col"))
y_col = int(self.reflectivity_unpol_data.get_content("plot_y_col"))
if "Energy" in labels[0]:
congruence.checkStrictlyPositiveNumber(self.angle_single_value, "Angle Single Value")
output_data.reflectivity_data.energies_number = len(reflectivity_data)
output_data.reflectivity_data.angles_number = 1
output_data.reflectivity_data.energy_start = reflectivity_data[0, x_col]
output_data.reflectivity_data.energy_end = reflectivity_data[-1, x_col]
output_data.reflectivity_data.angle_start = self.angle_single_value
output_data.reflectivity_data.angle_end = self.angle_single_value
elif "Theta" in labels[0]:
congruence.checkStrictlyPositiveNumber(self.energy_single_value, "Energy Single Value")
output_data.reflectivity_data.energies_number = 1
output_data.reflectivity_data.angles_number = len(reflectivity_data)
output_data.reflectivity_data.energy_start = self.energy_single_value
output_data.reflectivity_data.energy_end = self.energy_single_value
output_data.reflectivity_data.angle_start = reflectivity_data[0, x_col]*0.001 #to rad
output_data.reflectivity_data.angle_end = reflectivity_data[-1, x_col]*0.001 #to rad
output_data.reflectivity_data.components_number = 1
output_data.reflectivity_data.energy_scale_type = ScaleType.LINEAR
output_data.reflectivity_data.angle_scale_type = ScaleType.LINEAR
for i in range(0, len(reflectivity_data)):
if i!=0: data_txt += "\n"
data_txt += str(reflectivity_data[i, y_col]) + "\n0.0"
except Exception as exception:
QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
if self.IS_DEVELOP: raise exception
return
if not data_txt == "":
file = open(file_name, "w")
file.write(data_txt)
file.flush()
file.close()
self.send("Reflectivity Data", output_data)
elif not self.reflectivity_s_data is None and not self.reflectivity_p_data is None:
try:
reflectivity_s = self.reflectivity_s_data.get_content("data2D")
energy_s = self.reflectivity_s_data.get_content("dataX")
angle_s = self.reflectivity_s_data.get_content("dataY")*0.001 #to rad
try:
reflectivity_p = self.reflectivity_p_data.get_content("data2D")
energy_p = self.reflectivity_p_data.get_content("dataX")
angle_p = self.reflectivity_p_data.get_content("dataY")*0.001 #to rad
if (len(energy_s) != len(energy_p)) or \
(energy_p[0] != energy_s[0]) or \
(energy_p[-1] != energy_s[-1]) or \
(len(angle_s) != len(angle_p)) or \
(angle_p[0] != angle_s[0]) or \
(angle_p[-1] != angle_s[-1]):
QMessageBox.critical(self, "Error", "Reflectivity data have different dimension or different range of Energy/Angle values", QMessageBox.Ok)
return
output_data.reflectivity_data.energies_number = len(energy_s)
output_data.reflectivity_data.angles_number = len(angle_s)
output_data.reflectivity_data.components_number = 2
output_data.reflectivity_data.energy_start = energy_s[0]
output_data.reflectivity_data.energy_end = energy_s[-1]
output_data.reflectivity_data.energy_scale_type = ScaleType.LINEAR
output_data.reflectivity_data.angle_start = angle_s[0]
output_data.reflectivity_data.angle_end = angle_s[-1]
output_data.reflectivity_data.angle_scale_type = ScaleType.LINEAR
data_txt = ""
for i in range(0, len(angle_s)):
for j in range (0, len(energy_s)):
if not (i==0 and j==0): data_txt += "\n"
data_txt += str(reflectivity_s[j, i]) + "\n0.0"
for i in range(0, len(angle_p)):
for j in range (0, len(energy_p)):
data_txt += "\n" + str(reflectivity_p[j, i]) + "\n0.0"
except:
QMessageBox.critical(self, "Error", "Reflectivity data have different dimension", QMessageBox.Ok)
return
except:
try:
reflectivity_s = self.reflectivity_s_data.get_content("xoppy_data")
labels_s = self.reflectivity_s_data.get_content("labels")
x_col = int(self.reflectivity_s_data.get_content("plot_x_col"))
y_col = int(self.reflectivity_s_data.get_content("plot_y_col"))
try:
reflectivity_p = self.reflectivity_p_data.get_content("xoppy_data")
labels_p = self.reflectivity_p_data.get_content("labels")
if (len(reflectivity_p) != len(reflectivity_s)) or \
(reflectivity_s[0, x_col] != reflectivity_p[0, x_col]) or \
(reflectivity_s[-1, x_col] != reflectivity_p[-1, x_col]) or \
(labels_s[0] != labels_p[0]):
QMessageBox.critical(self, "Error", "Reflectivity data have different dimension or different range of Energy/Angle values", QMessageBox.Ok)
return
try:
if "Energy" in labels_s[0]:
congruence.checkStrictlyPositiveNumber(self.angle_single_value, "Angle Single Value")
output_data.reflectivity_data.energies_number = len(reflectivity_s)
output_data.reflectivity_data.angles_number = 1
output_data.reflectivity_data.energy_start = reflectivity_s[0, x_col]
output_data.reflectivity_data.energy_end = reflectivity_s[-1, x_col]
output_data.reflectivity_data.angle_start = self.angle_single_value
output_data.reflectivity_data.angle_end = self.angle_single_value
elif "Theta" in labels_s[0]:
congruence.checkStrictlyPositiveNumber(self.energy_single_value, "Energy Single Value")
output_data.reflectivity_data.energies_number = 1
output_data.reflectivity_data.angles_number = len(reflectivity_s)
output_data.reflectivity_data.energy_start = self.energy_single_value
output_data.reflectivity_data.energy_end = self.energy_single_value
output_data.reflectivity_data.angle_start = reflectivity_s[0, x_col]*0.001 #to rad
output_data.reflectivity_data.angle_end = reflectivity_s[-1, x_col]*0.001 #to rad
except Exception as exception:
QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
if self.IS_DEVELOP: raise exception
return
output_data.reflectivity_data.components_number = 2
output_data.reflectivity_data.energy_scale_type = ScaleType.LINEAR
output_data.reflectivity_data.angle_scale_type = ScaleType.LINEAR
for i in range(0, len(reflectivity_s)):
if i!=0: data_txt += "\n"
data_txt += str(reflectivity_s[i, y_col]) + "\n0.0"
for i in range(0, len(reflectivity_p)):
data_txt += "\n" + str(reflectivity_p[i, y_col]) + "\n0.0"
except:
QMessageBox.critical(self, "Error", "Reflectivity data have different dimension", QMessageBox.Ok)
return
except Exception as exception:
QMessageBox.critical(self, "Error", str(exception), QMessageBox.Ok)
if self.IS_DEVELOP: raise exception
return
if not data_txt == "":
file = open(file_name, "w")
file.write(data_txt)
file.flush()
file.close()
self.send("Reflectivity Data", output_data)
else:
QMessageBox.critical(self, "Error", "Incomplete Data: connect Total Polarization Data or BOTH Polarizations Data", QMessageBox.Ok)
def replace_fig(self, beam, var_x, var_y, title, xtitle, ytitle, xrange,
yrange, nbins, nolost, xum, yum):
if self.plot_canvas is None:
self.plot_canvas = ShadowPlot.DetailedPlotWidget(
y_scale_factor=1.14)
self.image_box.layout().addWidget(self.plot_canvas)
try:
if self.autosave == 1:
if self.autosave_file is None:
self.autosave_file = ShadowPlot.PlotXYHdf5File(
congruence.checkDir(self.autosave_file_name))
elif self.autosave_file.filename != congruence.checkFileName(
self.autosave_file_name):
self.autosave_file.close()
self.autosave_file = ShadowPlot.PlotXYHdf5File(
congruence.checkDir(self.autosave_file_name))
if self.keep_result == 1:
self.cumulated_ticket, last_ticket = self.plot_canvas.plot_xy(
beam,
var_x,
var_y,
title,
xtitle,
ytitle,
xrange=xrange,
yrange=yrange,
nbins=nbins,
nolost=nolost,
xum=xum,
yum=yum,
conv=self.workspace_units_to_cm,
ref=self.weight_column_index,
ticket_to_add=self.cumulated_ticket)
self.plotted_ticket = self.cumulated_ticket
if self.autosave == 1:
self.autosave_prog_id += 1
self.autosave_file.write_coordinates(self.cumulated_ticket)
dataset_name = self.weight_column.itemText(
self.weight_column_index)
self.autosave_file.add_plot_xy(self.cumulated_ticket,
dataset_name=dataset_name)
if self.autosave_partial_results == 1:
if last_ticket is None:
self.autosave_file.add_plot_xy(
self.cumulated_ticket,
plot_name="Plot XY #" +
str(self.autosave_prog_id),
dataset_name=dataset_name)
else:
self.autosave_file.add_plot_xy(
last_ticket,
plot_name="Plot X #" +
str(self.autosave_prog_id),
dataset_name=dataset_name)
self.autosave_file.flush()
else:
ticket, _ = self.plot_canvas.plot_xy(
beam,
var_x,
var_y,
title,
xtitle,
ytitle,
xrange=xrange,
yrange=yrange,
nbins=nbins,
nolost=nolost,
xum=xum,
yum=yum,
conv=self.workspace_units_to_cm,
ref=self.weight_column_index)
self.cumulated_ticket = None
self.plotted_ticket = ticket
if self.autosave == 1:
self.autosave_prog_id += 1
self.autosave_file.write_coordinates(ticket)
self.autosave_file.add_plot_xy(
ticket,
dataset_name=self.weight_column.itemText(
self.weight_column_index))
self.autosave_file.flush()
except Exception as e:
if not self.IS_DEVELOP:
raise Exception(
"Data not plottable: No good rays or bad content")
else:
raise e
def get_prerefl_file(self):
if self.ri_calculation_mode == 1:
return congruence.checkFileName(self.prerefl_file)
else:
return None
def replace_fig(self, shadow_beam, var_x, var_y, xrange, yrange, nbins, nolost):
if self.plot_canvas is None:
self.plot_canvas = PowerPlotXYWidget()
self.image_box.layout().addWidget(self.plot_canvas)
try:
if self.autosave == 1:
if self.autosave_file is None:
self.autosave_file = ShadowPlot.PlotXYHdf5File(congruence.checkDir(self.autosave_file_name))
elif self.autosave_file.filename != congruence.checkFileName(self.autosave_file_name):
self.autosave_file.close()
self.autosave_file = ShadowPlot.PlotXYHdf5File(congruence.checkDir(self.autosave_file_name))
if self.keep_result == 1:
self.cumulated_ticket, last_ticket = self.plot_canvas.plot_power_density(shadow_beam, var_x, var_y,
self.total_power, self.cumulated_total_power,
self.energy_min, self.energy_max, self.energy_step,
nbins=nbins, xrange=xrange, yrange=yrange, nolost=nolost,
ticket_to_add=self.cumulated_ticket,
to_mm=self.workspace_units_to_mm,
show_image=self.view_type==1,
kind_of_calculation=self.kind_of_calculation,
replace_poor_statistic=self.replace_poor_statistic,
good_rays_limit=self.good_rays_limit,
center_x=self.center_x,
center_y=self.center_y,
sigma_x=self.sigma_x,
sigma_y=self.sigma_y,
gamma=self.gamma)
self.plotted_ticket = self.cumulated_ticket
self.plotted_ticket_original = self.plotted_ticket.copy()
if self.autosave == 1:
self.autosave_file.write_coordinates(self.cumulated_ticket)
dataset_name = "power_density"
self.autosave_file.add_plot_xy(self.cumulated_ticket, dataset_name=dataset_name)
if self.autosave_partial_results == 1:
if last_ticket is None:
self.autosave_file.add_plot_xy(self.cumulated_ticket,
plot_name="Energy Range: " + str(round(self.energy_max-self.energy_step, 2)) + "-" + str(round(self.energy_max, 2)),
dataset_name=dataset_name)
else:
self.autosave_file.add_plot_xy(last_ticket,
plot_name="Energy Range: " + str(round(self.energy_max-self.energy_step, 2)) + "-" + str(round(self.energy_max, 2)),
dataset_name=dataset_name)
self.autosave_file.flush()
else:
ticket, _ = self.plot_canvas.plot_power_density(shadow_beam, var_x, var_y,
self.total_power, self.cumulated_total_power,
self.energy_min, self.energy_max, self.energy_step,
nbins=nbins, xrange=xrange, yrange=yrange, nolost=nolost,
to_mm=self.workspace_units_to_mm,
show_image=self.view_type==1,
kind_of_calculation=self.kind_of_calculation,
replace_poor_statistic=self.replace_poor_statistic,
good_rays_limit=self.good_rays_limit,
center_x=self.center_x,
center_y=self.center_y,
sigma_x=self.sigma_x,
sigma_y=self.sigma_y,
gamma=self.gamma)
self.cumulated_ticket = None
self.plotted_ticket = ticket
self.plotted_ticket_original = self.plotted_ticket.copy()
if self.autosave == 1:
self.autosave_file.write_coordinates(ticket)
self.autosave_file.add_plot_xy(ticket, dataset_name="power_density")
self.autosave_file.flush()
except Exception as e:
if not self.IS_DEVELOP:
raise Exception("Data not plottable: No good rays or bad content")
else:
raise e
