def button_release_callback(self, event):
'whenever a mouse button is released'
a = P4Rm()
val = a.xrd_graph_loaded
if self.canvas.HasCapture():
self.canvas.ReleaseMouse()
else:
if not self.showverts:
return
if event.button != 1:
return
if self.new_coord['indice'] is not None and val == 1:
a = P4Rm()
temp_1 = self.new_coord['y']
temp_2 = self.new_coord['x']
P4Rm.DragDrop_DW_y[self.new_coord['indice']] = temp_1
P4Rm.DragDrop_DW_x[self.new_coord['indice']] = temp_2
if a.AllDataDict['model'] == 0:
temp = self.new_coord['y']
P4Rm.DragDrop_DW_y[self.new_coord['indice']] = temp
temp = [
dw * scale for dw, scale in zip(
a.DragDrop_DW_y, a.ParamDict['scale_dw'])
]
temp = [float(format(value, '.8f')) for value in temp]
temp2 = np.concatenate([temp, [a.ParamDict['dw_out']]])
P4Rm.ParamDict['dwp'] = deepcopy(temp2)
P4Rm.ParamDictbackup['dwp'] = deepcopy(temp2)
elif a.AllDataDict['model'] == 1:
temp = self.new_coord['y']
P4Rm.DragDrop_DW_y[self.new_coord['indice']] = temp
temp = [
dw * scale for dw, scale in zip(
a.DragDrop_DW_y, a.ParamDict['scale_dw'])
]
temp = [float(format(value, '.8f')) for value in temp]
temp2 = np.concatenate([[a.ParamDict['dw_out'][0]], temp,
[a.ParamDict['dw_out'][1]]])
P4Rm.ParamDict['dwp'] = deepcopy(temp2)
P4Rm.ParamDictbackup['dwp'] = deepcopy(temp2)
elif a.AllDataDict['model'] == 2:
t_temp = a.ParamDict['depth'] + a.ParamDict['z']
t = t_temp[0]
dwp_temp = range(7)
dwp_temp[0] = a.DragDrop_DW_y[0]
dwp_temp[1] = 1 - a.DragDrop_DW_x[0] / t
dwp_temp[2] = 2 * (-1 + a.ParamDict['dwp'][1] +
a.DragDrop_DW_x[1] / t)
dwp_temp[3] = 2 * (1 - a.ParamDict['dwp'][1] -
1 * a.DragDrop_DW_x[2] / t)
dwp_temp[4] = a.ParamDict['dwp'][4]
dwp_temp[5] = a.ParamDict['dwp'][5]
dwp_temp[6] = a.DragDrop_DW_y[3]
P4Rm.ParamDict['dwp'] = deepcopy(dwp_temp)
P4Rm.ParamDictbackup['dwp'] = deepcopy(dwp_temp)
P4Rm.ParamDict['dwp_pv'] = deepcopy(dwp_temp)
pub.sendMessage(pubsub_Update_Fit_Live)
self._ind = None
def residual_square(p, data):
a = P4Rm()
P4Rm.ParamDict['_fp_min'] = p
y_cal = f_Refl(a.AllDataDict['geometry'])
y_cal = y_cal / y_cal.max() + data['background']
temp = ((log10(a.ParamDict['Iobs']) - log10(y_cal))**2).sum()
return temp / len(y_cal)
def scale_manual(self, event, val=None):
a = P4Rm()
if val is not None:
P4Rm.ParamDict['DW_multiplication'] = val
P4Rm.ParamDict['dwp'] = multiply(a.ParamDict['dwp'],
a.ParamDict['DW_multiplication'])
pub.sendMessage(pubsub_Re_Read_field_paramters_panel, event=event)
def residual_lmfit(self, pars, x, y):
a = P4Rm()
self.strain_DW(pars)
res = f_Refl_fit(a.AllDataDict['geometry'], self.Data4f_Refl)
y_cal = convolve(abs(res) ** 2, a.ParamDict['resol'], mode='same')
y_cal = y_cal / y_cal.max() + a.AllDataDict['background']
return (log10(y) - log10(y_cal))
def strain_DW(self, pars=None):
a = P4Rm()
self.Data4f_Refl = []
if pars is None:
strain = f_strain(a.ParamDict['z'],
a.ParamDict['_fp_min'][:self.len_sp:],
a.AllDataDict['damaged_depth'],
a.splinenumber[0])
DW = f_DW(a.ParamDict['z'],
a.ParamDict['_fp_min'][self.len_sp:self.len_sp +
self.len_dwp:],
a.AllDataDict['damaged_depth'], a.splinenumber[1])
else:
if a.AllDataDict['model'] == 0:
spline_DW = 5
spline_strain = 5
elif a.AllDataDict['model'] == 1:
spline_DW = 6
spline_strain = 6
elif a.AllDataDict['model'] == 2:
spline_DW = 4
spline_strain = 4
self.pars4numba(pars)
strain = f_strain(a.ParamDict['z'], self.pars_value,
a.AllDataDict['damaged_depth'], spline_strain)
DW = f_DW(a.ParamDict['z'], self.pars_value,
a.AllDataDict['damaged_depth'], spline_DW)
strain.astype(np.float64)
DW.astype(np.float64)
self.Data4f_Refl.append(strain)
self.Data4f_Refl.append(DW)
self.Data4f_Refl.append(self.const)
def on_launch_fit(self):
a = P4Rm()
b = Calcul4Radmax()
b.on_update()
pub.sendMessage(pubsub_Read_field4Save)
if a.PathDict['namefromini'] != "":
logger.log(logging.INFO, "Start Fit")
if (a.checkInitialField == 1 and a.checkGeometryField == 1 and
a.checkFittingField == 1):
P4Rm.allparameters = (a.initial_parameters +
a.fitting_parameters +
a.sample_geometry)
i = 0
for k in p4R.IP_p + p4R.F_p + p4R.SG_p:
P4Rm.AllDataDict[k] = a.allparameters[i]
i += 1
if a.AllDataDict['nb_cycle_max'] < a.AllDataDict['nb_palier']:
P4Rm.AllDataDict['nb_cycle_max'] = a.AllDataDict['nb_palier']
pub.sendMessage(pubsub_adjust_nb_cycle)
self.onLaunchtest()
else:
return
else:
pub.sendMessage(pubsub_save_project_before_fit, case=2)
def init_array(self):
a = P4Rm()
const_all = []
const_all.append(a.AllDataDict['wavelength'])
const_all.append(a.AllDataDict['damaged_depth'])
const_all.append(a.AllDataDict['number_slices'])
const_all.append(a.ConstDict['phi'])
const_all.append(a.ParamDict['t_l'])
const_all.append(a.ParamDict['b_S'])
const_all.append(a.ParamDict['thB_S'])
const_all.append(a.ParamDict['G'])
const_all.append(a.ParamDict['F0'])
const_all.append(a.ParamDict['FH'])
const_all.append(a.ParamDict['FmH'])
const_all.append(a.ParamDict['b_S_s'])
const_all.append(a.ParamDict['thB_S_s'])
const_all.append(a.ParamDict['G_s'])
const_all.append(a.ParamDict['F0_s'])
const_all.append(a.ParamDict['FH_s'])
const_all.append(a.ParamDict['FmH_s'])
const_all.append(a.AllDataDict['film_thick'])
const_all.append(a.AllDataDict['dw_thick'])
const_all.append(a.ParamDict['th'])
const_all.append(len(a.ParamDict['z']))
self.const = const_all
self.len_sp = len(a.ParamDict['sp'])
self.len_dwp = len(a.ParamDict['dwp'])
def on_read_data_from_lmfit(self):
a = P4Rm()
from lmfit import fit_report
result = P4Rm.resultFit
data = []
data.append(result.success)
data.append(result.lmdif_message)
data.append(result.ier)
data.append(fit_report(result))
P4Rm.FitDict['Leastsq_report'] = data
i = 0
if a.AllDataDict['model'] == 2:
for param in result.params.values():
if i in range(1, 7):
P4Rm.ParamDict['sp'][i] = param.value
if i in range(7, 14):
P4Rm.ParamDict['dwp'][i - 7] = param.value
i += 1
else:
len_sp = int(result.params['nb_sp_val'])
len_dwp = int(result.params['nb_dwp_val'])
for ii in range(len_dwp):
name = 'dwp_' + str(ii)
P4Rm.ParamDict['dwp'][ii] = result.params[name].value
for jj in range(len_sp):
name = 'sp_' + str(jj)
P4Rm.ParamDict['sp'][jj] = result.params[name].value
def f_Refl_Thick_Film():
a = P4Rm()
wl = a.AllDataDict['wavelength']
t = a.AllDataDict['damaged_depth']
N = a.AllDataDict['number_slices']
t_film = a.AllDataDict['film_thick']
G = a.ParamDict['G']
thB_S = a.ParamDict['thB_S']
resol = a.ParamDict['resol']
phi = a.ConstDict['phi']
t_l = a.ParamDict['t_l']
z = a.ParamDict['z']
FH = a.ParamDict['FH']
FmH = a.ParamDict['FmH']
F0 = a.ParamDict['F0']
sp = a.ParamDict['sp']
dwp = a.ParamDict['dwp']
th = a.ParamDict['th']
spline_DW = a.splinenumber[1]
spline_strain = a.splinenumber[0]
param = a.ParamDict['par']
delta_t = t_film - t
strain = f_strain(z, param[:len(sp):], t, spline_strain)
DW = f_DW(z, param[len(sp):len(sp) + len(dwp):], t, spline_DW)
thB = thB_S - strain * tan(thB_S) # angle de Bragg dans chaque lamelle
eta = 0
res = 0
g0 = sin(thB[0] - phi) # gamma 0
gH = -sin(thB[0] + phi) # gamma H
b = g0 / gH
T = pi * G * ((FH[0] * FmH[0])**0.5) * delta_t / (wl * (abs(g0 * gH)**0.5))
eta = (-b * (th - thB[0]) * sin(2 * thB_S) - 0.5 * G * F0[0] *
(1 - b)) / ((abs(b)**0.5) * G * (FH[0] * FmH[0])**0.5)
S1 = (res - eta + (eta * eta - 1)**0.5) * exp(-1j * T *
(eta * eta - 1)**0.5)
S2 = (res - eta - (eta * eta - 1)**0.5) * exp(1j * T *
(eta * eta - 1)**0.5)
res = (eta + ((eta * eta - 1)**0.5) * ((S1 + S2) / (S1 - S2)))
n = 1
while (n <= N):
g0 = sin(thB[n] - phi) # gamma 0
gH = -sin(thB[n] + phi) # gamma H
b = g0 / gH
T = pi * G * (
(FH[n] * FmH[n])**0.5) * t_l * DW[n] / (wl * (abs(g0 * gH)**0.5))
eta = (-b * (th - thB[n]) * sin(2 * thB_S) - 0.5 * G * F0[n] *
(1 - b)) / ((abs(b)**0.5) * G * DW[n] * (FH[n] * FmH[n])**0.5)
S1 = (res - eta + (eta * eta - 1)**0.5) * exp(-1j * T *
(eta * eta - 1)**0.5)
S2 = (res - eta - (eta * eta - 1)**0.5) * exp(1j * T *
(eta * eta - 1)**0.5)
res = (eta + ((eta * eta - 1)**0.5) * ((S1 + S2) / (S1 - S2)))
n += 1
return convolve(abs(res)**2, resol, mode='same')
def save_project(self, case):
nunberofdatapersection = [
0,
len(p4R.s_crystal),
len(p4R.s_data_file),
len(p4R.s_experiment),
len(p4R.s_material),
len(p4R.s_strain_DW),
len(p4R.s_GSA_options),
len(p4R.s_bsplines),
len(p4R.s_pv),
len(p4R.s_GSA_expert),
len(p4R.s_leastsq),
len(p4R.s_geometry),
len(p4R.s_substrate)
]
a = P4Rm()
filename_ = a.PathDict['path2inicomplete']
parser = SafeConfigParser()
if case == 0:
parser.read(filename_)
new_section_name = p4R.Exp_file_all_section
for i in range(len(p4R.Exp_file_section)):
if case == 1:
parser.add_section(p4R.Exp_file_section[i])
k = nunberofdatapersection[i]
r = nunberofdatapersection[i + 1]
new_section_name = new_section_name[k:]
for l in range(r):
parser.set(p4R.Exp_file_section[i], new_section_name[l],
str(a.AllDataDict[new_section_name[l]]))
parser.write(open(filename_, 'w'))
def on_load(self, b=None):
for ii in self.data_fields:
self.data_fields[ii].Clear()
if b == 1:
for i in range(len(New_project_initial)):
p_ = New_project_initial[i]
self.data_fields[i].AppendText(str(p_))
else:
a = P4Rm()
self.state = 4 * [False]
val = int(float(a.AllDataDict['geometry']))
self.state[val] = True
self.rb[val].SetValue(True)
self.on_apply_rb()
i = 0
for k in p4R.SG_p[1:]:
self.data_fields[i].AppendText(str(a.AllDataDict[k]))
i += 1
val = self.symmetry_choice[int(
float(a.AllDataDict['crystal_symmetry_s']))]
self.cb_crystalsymmetry.SetStringSelection(val)
self.on_select_symmetry(None, val)
if a.PathDict['substrate_name'] in a.crystal_list:
indexx = a.crystal_list.index(a.PathDict['substrate_name'])
self.cb_crystalname.SetStringSelection(a.crystal_list[indexx])
msg_ = "Config file successfully loaded"
logger.log(logging.INFO, msg_)
else:
msg_ = ("You need to add the proper strcuture" + "to continue")
logger.log(logging.INFO, msg_)
def on_search_in_DB(self):
a = P4Rm()
temp = []
test = []
test = [
RadMaxData.exp_name, RadMaxData.crys_name, RadMaxData.geometry,
RadMaxData.model, RadMaxData.date
]
for i in range(len(a.DBDict['choice_combo'])):
if not a.DBDict['choice_combo'][i] is None:
if a.DBDict['choice_combo'][i] == 'equal':
the_day = datetime.strptime(a.DBDict['date_1'],
"%Y-%m-%d %H:%M:%S")
next_day = the_day + timedelta(days=1)
next_day = '{:%Y-%m-%d %H:%M:%S}'.format(next_day)
temp.append(test[i] >= a.DBDict['date_1'])
temp.append(test[i] <= next_day)
elif a.DBDict['choice_combo'][i] == '=<':
temp.append(test[i] <= a.DBDict['date_1'])
elif a.DBDict['choice_combo'][i] == '>=':
temp.append(test[i] >= a.DBDict['date_1'])
elif a.DBDict['choice_combo'][i] == 'between':
temp.append(test[i] >= a.DBDict['date_1'])
temp.append(test[i] <= a.DBDict['date_2'])
else:
temp.append(test[i] == a.DBDict['choice_combo'][i])
s = a.DBDict['session'].query(RadMaxData).filter(*temp).all()
if a.DBDict['choice_state']:
self.on_read_database_and_fill_list(s)
else:
[a.DBDict['session'].delete(x) for x in s]
pub.sendMessage(pubsub_sup_data_DB)
def on_save_data(self, event):
_msg = "Save data as default ?\n" + \
"This change will be applied for all fit !!\n\n"
dlg = GMD.GenericMessageDialog(None,
_msg,
"Attention",
agwStyle=wx.OK | wx.CANCEL
| wx.ICON_QUESTION)
result = dlg.ShowModal()
dlg.Destroy()
if result == wx.ID_OK:
pub.sendMessage(pubsub_Read_field_Bspline)
pub.sendMessage(pubsub_Read_field_PseudoV)
pub.sendMessage(pubsub_Read_field_Fit)
success = self.IsDataFloat()
if success:
a = P4Rm()
P4Rm.Paramwindowtest['FitParametersPanel'] = True
if False not in a.Paramwindowtest:
for k in p4R.Exp_read_only:
P4Rm.DefaultDict[k] = a.AllDataDict[k]
b = SaveFile4Diff()
b.on_update_config_file_parameters(
os.path.join(p4R.current_dir, p4R.filename + '.ini'))
P4Rm.Paramwindowtest['FitParametersPanel'] = True
pub.sendMessage(pubsub_Save_Param_and_quit, event=event)
event.Skip()
def on_delete_data(self):
a = P4Rm()
_msg = "Do you really want to delete these datas?"
dlg = GMD.GenericMessageDialog(None,
_msg,
"Confirm Suppression",
agwStyle=wx.OK | wx.CANCEL
| wx.ICON_QUESTION)
result = dlg.ShowModal()
dlg.Destroy()
if result == wx.ID_OK:
c = DataBaseUse()
c.on_delete_data()
self.on_fill_combobox()
state1 = self.rb1.SetValue(True)
state2 = self.rb2.SetValue(False)
self.state = [state1, state2]
for i in range(len(self.cb_list)):
self.cb_list[i].SetValue(False)
self.combo_list[i].Disable()
empty = a.DBDict['session'].query(RadMaxData).first()
if empty is None:
s = a.DBDict['session'].query(RadMaxData).order_by(
RadMaxData.id)
c.on_read_database_and_fill_list(s)
else:
self.on_search_in_DB()
def on_init_sp_dwp(self):
a = P4Rm()
P4Rm.ParamDict['sp_pv'] = sp_pv_initial
P4Rm.ParamDict['dwp_pv'] = dwp_pv_initial
P4Rm.ParamDict['state_sp'] = len(a.ParamDict['sp'])*[True]
P4Rm.ParamDict['state_dwp'] = len(a.ParamDict['dwp'])*[True]
def IsDataFloat(self):
a = P4Rm()
IsFloat = []
dataFloat = True
for i in range(len(self.Textcontrol)):
IsFloat.append(self.Is_number(self.Textcontrol[i].GetValue()))
if False in IsFloat:
dataFloat = False
StringPosition = [i for i, x in enumerate(IsFloat) if x is False]
for ii in StringPosition:
self.Textcontrol[ii].SetBackgroundColour('green')
self.Refresh()
_msg = "Please, fill correctly the fields before to continue"
dlg = GMD.GenericMessageDialog(None,
_msg,
"Attention",
agwStyle=wx.OK
| wx.ICON_INFORMATION)
dlg.ShowModal()
for ii in StringPosition:
self.Textcontrol[ii].SetBackgroundColour('white')
self.Refresh()
else:
i = 0
for k in p4R.s_pv:
val = self.Textcontrol[i].GetValue()
P4Rm.AllDataDict[k] = float(val)
self.Textcontrol[i].Clear()
self.Textcontrol[i].AppendText(str(a.AllDataDict[k]))
i += 1
return dataFloat
def on_update(self):
a = P4Rm()
pub.sendMessage(pubsub_Read_field4Save)
if (a.checkInitialField == 1 and a.checkGeometryField == 1 and
a.checkFittingField == 1):
P4Rm.allparameters = (a.initial_parameters +
a.fitting_parameters +
a.sample_geometry)
i = 0
for k in p4R.IP_p + p4R.F_p + p4R.SG_p:
P4Rm.AllDataDict[k] = a.allparameters[i]
i += 1
pub.sendMessage(pubsub_test_some_field)
if (a.ParamDict['Iobs'] == [] or
a.ParamDict['sp'] == [] or
a.ParamDict['dwp'] == []):
return
else:
self.on_calcul_parameters()
if a.AllDataDict['model'] == 2:
pub.sendMessage(pubsub_update_sp_dwp_eta)
P4Rm.success4Fit = 0
else:
P4Rm.success4Fit = 1
def convert_Data_File(self, name):
ll_0 = []
ll_1 = []
a = P4Rm()
with open(name, 'r') as f:
for line in self.nonblank_lines(f):
if line[0] is not '[':
ll = line.split(' = ')
ll_0.append(ll[0])
ll_1.append(ll[1])
i = 0
P4Rm.AllDataDict['model'] = 0.0
P4Rm.AllDataDict['function_profile'] = 2.0
for k in ll_0:
P4Rm.AllDataDict[k] = ll_1[i]
i += 1
P4Rm.AllDataDict['substrate_name'] = a.AllDataDict['crystal_name']
for k in p4R.s_radmax_3 + p4R.s_radmax_4 + p4R.s_radmax_5:
P4Rm.AllDataDict[k] = p4R.FitParamDefault[k]
data_path = os.path.split(name)[0]
data_file_name = os.path.splitext(os.path.basename(name))[0]
data_name = os.path.join(data_path, data_file_name + '.ini')
P4Rm.PathDict['path2inicomplete'] = data_name
b = SaveFile4Diff()
b.save_project(1)
return 0
def on_read_initial_file(self):
a = P4Rm()
b = ReadFile()
if (os.path.exists(a.PathDict['DW_file']) and
os.path.exists(a.PathDict['Strain_file']) and
os.path.exists(a.PathDict['XRD_file'])) is True:
try:
"""READING DW FILE"""
b.read_dw_file(a.PathDict['DW_file'])
"""READING Strain FILE"""
b.read_strain_file(a.PathDict['Strain_file'])
"""READING XRD FILE"""
b.read_xrd_file(a.PathDict['XRD_file'])
self.on_calc_from_xrd()
P4Rm.ParamDictbackup['dwp'] = a.ParamDict['dwp']
P4Rm.ParamDictbackup['sp'] = a.ParamDict['sp']
P4Rm.ParamDict['sp_abrupt'] = a.ParamDict['sp']
P4Rm.ParamDict['dwp_abrupt'] = a.ParamDict['dwp']
P4Rm.ParamDict['sp_smooth'] = a.ParamDict['sp']
P4Rm.ParamDict['dwp_smooth'] = a.ParamDict['dwp']
except TypeError:
logger.log(logging.WARNING, "!Please check your input file!")
else:
return True
else:
msg_ = "Please, check that the input files really exists"
dlg = GMD.GenericMessageDialog(None, msg_,
"Attention", agwStyle=wx.OK |
wx.ICON_INFORMATION)
dlg.ShowModal()
return False
def save_drx(self, case):
a = P4Rm()
name = a.PathDict['project_name'] + '.txt'
path = os.path.join(a.DefaultDict['Save_as_folder'], name)
P4Rm.PathDict[case] = path
data = column_stack(
(2 * a.ParamDict['th'] * 180 / pi, a.ParamDict['Iobs']))
savetxt(path, data, fmt='%10.8f')
def on_fill_report(self):
a = P4Rm()
data = a.FitDict['Leastsq_report']
if data is not "":
for i in range(3):
self.Textcontrol[i].SetLabel(str(data[i]))
self._logFileContents.SetValue(data[-1])
self.Refresh()
def scale_manual(self, event, val=None):
a = P4Rm()
if val is not None:
P4Rm.ParamDict['strain_multiplication'] = val
temp_1 = a.ParamDict['sp']
temp_2 = a.ParamDict['strain_multiplication']
P4Rm.ParamDict['sp'] = multiply(temp_1, temp_2)
pub.sendMessage(pubsub_Re_Read_field_paramters_panel, event=event)
def on_color(self):
a = P4Rm()
self.c_data = a.DefaultDict['c_data']
self.c_fit = a.DefaultDict['c_fit']
self.c_live = a.DefaultDict['c_fit_live']
self.l_data = a.DefaultDict['l_data']
self.l_fit = a.DefaultDict['l_fit']
self.l_live = a.DefaultDict['l_fit_live']
self.c_bkg = a.DefaultDict['c_graph_background']
def on_test_data_before_fit(self):
a = P4Rm()
P4Rm.ParamDict['sp'] = np.asarray(a.ParamDict['sp'])
P4Rm.ParamDict['dwp'] = np.asarray(a.ParamDict['dwp'])
if a.AllDataDict['model'] == 0. or a.AllDataDict['model'] == 1.:
""" do not use the last value of strain because
is out of the scope """
test_dw = (all(a.ParamDict['dwp'] > a.AllDataDict['dw_min']) and
all(a.ParamDict['dwp'][:-1] < a.AllDataDict['dw_max']))
test_strain = (all(a.ParamDict['sp'][:-1] >
a.AllDataDict['strain_min']) and
all(a.ParamDict['sp'] <
a.AllDataDict['strain_max']))
if test_dw and test_strain:
return True
else:
return False
elif a.AllDataDict['model'] == 2.:
i = 0
ls_ = [0, 4, 5, 6]
lse_ = [0, 2, 2, 4]
ld_ = [x + 6 for x in ls_]
lde_ = [x + 6 for x in lse_]
test_dw = [False] * len(a.ParamDict['dwp'])
test_strain = [False] * len(a.ParamDict['sp'])
for val_dwp, val_sp in zip(a.ParamDict['dwp'],
a.ParamDict['sp']):
if i in ls_:
v_ = ls_.index(i)
ve_ = lse_[v_]
if val_sp < a.AllDataDict[p4R.GSAp_[ve_]]:
test_strain[i] = True
elif val_sp > a.AllDataDict[p4R.GSAp_[ve_ + 1]]:
test_strain[i] = True
else:
if val_sp < 0.:
test_strain[i] = True
elif val_sp > 1.:
test_strain[i] = True
j = i + 6
if j in ld_:
v_ = ld_.index(j)
ve_ = lde_[v_]
if val_dwp < a.AllDataDict[p4R.GSAp_[ve_]]:
test_dw[i] = True
elif val_dwp > a.AllDataDict[p4R.GSAp_[ve_ + 1]]:
test_dw[i] = True
else:
if val_dwp < 0.:
test_dw[i] = True
elif val_dwp > 1.:
test_dw[i] = True
i += 1
if (True in test_dw) or (True in test_strain):
return False
else:
return True
def on_add_new_name_to_combobox(self):
a = P4Rm()
if not a.PathDict['project_name'] in a.DBDict['name']:
c = DataBaseUse()
c.on_read_part_DB()
self.name.SetItems(a.DBDict['name'])
self.name.SetStringSelection(a.DBDict['name'][0])
self.Layout()
self.SetAutoLayout(1)
def OnDrawGraph(self, b=None):
a = P4Rm()
self.modelpv = a.modelPv
self.ax.clear()
if a.AllDataDict['damaged_depth'] == 0:
self.ax.text(0.5,
0.5,
"No Damage",
size=30,
rotation=0.,
ha="center",
va="center",
bbox=dict(
boxstyle="round",
ec='red',
fc=self.c_dw,
))
x_dwp = [-1]
y_dwp = [-1]
xs = [-1]
ys = [-1]
self.ax.set_xticklabels([])
self.ax.set_yticklabels([])
self.ax.set_xlim([0, 1])
self.ax.set_ylim([0, 1])
else:
if b != 2:
x_dwp = a.ParamDict['x_dwp']
y_dwp = a.ParamDict['DW_shifted']
xs = deepcopy(a.ParamDict['depth'])
ys = deepcopy(a.ParamDict['DW_i'])
P4Rm.DragDrop_DW_x = x_dwp
P4Rm.DragDrop_DW_y = y_dwp
ymin = min(ys) - min(ys) * 10 / 100
ymax = max(ys) + max(ys) * 10 / 100
self.ax.set_ylim([ymin, ymax])
if a.ParamDict['x_dwp'] != "":
self.ax.set_xlim(
[a.ParamDict['depth'][-1], a.ParamDict['depth'][0]])
elif b == 2:
x_dwp = [-1]
y_dwp = [-1]
xs = [-1]
ys = [-1]
self.ax.set_xlim([0, 1])
self.ax.set_ylim([0, 1])
poly = Polygon(list(zip(x_dwp, y_dwp)),
lw=0,
ls='solid',
color=self.c_dw,
fill=False,
closed=False,
animated=True)
if self.modelpv is True:
P4Rm.ParamDict['dwp_pv_backup'] = a.ParamDict['dwp']
self.draw_c(poly, xs, ys)
def OnChangeBasisFunction(self, strain, dw, spline_strain,
spline_DW, slice_):
a = P4Rm()
strain_change = 0
dw_change = 0
slice_change = 0
if strain != float(a.ParamDict['strain_basis_backup']):
P4Rm.ParamDict['strain_basis_backup'] = strain
P4Rm.ParamDict['state_sp'] = int(strain)*[True]
strain_change = 1
if dw != a.ParamDict['dw_basis_backup']:
P4Rm.ParamDict['dw_basis_backup'] = dw
dw_change = 1
if slice_ != float(a.ParamDict['slice_backup']):
P4Rm.ParamDict['slice_backup'] = slice_
slice_change = 1
if a.FitDict['New&Load'] == 1:
dw_change = 1
if strain_change == 1 or dw_change == 1 or slice_change == 1:
temp = self.find_nearest_damaged_depth(a.AllDataDict['damaged_depth'],
a.AllDataDict['number_slices'],
strain)
P4Rm.AllDataDict['damaged_depth'] = temp[0]
P4Rm.AllDataDict['number_slices'] = temp[1]
damaged_val = temp[0]
slice_val = temp[1]
dw, index, list_ = self.find_nearest_dw(a.AllDataDict['number_slices'],
dw, strain, strain_change,
dw_change, slice_change)
P4Rm.ParamDict['t_l'] = damaged_val/slice_val
P4Rm.ParamDict['z'] = arange(slice_val+1) * a.ParamDict['t_l']
P4Rm.ParamDict['dwp'] = old2new_DW(a.ParamDict['z'],
a.ParamDict['dwp'],
damaged_val, dw, spline_DW)
P4Rm.ParamDict['sp'] = old2new_strain(a.ParamDict['z'],
a.ParamDict['sp'],
damaged_val, strain,
spline_strain)
P4Rm.ParamDictbackup['dwp'] = deepcopy(a.ParamDict['dwp'])
P4Rm.ParamDictbackup['sp'] = deepcopy(a.ParamDict['sp'])
P4Rm.FitDict['New&Load'] = 0
P4Rm.FitDict['list4DW'] = list_
tmp = []
tmp.append(list_)
tmp.append(index)
tmp.append(damaged_val)
tmp.append(dw)
tmp.append(slice_val)
P4Rm.ParamDict['state_dwp'] = dw*[True]
pub.sendMessage(pubsub_change_basic_function, tmp=tmp)
return slice_val, dw
else:
slice_val = int(a.AllDataDict['number_slices'])
return slice_val, dw
def on_init(self):
a = P4Rm()
i = 0
for k in p4R.s_GSA_expert:
self.TextcontrolGSA[i].AppendText(str(a.AllDataDict[k]))
i += 1
i = 0
for k in p4R.s_leastsq:
self.TextcontrolLeastsq[i].AppendText(str(a.AllDataDict[k]))
i += 1
def OnUnzoom(self, event=None):
self.canvas.toolbar.home()
P4Rm.zoomOn = 0
a = P4Rm()
P4Rm.ParamDict['th'] = a.ParamDictbackup['th']
P4Rm.ParamDict['Iobs'] = a.ParamDictbackup['Iobs']
P4Rm.ParamDict['th4live'] = 2 * a.ParamDict['th'] * 180 / np.pi
pub.sendMessage(pubsub_Re_Read_field_paramters_panel)
self.CheckedGrid()
self.CursorMove()
def re_fill_list(self):
a = P4Rm()
self.Freeze()
if a.db_nb_line is not -1:
self.list.SortBy(0, ascending=False)
self.list.SetFilter(Filter.Head(a.db_nb_line))
else:
self.list.SetFilter(None)
self.list.RepopulateList()
self.Thaw()
