def apply_parameters_reverse(self, event=None):
""" Read the values from the pages parameters and write
it to the GUI form.
"""
modelid = self.corr.fit_model.id
#
# As of version 0.7.5: we want the units to be displayed
# human readable - the way they are displayed
# in the Page info tool.
#
# Here: Convert program internal units to
# human readable units
parameters = mdls.GetHumanReadableParms(modelid,
self.corr.fit_parameters)[1]
parameters_variable = self.corr.fit_parameters_variable
# Write parameters to the form on the Page
for i in np.arange(len(self.active_parms[1])):
self.spincontrol[i].SetValue(parameters[i])
self.checkboxes[i].SetValue(parameters_variable[i])
# Fitting parameters
self.Fitbox[5].SetValue(self.weighted_nuvar)
idf = self.weighted_fittype_id
List = self.Fitbox[1].GetItems()
List[1] = "spline (" + str(self.FitKnots) + " knots)"
self.Fitbox[1].SetItems(List)
self.Fitbox[1].SetSelection(idf)
# Normalization
if self.corr.normparm is None:
normsel = 0
else:
normsel = self.corr.normparm + 1
self.AmplitudeInfo[2].SetSelection(normsel)
# Fitting algorithm
keys = fit.GetAlgorithmStringList()[0]
idalg = keys.index(self.corr.fit_algorithm)
self.AlgorithmDropdown.SetSelection(idalg)
self.updateChi2()
def settings(self):
""" Here we define, what should be displayed at the left side
of the fitting page/tab.
Parameters:
"""
modelid = self.corr.fit_model.id
horizontalsize = self.sizepanelx - 10
# Title
# Create empty tab title
mddat = mdls.modeldict[modelid]
modelshort = mdls.GetModelType(modelid)
titlelabel = u"Data set {} ({} {})".format(self.counter.strip(" :"),
modelshort, mddat[1])
boxti = wx.StaticBox(self.panelsettings, label=titlelabel)
sizerti = wx.StaticBoxSizer(boxti, wx.VERTICAL)
sizerti.SetMinSize((horizontalsize, -1))
self.tabtitle = wx.TextCtrl(self.panelsettings,
value="",
size=(horizontalsize - 20, -1))
self.Bind(wx.EVT_TEXT, self.OnTitleChanged, self.tabtitle)
sizerti.Add(self.tabtitle, 0, wx.EXPAND, 0)
# Create StaticBoxSizer
box1, check, spin = self.MakeStaticBoxSizer("Model parameters")
# Make the check boxes and spin-controls available everywhere
self.checkboxes = check
self.spincontrol = spin
#
# As of version 0.7.5: we want the units to be displayed
# human readable - the way they are displayed
# in the Page info tool.
#
labels, parameters = mdls.GetHumanReadableParms(
modelid, self.active_parms[1])
parameterstofit = self.active_parms[2]
# Set initial values given by user/programmer for Diffusion Model
for i in np.arange(len(labels)):
self.checkboxes[i].SetValue(parameterstofit[i])
self.spincontrol[i].SetValue(parameters[i])
# Put everything together
self.panelsettings.sizer = wx.BoxSizer(wx.VERTICAL)
self.panelsettings.sizer.Add(sizerti, 0, wx.EXPAND, 0)
self.panelsettings.sizer.Add(box1, 0, wx.EXPAND, 0)
# checkbox "Protect from batch control"
self.wxCBPreventBatchParms = wx.CheckBox(self.panelsettings, -1,
"prevent batch modification")
box1.Add(self.wxCBPreventBatchParms)
# buttons "Apply" and "Set range"
horzs = wx.BoxSizer(wx.HORIZONTAL)
buttonapply = wx.Button(self.panelsettings, label="Apply")
self.Bind(wx.EVT_BUTTON, self.PlotAll, buttonapply)
horzs.Add(buttonapply)
buttonrange = wx.Button(self.panelsettings, label="Set range")
self.Bind(wx.EVT_BUTTON, self.OnSetRange, buttonrange)
horzs.Add(buttonrange)
box1.Add(horzs)
# Set horizontal size
box1.SetMinSize((horizontalsize, -1))
# More info
normbox = wx.StaticBox(self.panelsettings,
label="Amplitude corrections")
miscsizer = wx.StaticBoxSizer(normbox, wx.VERTICAL)
miscsizer.SetMinSize((horizontalsize, -1))
# Intensities and Background
sizeint = wx.FlexGridSizer(rows=3, cols=3, vgap=5, hgap=5)
sizeint.Add(wx.StaticText(self.panelsettings, label="[kHz]"))
sizeint.Add(wx.StaticText(self.panelsettings, label="Intensity"))
sizeint.Add(wx.StaticText(self.panelsettings, label="Background"))
sizeint.Add(wx.StaticText(self.panelsettings, label="Ch1"))
intlabel1 = wx.TextCtrl(self.panelsettings)
bgspin1 = wxutils.PCFFloatTextCtrl(self.panelsettings)
bgspin1.Bind(wx.EVT_KILL_FOCUS, self.OnBGSpinChanged)
bgspin1.Bind(wx.EVT_TEXT_ENTER, self.OnBGSpinChanged)
sizeint.Add(intlabel1)
intlabel1.SetEditable(False)
sizeint.Add(bgspin1)
chtext2 = wx.StaticText(self.panelsettings, label="Ch2")
sizeint.Add(chtext2)
intlabel2 = wx.TextCtrl(self.panelsettings)
intlabel2.SetEditable(False)
bgspin2 = wxutils.PCFFloatTextCtrl(self.panelsettings)
bgspin2.Bind(wx.EVT_KILL_FOCUS, self.OnBGSpinChanged)
sizeint.Add(intlabel2)
sizeint.Add(bgspin2)
miscsizer.Add(sizeint)
# Normalize to n?
textnor = wx.StaticText(self.panelsettings, label="Plot normalization")
miscsizer.Add(textnor)
normtoNDropdown = wx.ComboBox(self.panelsettings)
self.Bind(wx.EVT_COMBOBOX, self.PlotAll, normtoNDropdown)
miscsizer.Add(normtoNDropdown)
self.AmplitudeInfo = [[intlabel1, intlabel2], [bgspin1, bgspin2],
normtoNDropdown, textnor]
self.WXAmplitudeCCOnlyStuff = [chtext2, intlabel2, bgspin2]
self.panelsettings.sizer.Add(miscsizer, 0, wx.EXPAND, 0)
# Add fitting Box
fitbox = wx.StaticBox(self.panelsettings, label="Fitting options")
fitsizer = wx.StaticBoxSizer(fitbox, wx.VERTICAL)
fitsizer.SetMinSize((horizontalsize, -1))
# Add a checkbox for weighted fitting
weightedfitdrop = wx.ComboBox(self.panelsettings)
self.weightlist = ["no weights", "spline (5 knots)", "model function"]
weightedfitdrop.SetItems(self.weightlist)
weightedfitdrop.SetSelection(0)
fitsizer.Add(weightedfitdrop)
# WeightedFitCheck() Enables or Disables the variance part
weightedfitdrop.Bind(wx.EVT_COMBOBOX, self.Fit_WeightedFitCheck)
# Add the variance part.
# In order to do a weighted fit, we need to calculate the variance
# at each point of the experimental data array.
# In order to do that, we need to know how many data points from left
# and right of the interesting data point we want to include in that
# calculation.
fittext = wx.StaticText(self.panelsettings,
label="Calculation of the variance")
fitsizer.Add(fittext)
fittext2 = wx.StaticText(self.panelsettings,
label="from 2j+1 data points")
fitsizer.Add(fittext2)
fitsizerspin = wx.BoxSizer(wx.HORIZONTAL)
fittextvar = wx.StaticText(self.panelsettings, label="j = ")
fitspin = wx.SpinCtrl(self.panelsettings,
-1,
initial=3,
min=1,
max=100)
fitsizerspin.Add(fittextvar)
fitsizerspin.Add(fitspin)
fitsizer.Add(fitsizerspin)
# Add algorithm selection
textalg = wx.StaticText(self.panelsettings, label="Algorithm")
fitsizer.Add(textalg)
self.AlgorithmDropdown = wx.ComboBox(self.panelsettings)
items = fit.GetAlgorithmStringList()[1]
self.AlgorithmDropdown.SetItems(items)
self.Bind(wx.EVT_COMBOBOX, self.apply_parameters,
self.AlgorithmDropdown)
fitsizer.Add(self.AlgorithmDropdown)
self.AlgorithmDropdown.SetMaxSize(weightedfitdrop.GetSize())
# Add button "Fit" and chi2 display
fitbuttonsizer = wx.BoxSizer(wx.HORIZONTAL)
buttonfit = wx.Button(self.panelsettings, label="Fit")
self.Bind(wx.EVT_BUTTON, self.Fit_function, buttonfit)
fitbuttonsizer.Add(buttonfit)
# add shortcut
acctbl = wx.AcceleratorTable([(wx.ACCEL_CTRL, ord('F'),
buttonfit.GetId())])
self.SetAcceleratorTable(acctbl)
##
self.WXTextChi2 = wx.StaticText(self.panelsettings)
# this StaticText is updated by `self.updateChi2()`
fitbuttonsizer.Add(self.WXTextChi2, flag=wx.ALIGN_CENTER)
fitsizer.Add(fitbuttonsizer)
self.panelsettings.sizer.Add(fitsizer, 0, wx.EXPAND, 0)
# Squeeze everything into the sizer
self.panelsettings.SetSizer(self.panelsettings.sizer)
# This is also necessary in Windows
self.panelsettings.Layout()
self.panelsettings.Show()
# Make all the stuff available for everyone
self.Fitbox = [
fitbox, weightedfitdrop, fittext, fittext2, fittextvar, fitspin,
buttonfit, textalg, self.AlgorithmDropdown
]
# Disable Fitting since no data has been loaded yet
for element in self.Fitbox:
element.Disable()
self.panelsettings.sizer.Fit(self.panelsettings)
self.parent.Layout()
def apply_parameters(self, event=None):
""" Read the values from the GUI form and write it to the
pages parameters / correlation class.
This function is called when the "Apply" button is hit.
"""
modelid = self.corr.fit_model.id
parameters = list()
parameters_variable = list()
# Read parameters from form and update self.active_parms[1]
for i in np.arange(len(self.spincontrol)):
parameters.append(1 * self.spincontrol[i].GetValue())
parameters_variable.append(self.checkboxes[i].GetValue())
self.corr.fit_parameters_variable = np.array(parameters_variable,
dtype=bool)
# As of version 0.7.5: we want the units to be displayed
# human readable - the way they are displayed
# in the Page info tool.
# Here: Convert human readable units to program internal
# units
parmsconv = mdls.GetInternalFromHumanReadableParm(
modelid, np.array(parameters))[1]
self.corr.fit_parameters = parmsconv
# Fitting parameters
self.weighted_nuvar = self.Fitbox[5].GetValue()
self.weighted_fittype_id = self.Fitbox[1].GetSelection()
fitbox_value = self.Fitbox[1].GetValue()
if self.weighted_fittype_id == -1:
# User edited knot number
Knots = fitbox_value
Knots = "".join(filter(lambda x: x.isdigit(), Knots))
if Knots == "":
Knots = "5"
self.weighted_fittype_id = 1
self.FitKnots = str(Knots)
fit_weight_type = "spline{}".format(self.FitKnots)
fit_weight_data = self.weighted_nuvar
elif self.weighted_fittype_id == 1:
Knots = fitbox_value
Knots = "".join(filter(lambda x: x.isdigit(), Knots))
self.FitKnots = int(Knots)
fit_weight_type = "spline{}".format(self.FitKnots)
fit_weight_data = self.weighted_nuvar
elif self.weighted_fittype_id == 0:
fit_weight_type = "none"
fit_weight_data = None
elif self.weighted_fittype_id == 2:
fit_weight_type = "model function"
fit_weight_data = self.weighted_nuvar
else: # fitbox_selection > 2:
fit_weight_type = fitbox_value
self.corr.fit_weight_type = fitbox_value
fit_weight_data = self.corr.fit_weight_data
# Fitting algorithm
keys = fit.GetAlgorithmStringList()[0]
idalg = self.AlgorithmDropdown.GetSelection()
self.corr.fit_algorithm = keys[idalg]
self.corr.fit_weight_type = fit_weight_type
self.corr.fit_weight_data = fit_weight_data
# If parameters have been changed because of the check_parms
# function, write them back.
self.apply_parameters_reverse()