source: sasview/src/sas/sasgui/perspectives/fitting/fitpage.py @ 1a8e13f0

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 1a8e13f0 was 1a8e13f0, checked in by Paul Kienzle <pkienzle@…>, 3 years ago

remove unnecessary sleep

  • Property mode set to 100644
File size: 128.1 KB
Line 
1"""
2    FitPanel class contains fields allowing to display results when
3    fitting  a model and one data
4"""
5import sys
6import wx
7import wx.lib.newevent
8import numpy
9import copy
10import math
11import time
12import traceback
13
14from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
15
16from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \
17    PlotQrangeEvent
18from sas.sasgui.guiframe.dataFitting import check_data_validity
19from sas.sasgui.guiframe.utils import format_number, check_float
20from sas.sasgui.guiframe.documentation_window import DocumentationWindow
21
22from sas.sasgui.perspectives.fitting.basepage import BasicPage as BasicPage
23from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as \
24    PageInfoEvent
25from sas.sascalc.data_util.qsmearing import smear_selection
26from .basepage import ModelTextCtrl
27
28(Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent()
29_BOX_WIDTH = 76
30_DATA_BOX_WIDTH = 300
31SMEAR_SIZE_L = 0.00
32SMEAR_SIZE_H = 0.00
33
34
35class FitPage(BasicPage):
36    """
37    FitPanel class contains fields allowing to display results when
38    fitting  a model and one data
39
40    :note: For Fit to be performed the user should check at least one parameter
41        on fit Panel window.
42    """
43
44    def __init__(self, parent, color=None):
45        """
46        Initialization of the Panel
47        """
48        BasicPage.__init__(self, parent, color=color)
49
50        # draw sizer
51        self._fill_data_sizer()
52        self.is_2D = None
53        self.fit_started = False
54        self.weightbt_string = None
55        self.m_name = None
56        # get smear info from data
57        self._get_smear_info()
58        self._fill_model_sizer(self.sizer1)
59        self._get_defult_custom_smear()
60        self._fill_range_sizer()
61        self._set_smear(self.data)
62        self.Bind(EVT_CHI2_UPDATE, self.on_complete_chisqr)
63        # bind key event
64        self.Bind(wx.EVT_RIGHT_DOWN, self.on_right_down)
65        self._set_bookmark_flag(False)
66        self._set_save_flag(False)
67        self._set_preview_flag(False)
68        self._set_copy_flag(False)
69        self._set_paste_flag(False)
70        self.btFit.SetFocus()
71        self.enable_fit_button()
72        self.fill_data_combobox(data_list=self.data_list)
73        # create a default data for an empty panel
74        self.create_default_data()
75        self._manager.frame.Bind(wx.EVT_SET_FOCUS, self.on_set_focus)
76
77    def enable_fit_button(self):
78        """
79        Enable fit button if data is valid and model is valid
80        """
81        flag = check_data_validity(self.data) & (self.model is not None)
82        self.btFit.Enable(flag)
83
84    def on_set_focus(self, event):
85        """
86        Override the basepage focus method to ensure the save flag is set
87        properly when focusing on the fit page.
88        """
89        flag = check_data_validity(self.data) & (self.model is not None)
90        self._set_save_flag(flag)
91        self.parent.on_set_focus(event)
92        self.on_tap_focus()
93
94    def _fill_data_sizer(self):
95        """
96        fill sizer 0 with data info
97        """
98        self.data_box_description = wx.StaticBox(self, wx.ID_ANY,
99                                                 'I(q) Data Source')
100        if check_data_validity(self.data):
101            dname_color = wx.BLUE
102        else:
103            dname_color = wx.RED
104        self.data_box_description.SetForegroundColour(dname_color)
105        boxsizer1 = wx.StaticBoxSizer(self.data_box_description, wx.VERTICAL)
106        # ----------------------------------------------------------
107        sizer_data = wx.BoxSizer(wx.HORIZONTAL)
108        self.dataSource = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
109        wx.EVT_COMBOBOX(self.dataSource, wx.ID_ANY, self.on_select_data)
110        self.dataSource.SetMinSize((_DATA_BOX_WIDTH, -1))
111        sizer_data.Add(wx.StaticText(self, wx.ID_ANY, 'Name : '))
112        sizer_data.Add(self.dataSource)
113        sizer_data.Add((0, 5))
114        boxsizer1.Add(sizer_data, 0, wx.ALL, 10)
115        self.sizer0.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
116        self.sizer0.Layout()
117
118    def enable_datasource(self):
119        """
120        Enable or disable data source control depending on existing data
121        """
122        if not self.data_list:
123            self.dataSource.Disable()
124        else:
125            self.dataSource.Enable()
126
127    def fill_data_combobox(self, data_list):
128        """
129        Get a list of data and fill the corresponding combobox
130        """
131        self.dataSource.Clear()
132        self.data_list = data_list
133        self.enable_datasource()
134        if len(data_list) > 0:
135            # find the maximum range covering all data
136            qmin, qmax, npts = self.compute_data_set_range(data_list)
137            self.qmin_data_set = qmin
138            self.qmax_data_set = qmax
139            self.npts_data_set = npts
140
141            self.qmin.SetValue(str(self.qmin_data_set))
142            self.qmax.SetValue(str(self.qmax_data_set))
143            self.qmin.SetBackgroundColour("white")
144            self.qmax.SetBackgroundColour("white")
145            self.qmin_x = self.qmin_data_set
146            self.qmax_x = self.qmax_data_set
147            self.state.qmin = self.qmin_x
148            self.state.qmax = self.qmax_x
149        is_data = False
150        for data in self.data_list:
151            if data is not None:
152                self.dataSource.Append(str(data.name), clientData=data)
153                if not is_data:
154                    is_data = check_data_validity(data)
155        if is_data:
156            self.dataSource.SetSelection(0)
157            self.on_select_data(event=None)
158
159        if len(data_list) == 1:
160            self.dataSource.Disable()
161
162    def on_select_data(self, event=None):
163        """
164        On_select_data
165        """
166        if event is None and self.dataSource.GetCount() > 0:
167            data = self.dataSource.GetClientData(0)
168            self.set_data(data)
169        elif self.dataSource.GetCount() > 0:
170            pos = self.dataSource.GetSelection()
171            data = self.dataSource.GetClientData(pos)
172            self.set_data(data)
173
174    def _on_fit_complete(self):
175        """
176        When fit is complete ,reset the fit button label.
177        """
178        self.fit_started = False
179        self.set_fitbutton()
180
181    def _is_2D(self):
182        """
183        Check if data_name is Data2D
184
185        :return: True or False
186        """
187        if self.data.__class__.__name__ == "Data2D" or \
188                        self.enable2D:
189            return True
190        return False
191
192    def _fill_range_sizer(self):
193        """
194        Fill the Fitting sizer on the fit panel which contains: the smearing
195        information (dq), the weighting information (dI or other), the plotting
196        range, access to the 2D mask editor, the compute, fit, and help
197        buttons, xi^2, number of points etc.
198        """
199        is_2d_data = False
200
201        # Check if data is 2D
202        if self.data.__class__.__name__ == "Data2D" or \
203                        self.enable2D:
204            is_2d_data = True
205
206        title = "Fitting"
207        # smear messages & titles
208        smear_message_none = "No smearing is selected..."
209        smear_message_dqdata = "The dQ data is being used for smearing..."
210        smear_message_2d = \
211              "Higher accuracy is very time-expensive. Use it with care..."
212        smear_message_new_ssmear = \
213              "Please enter only the value of interest to customize smearing..."
214        smear_message_new_psmear = \
215              "Please enter both; the dQ will be generated by interpolation..."
216        smear_message_2d_x_title = "<dQp>[1/A]:"
217        smear_message_2d_y_title = "<dQs>[1/A]:"
218        smear_message_pinhole_min_title = "dQ_low[1/A]:"
219        smear_message_pinhole_max_title = "dQ_high[1/A]:"
220        smear_message_slit_height_title = "Slit height[1/A]:"
221        smear_message_slit_width_title = "Slit width[1/A]:"
222
223        self._get_smear_info()
224
225        # Sizers
226        box_description_range = wx.StaticBox(self, wx.ID_ANY, str(title))
227        box_description_range.SetForegroundColour(wx.BLUE)
228        boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)
229        self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL)
230        sizer_smearer = wx.BoxSizer(wx.HORIZONTAL)
231        self.sizer_new_smear = wx.BoxSizer(wx.HORIZONTAL)
232        self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
233        sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
234        smear_set_box = wx.StaticBox(self, wx.ID_ANY,
235                                     'Set Instrumental Smearing')
236        sizer_smearer_box = wx.StaticBoxSizer(smear_set_box, wx.HORIZONTAL)
237        sizer_smearer_box.SetMinSize((_DATA_BOX_WIDTH, 60))
238
239        weighting_set_box = wx.StaticBox(self, wx.ID_ANY,
240                                         'Set Weighting by Selecting dI Source')
241        weighting_box = wx.StaticBoxSizer(weighting_set_box, wx.HORIZONTAL)
242        sizer_weighting = wx.BoxSizer(wx.HORIZONTAL)
243        weighting_box.SetMinSize((_DATA_BOX_WIDTH, 40))
244        # Filling the sizer containing weighting info.
245        self.dI_noweight = wx.RadioButton(self, wx.ID_ANY,
246                                          'No Weighting', style=wx.RB_GROUP)
247        self.dI_didata = wx.RadioButton(self, wx.ID_ANY, 'Use dI Data')
248        self.dI_sqrdata = wx.RadioButton(self, wx.ID_ANY, 'Use |sqrt(I Data)|')
249        self.dI_idata = wx.RadioButton(self, wx.ID_ANY, 'Use |I Data|')
250        self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
251                  id=self.dI_noweight.GetId())
252        self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
253                  id=self.dI_didata.GetId())
254        self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
255                  id=self.dI_sqrdata.GetId())
256        self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting,
257                  id=self.dI_idata.GetId())
258        self.dI_didata.SetValue(True)
259        # add 4 types of weighting to the sizer
260        sizer_weighting.Add(self.dI_noweight, 0, wx.LEFT, 10)
261        sizer_weighting.Add((14, 10))
262        sizer_weighting.Add(self.dI_didata)
263        sizer_weighting.Add((14, 10))
264        sizer_weighting.Add(self.dI_sqrdata)
265        sizer_weighting.Add((14, 10))
266        sizer_weighting.Add(self.dI_idata)
267        sizer_weighting.Add((10, 10))
268        self.dI_noweight.Enable(False)
269        self.dI_didata.Enable(False)
270        self.dI_sqrdata.Enable(False)
271        self.dI_idata.Enable(False)
272        weighting_box.Add(sizer_weighting)
273
274        # combobox for smear2d accuracy selection
275        self.smear_accuracy = wx.ComboBox(self, wx.ID_ANY,
276                                          size=(50, -1), style=wx.CB_READONLY)
277        self._set_accuracy_list()
278        self.smear_accuracy.SetValue(self.smear2d_accuracy)
279        self.smear_accuracy.SetSelection(0)
280        self.smear_accuracy.SetToolTipString(
281            "'Higher' uses more Gaussian points for smearing computation.")
282
283        wx.EVT_COMBOBOX(self.smear_accuracy, wx.ID_ANY,
284                        self._on_select_accuracy)
285
286        # Fit button
287        self.btFit = wx.Button(self, self._ids.next(), 'Fit')
288        self.default_bt_colour = self.btFit.GetDefaultAttributes()
289        self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id=self.btFit.GetId())
290        self.btFit.SetToolTipString("Start fitting.")
291
292        # General Help button
293        self.btFitHelp = wx.Button(self, wx.ID_ANY, 'Help')
294        self.btFitHelp.SetToolTipString("General fitting help.")
295        self.btFitHelp.Bind(wx.EVT_BUTTON, self._onFitHelp)
296       
297        # Resolution Smearing Help button (for now use same technique as
298        # used for dI help to get tiniest possible button that works
299        # both on MAC and PC.  Should completely rewrite the fitting sizer
300        # in future.  This is minimum to get out release 3.1
301        #        comment June 14, 2015     --- PDB
302        if sys.platform.count("win32") > 0:
303            size_q = (20, 15)  # on PC
304        else:
305            size_q = (30, 20)  # on MAC
306        self.btSmearHelp = wx.Button(self, wx.ID_ANY, '?',
307                                     style=wx.BU_EXACTFIT, size=size_q)
308        self.btSmearHelp.SetToolTipString("Resolution smearing help.")
309        self.btSmearHelp.Bind(wx.EVT_BUTTON, self._onSmearHelp)
310       
311        # textcntrl for custom resolution
312        self.smear_pinhole_max = ModelTextCtrl(self, wx.ID_ANY,
313                            size=(_BOX_WIDTH - 25, 20),
314                            style=wx.TE_PROCESS_ENTER,
315                            text_enter_callback=self.onPinholeSmear)
316        self.smear_pinhole_min = ModelTextCtrl(self, wx.ID_ANY,
317                            size=(_BOX_WIDTH - 25, 20),
318                            style=wx.TE_PROCESS_ENTER,
319                            text_enter_callback=self.onPinholeSmear)
320        self.smear_slit_height = ModelTextCtrl(self, wx.ID_ANY,
321                            size=(_BOX_WIDTH - 25, 20),
322                            style=wx.TE_PROCESS_ENTER,
323                            text_enter_callback=self.onSlitSmear)
324        self.smear_slit_width = ModelTextCtrl(self, wx.ID_ANY,
325                            size=(_BOX_WIDTH - 25, 20),
326                            style=wx.TE_PROCESS_ENTER,
327                            text_enter_callback=self.onSlitSmear)
328
329        # smear
330        self.smear_data_left = BGTextCtrl(self, wx.ID_ANY,
331                                          size=(_BOX_WIDTH - 25, 20), style=0)
332        self.smear_data_left.SetValue(str(self.dq_l))
333        self.smear_data_right = BGTextCtrl(self, wx.ID_ANY,
334                                           size=(_BOX_WIDTH - 25, 20), style=0)
335        self.smear_data_right.SetValue(str(self.dq_r))
336
337        # set default values for smear
338        self.smear_pinhole_max.SetValue(str(self.dx_max))
339        self.smear_pinhole_min.SetValue(str(self.dx_min))
340        self.smear_slit_height.SetValue(str(self.dxl))
341        self.smear_slit_width.SetValue(str(self.dxw))
342
343        # Filling the sizer containing instruments smearing info.
344        self.disable_smearer = wx.RadioButton(self, wx.ID_ANY,
345                                              'None', style=wx.RB_GROUP)
346        self.enable_smearer = wx.RadioButton(self, wx.ID_ANY, 'Use dQ Data')
347        # self.enable_smearer.SetToolTipString(
348        # "Click to use the loaded dQ data for smearing.")
349        self.pinhole_smearer = wx.RadioButton(self, wx.ID_ANY,
350                                              'Custom Pinhole Smear')
351        # self.pinhole_smearer.SetToolTipString
352        # ("Click to input custom resolution for pinhole smearing.")
353        self.slit_smearer = wx.RadioButton(self, wx.ID_ANY, 'Custom Slit Smear')
354        # self.slit_smearer.SetToolTipString
355        # ("Click to input custom resolution for slit smearing.")
356        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear,
357                  id=self.disable_smearer.GetId())
358        self.Bind(wx.EVT_RADIOBUTTON, self.onSmear,
359                  id=self.enable_smearer.GetId())
360        self.Bind(wx.EVT_RADIOBUTTON, self.onPinholeSmear,
361                  id=self.pinhole_smearer.GetId())
362        self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear,
363                  id=self.slit_smearer.GetId())
364        self.enable_smearer.SetValue(True)
365
366        sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10)
367        sizer_smearer.Add(self.enable_smearer)
368        sizer_smearer.Add(self.pinhole_smearer)
369        sizer_smearer.Add(self.slit_smearer)
370        sizer_smearer.Add(self.btSmearHelp)
371        sizer_smearer.Add((10, 10))
372
373        # StaticText for chi2, N(for fitting), Npts + Log/linear spacing
374        self.tcChi = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0)
375        self.tcChi.SetToolTipString("Chi2/Npts(Fit)")
376        self.Npts_fit = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0)
377        self.Npts_fit.SetToolTipString(
378            " Npts : number of points selected for fitting")
379        self.Npts_total = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
380                                        style=wx.TE_PROCESS_ENTER,
381                                        text_enter_callback=self._onQrangeEnter)
382        self.Npts_total.SetValue(format_number(self.npts_x))
383        self.Npts_total.SetToolTipString(
384            " Total Npts : total number of data points")
385
386        # Update and Draw button
387        self.draw_button = wx.Button(self, self._ids.next(), 'Compute')
388        self.draw_button.Bind(wx.EVT_BUTTON,
389                              self._onDraw, id=self.draw_button.GetId())
390        self.draw_button.SetToolTipString("Compute and Draw.")
391
392        self.points_sizer = wx.BoxSizer(wx.HORIZONTAL)
393        self.pointsbox = wx.CheckBox(self, wx.ID_ANY, 'Log?', (10, 10))
394        self.pointsbox.SetValue(False)
395        self.pointsbox.SetToolTipString("Check mark to use log spaced points")
396        wx.EVT_CHECKBOX(self, self.pointsbox.GetId(), self.select_log)
397
398        self.points_sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Npts    '))
399        self.points_sizer.Add(self.pointsbox)
400
401        box_description_1 = wx.StaticText(self, wx.ID_ANY, '   Chi2/Npts')
402        box_description_2 = wx.StaticText(self, wx.ID_ANY, 'Npts(Fit)')
403
404        # StaticText for smear
405        self.smear_description_none = wx.StaticText(self, wx.ID_ANY,
406                                    smear_message_none, style=wx.ALIGN_LEFT)
407        self.smear_description_dqdata = wx.StaticText(self, wx.ID_ANY,
408                                 smear_message_dqdata, style=wx.ALIGN_LEFT)
409        self.smear_description_type = wx.StaticText(self, wx.ID_ANY,
410                                    "Type:", style=wx.ALIGN_LEFT)
411        self.smear_description_accuracy_type = wx.StaticText(self, wx.ID_ANY,
412                                    "Accuracy:", style=wx.ALIGN_LEFT)
413        self.smear_description_smear_type = BGTextCtrl(self, wx.ID_ANY,
414                                                       size=(57, 20), style=0)
415        self.smear_description_smear_type.SetValue(str(self.dq_l))
416        self.SetBackgroundColour(self.GetParent().GetBackgroundColour())
417        self.smear_description_2d = wx.StaticText(self, wx.ID_ANY,
418                                    smear_message_2d, style=wx.ALIGN_LEFT)
419        self.smear_message_new_s = wx.StaticText(self, wx.ID_ANY,
420                         smear_message_new_ssmear, style=wx.ALIGN_LEFT)
421        self.smear_message_new_p = wx.StaticText(self, wx.ID_ANY,
422                            smear_message_new_psmear, style=wx.ALIGN_LEFT)
423        self.smear_description_2d_x = wx.StaticText(self, wx.ID_ANY,
424                            smear_message_2d_x_title, style=wx.ALIGN_LEFT)
425        self.smear_description_2d_x.SetToolTipString(
426                                        "  dQp(parallel) in q_r direction.")
427        self.smear_description_2d_y = wx.StaticText(self, wx.ID_ANY,
428                            smear_message_2d_y_title, style=wx.ALIGN_LEFT)
429        self.smear_description_2d_y.SetToolTipString(
430                                    " dQs(perpendicular) in q_phi direction.")
431        self.smear_description_pin_min = wx.StaticText(self, wx.ID_ANY,
432                        smear_message_pinhole_min_title, style=wx.ALIGN_LEFT)
433        self.smear_description_pin_max = wx.StaticText(self, wx.ID_ANY,
434                        smear_message_pinhole_max_title, style=wx.ALIGN_LEFT)
435        self.smear_description_slit_height = wx.StaticText(self, wx.ID_ANY,
436                        smear_message_slit_height_title, style=wx.ALIGN_LEFT)
437        self.smear_description_slit_width = wx.StaticText(self, wx.ID_ANY,
438                        smear_message_slit_width_title, style=wx.ALIGN_LEFT)
439
440        # arrange sizers
441        self.sizer_set_smearer.Add(sizer_smearer)
442        self.sizer_set_smearer.Add((10, 10))
443        self.sizer_set_smearer.Add(self.smear_description_none,
444                                   0, wx.CENTER, 10)
445        self.sizer_set_smearer.Add(self.smear_description_dqdata,
446                                   0, wx.CENTER, 10)
447        self.sizer_set_smearer.Add(self.smear_description_2d,
448                                   0, wx.CENTER, 10)
449        self.sizer_new_smear.Add(self.smear_description_type,
450                                 0, wx.CENTER, 10)
451        self.sizer_new_smear.Add(self.smear_description_accuracy_type,
452                                 0, wx.CENTER, 10)
453        self.sizer_new_smear.Add(self.smear_accuracy)
454        self.sizer_new_smear.Add(self.smear_description_smear_type,
455                                 0, wx.CENTER, 10)
456        self.sizer_new_smear.Add((15, -1))
457        self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10)
458        self.sizer_new_smear.Add(self.smear_description_pin_min,
459                                 0, wx.CENTER, 10)
460        self.sizer_new_smear.Add(self.smear_description_slit_height,
461                                 0, wx.CENTER, 10)
462
463        self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10)
464        self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10)
465        self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10)
466        self.sizer_new_smear.Add((20, -1))
467        self.sizer_new_smear.Add(self.smear_description_2d_y,
468                                 0, wx.CENTER, 10)
469        self.sizer_new_smear.Add(self.smear_description_pin_max,
470                                 0, wx.CENTER, 10)
471        self.sizer_new_smear.Add(self.smear_description_slit_width,
472                                 0, wx.CENTER, 10)
473
474        self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10)
475        self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10)
476        self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10)
477
478        self.sizer_set_smearer.Add(self.smear_message_new_s, 0, wx.CENTER, 10)
479        self.sizer_set_smearer.Add(self.smear_message_new_p, 0, wx.CENTER, 10)
480        self.sizer_set_smearer.Add((5, 2))
481        self.sizer_set_smearer.Add(self.sizer_new_smear, 0, wx.CENTER, 10)
482
483        # add all to chi2 sizer
484        sizer_smearer_box.Add(self.sizer_set_smearer)
485        sizer_chi2.Add(sizer_smearer_box)
486        sizer_chi2.Add((-1, 5))
487        sizer_chi2.Add(weighting_box)
488        sizer_chi2.Add((-1, 5))
489
490        # hide all smear messages and textctrl
491        self._hide_all_smear_info()
492
493        # get smear_selection
494        self.current_smearer = smear_selection(self.data, self.model)
495
496        # Show only the relevant smear messages, etc
497        if self.current_smearer is None:
498            if not is_2d_data:
499                self.smear_description_none.Show(True)
500                self.enable_smearer.Disable()
501            else:
502                self.smear_description_none.Show(True)
503                self.slit_smearer.Disable()
504            if self.data is None:
505                self.slit_smearer.Disable()
506                self.pinhole_smearer.Disable()
507                self.enable_smearer.Disable()
508        else:
509            self._show_smear_sizer()
510        boxsizer_range.Add(self.sizer_set_masking)
511        # 2D data? default
512        is_2d_data = False
513
514        # check if it is 2D data
515        if self.data.__class__.__name__ == "Data2D" or self.enable2D:
516            is_2d_data = True
517
518        self.sizer5.Clear(True)
519
520        self.qmin = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
521                                  style=wx.TE_PROCESS_ENTER,
522                                  set_focus_callback=self.qrang_set_focus,
523                                  text_enter_callback=self._onQrangeEnter,
524                                  name='qmin')
525        self.qmin.SetValue(str(self.qmin_x))
526        q_tip = "Click outside of the axes\n to remove the lines."
527        qmin_tip = "Minimun value of Q.\n"
528        qmin_tip += q_tip
529        self.qmin.SetToolTipString(qmin_tip)
530
531        self.qmax = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
532                                  style=wx.TE_PROCESS_ENTER,
533                                  set_focus_callback=self.qrang_set_focus,
534                                  text_enter_callback=self._onQrangeEnter,
535                                  name='qmax')
536        self.qmax.SetValue(str(self.qmax_x))
537        qmax_tip = "Maximum value of Q.\n"
538        qmax_tip += q_tip
539        self.qmax.SetToolTipString(qmax_tip)
540        self.qmin.Bind(wx.EVT_MOUSE_EVENTS, self.qrange_click)
541        self.qmax.Bind(wx.EVT_MOUSE_EVENTS, self.qrange_click)
542        self.qmin.Bind(wx.EVT_KEY_DOWN, self.on_key)
543        self.qmax.Bind(wx.EVT_KEY_DOWN, self.on_key)
544        self.qmin.Bind(wx.EVT_TEXT, self.on_qrange_text)
545        self.qmax.Bind(wx.EVT_TEXT, self.on_qrange_text)
546        wx_id = self._ids.next()
547        self.reset_qrange = wx.Button(self, wx_id, 'Reset')
548
549        self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked, id=wx_id)
550        self.reset_qrange.SetToolTipString("Reset Q range to the default")
551
552        sizer = wx.GridSizer(5, 5, 2, 6)
553
554        self.btEditMask = wx.Button(self, self._ids.next(), 'Editor')
555        self.btEditMask.Bind(wx.EVT_BUTTON, self._onMask,
556                             id=self.btEditMask.GetId())
557        self.btEditMask.SetToolTipString("Edit Mask.")
558        self.EditMask_title = wx.StaticText(self, wx.ID_ANY, ' Masking(2D)')
559
560        sizer.Add(wx.StaticText(self, wx.ID_ANY, '   Q range'))
561        sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Min[1/A]'))
562        sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Max[1/A]'))
563        sizer.Add(self.EditMask_title)
564        sizer.Add((-1, 5))
565
566        sizer.Add(self.reset_qrange)
567        sizer.Add(self.qmin)
568        sizer.Add(self.qmax)
569        sizer.Add(self.btEditMask)
570        sizer.Add((-1, 5))
571
572        sizer.AddMany(5*[(-1, 5)])
573
574        sizer.Add(box_description_1, 0, 0)
575        sizer.Add(box_description_2, 0, 0)
576        sizer.Add(self.points_sizer, 0, 0)
577        sizer.Add(self.draw_button, 0, 0)
578        sizer.Add((-1, 5))
579       
580        sizer.Add(self.tcChi, 0, 0)
581        sizer.Add(self.Npts_fit, 0, 0)
582        sizer.Add(self.Npts_total, 0, 0)
583        sizer.Add(self.btFit, 0, 0)
584        sizer.Add(self.btFitHelp, 0, 0)
585       
586        boxsizer_range.Add(sizer_chi2)
587        boxsizer_range.Add(sizer)
588        if is_2d_data:
589            self.btEditMask.Enable()
590            self.EditMask_title.Enable()
591        else:
592            self.btEditMask.Disable()
593            self.EditMask_title.Disable()
594        # save state
595        self.save_current_state()
596        self.sizer5.Add(boxsizer_range, 0, wx.EXPAND | wx.ALL, 10)
597        self.sizer5.Layout()
598
599    def _set_sizer_dispersion(self):
600        """
601        draw sizer with gaussian dispersity parameters
602        """
603        self.fittable_param = []
604        self.fixed_param = []
605        self.orientation_params_disp = []
606
607        self.sizer4_4.Clear(True)
608        if self.model is None:
609            # no model is selected
610            return
611        if not self.enable_disp.GetValue():
612            # the user didn't select dispersity display
613            return
614
615        self._reset_dispersity()
616
617        # fill a sizer with the combobox to select dispersion type
618        model_disp = wx.StaticText(self, wx.ID_ANY, 'Function')
619        CHECK_STATE = False
620
621        ix = 0
622        iy = 0
623        disp = wx.StaticText(self, wx.ID_ANY, ' ')
624        self.sizer4_4.Add(disp, (iy, ix), (1, 1),
625                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
626        ix += 1
627        values = wx.StaticText(self, wx.ID_ANY, 'PD[ratio]')
628        polytext = "Polydispersity (= STD/mean); "
629        polytext += "the standard deviation over the mean value."
630        values.SetToolTipString(polytext)
631
632        self.sizer4_4.Add(values, (iy, ix), (1, 1),
633                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
634        ix += 2
635        if self.is_mac:
636            err_text = 'Error'
637        else:
638            err_text = ''
639        self.text_disp_1 = wx.StaticText(self, wx.ID_ANY, err_text)
640        self.sizer4_4.Add(self.text_disp_1, (iy, ix), (1, 1),
641                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
642
643        ix += 1
644        self.text_disp_min = wx.StaticText(self, wx.ID_ANY, 'Min')
645        self.sizer4_4.Add(self.text_disp_min, (iy, ix), (1, 1),
646                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
647
648        ix += 1
649        self.text_disp_max = wx.StaticText(self, wx.ID_ANY, 'Max')
650        self.sizer4_4.Add(self.text_disp_max, (iy, ix), (1, 1),
651                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
652
653        ix += 1
654        npts = wx.StaticText(self, wx.ID_ANY, 'Npts')
655        npts.SetToolTipString("Number of sampling points for the numerical\n\
656        integration over the distribution function.")
657        self.sizer4_4.Add(npts, (iy, ix), (1, 1),
658                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
659        ix += 1
660        nsigmas = wx.StaticText(self, wx.ID_ANY, 'Nsigs')
661        nsigmas.SetToolTipString("Number of sigmas between which the range\n\
662         of the distribution function will be used for weighting. \n\
663        The value '3' covers 99.5% for Gaussian distribution \n\
664        function. Note: Not recommended to change this value.")
665        self.sizer4_4.Add(nsigmas, (iy, ix), (1, 1),
666                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
667        ix += 1
668        self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
669                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
670
671        self.text_disp_max.Show(True)
672        self.text_disp_min.Show(True)
673
674        for item in self.model.dispersion.keys():
675            if not self.magnetic_on:
676                if item in self.model.magnetic_params:
677                    continue
678            if item not in self.model.orientation_params:
679                if item not in self.disp_cb_dict:
680                    self.disp_cb_dict[item] = None
681                name0 = "Distribution of " + item
682                name1 = item + ".width"
683                name2 = item + ".npts"
684                name3 = item + ".nsigmas"
685                if name1 not in self.model.details:
686                    self.model.details[name1] = ["", None, None]
687
688                iy += 1
689                for p in self.model.dispersion[item].keys():
690
691                    if p == "width":
692                        ix = 0
693                        cb = wx.CheckBox(self, wx.ID_ANY, name0, (10, 10))
694                        cb.SetValue(CHECK_STATE)
695                        cb.SetToolTipString("Check mark to fit")
696                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
697                        self.sizer4_4.Add(cb, (iy, ix), (1, 1),
698                                wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
699                        ix = 1
700                        value = self.model.getParam(name1)
701                        ctl1 = ModelTextCtrl(self, wx.ID_ANY,
702                                             size=(_BOX_WIDTH / 1.3, 20),
703                                             style=wx.TE_PROCESS_ENTER)
704                        ctl1.SetLabel('PD[ratio]')
705                        poly_text = "Polydispersity (STD/mean) of %s\n" % item
706                        poly_text += "STD: the standard deviation"
707                        poly_text += " from the mean value."
708                        ctl1.SetToolTipString(poly_text)
709                        ctl1.SetValue(str(format_number(value, True)))
710                        self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
711                        # text to show error sign
712                        ix = 2
713                        text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
714                        self.sizer4_4.Add(text2, (iy, ix), (1, 1),
715                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
716                        if not self.is_mac:
717                            text2.Hide()
718
719                        ix = 3
720                        ctl2 = wx.TextCtrl(self, wx.ID_ANY,
721                                           size=(_BOX_WIDTH / 1.3, 20),
722                                           style=0)
723
724                        self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
725                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
726                        if not self.is_mac:
727                            ctl2.Hide()
728
729                        ix = 4
730                        ctl3 = ModelTextCtrl(self, wx.ID_ANY,
731                                             size=(_BOX_WIDTH / 2, 20),
732                                             style=wx.TE_PROCESS_ENTER,
733                            text_enter_callback=self._onparamRangeEnter)
734
735                        self.sizer4_4.Add(ctl3, (iy, ix), (1, 1),
736                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
737
738                        ix = 5
739                        ctl4 = ModelTextCtrl(self, wx.ID_ANY,
740                                             size=(_BOX_WIDTH / 2, 20),
741                                             style=wx.TE_PROCESS_ENTER,
742                            text_enter_callback=self._onparamRangeEnter)
743
744                        self.sizer4_4.Add(ctl4, (iy, ix), (1, 1),
745                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
746
747                        ctl3.Show(True)
748                        ctl4.Show(True)
749
750                    elif p == "npts":
751                        ix = 6
752                        value = self.model.getParam(name2)
753                        Tctl = ModelTextCtrl(self, wx.ID_ANY,
754                                             size=(_BOX_WIDTH / 2.2, 20),
755                                             style=wx.TE_PROCESS_ENTER)
756
757                        Tctl.SetValue(str(format_number(value)))
758                        self.sizer4_4.Add(Tctl, (iy, ix), (1, 1),
759                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
760                        self.fixed_param.append([None, name2, Tctl, None, None,
761                                                 None, None, None])
762                    elif p == "nsigmas":
763                        ix = 7
764                        value = self.model.getParam(name3)
765                        Tct2 = ModelTextCtrl(self, wx.ID_ANY,
766                                             size=(_BOX_WIDTH / 2.2, 20),
767                                             style=wx.TE_PROCESS_ENTER)
768
769                        Tct2.SetValue(str(format_number(value)))
770                        self.sizer4_4.Add(Tct2, (iy, ix), (1, 1),
771                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
772                        self.fixed_param.append([None, name3, Tct2,
773                                                 None, None, None,
774                                                 None, None])
775
776                ix = 8
777                disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1),
778                                       style=wx.CB_READONLY, name='%s' % name1)
779                for key, value in POLYDISPERSITY_MODELS.iteritems():
780                    name_disp = str(key)
781                    disp_box.Append(name_disp, value)
782                    disp_box.SetStringSelection("gaussian")
783                wx.EVT_COMBOBOX(disp_box, wx.ID_ANY, self._on_disp_func)
784                self.sizer4_4.Add(disp_box, (iy, ix), (1, 1), wx.EXPAND)
785                self.fittable_param.append([cb, name1, ctl1, text2,
786                                            ctl2, ctl3, ctl4, disp_box])
787
788        ix = 0
789        iy += 1
790        self.sizer4_4.Add((20, 20), (iy, ix), (1, 1),
791                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
792        first_orient = True
793        for item in self.model.dispersion.keys():
794            if not self.magnetic_on:
795                if item in self.model.magnetic_params:
796                    continue
797            if item in self.model.orientation_params:
798                if item not in self.disp_cb_dict:
799                    self.disp_cb_dict[item] = None
800                name0 = "Distribution of " + item
801                name1 = item + ".width"
802                name2 = item + ".npts"
803                name3 = item + ".nsigmas"
804
805                if name1 not in self.model.details:
806                    self.model.details[name1] = ["", None, None]
807
808                iy += 1
809                for p in self.model.dispersion[item].keys():
810
811                    if p == "width":
812                        ix = 0
813                        cb = wx.CheckBox(self, wx.ID_ANY, name0, (10, 10))
814                        cb.SetValue(CHECK_STATE)
815                        cb.SetToolTipString("Check mark to fit")
816                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
817                        self.sizer4_4.Add(cb, (iy, ix), (1, 1),
818                                wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
819                        if self.data.__class__.__name__ == "Data2D" or \
820                                    self.enable2D:
821                            cb.Show(True)
822                        elif cb.IsShown():
823                            cb.Hide()
824                        ix = 1
825                        value = self.model.getParam(name1)
826                        ctl1 = ModelTextCtrl(self, wx.ID_ANY,
827                                             size=(_BOX_WIDTH / 1.3, 20),
828                                             style=wx.TE_PROCESS_ENTER)
829                        poly_tip = "Absolute Sigma for %s." % item
830                        ctl1.SetToolTipString(poly_tip)
831                        ctl1.SetValue(str(format_number(value, True)))
832                        if self.data.__class__.__name__ == "Data2D" or \
833                                    self.enable2D:
834                            if first_orient:
835                                values.SetLabel('PD[ratio], Sig[deg]')
836                                poly_text = "PD(polydispersity for lengths):\n"
837                                poly_text += "It should be a value between"
838                                poly_text += "0 and 1\n"
839                                poly_text += "Sigma for angles: \n"
840                                poly_text += "It is the STD (ratio*mean)"
841                                poly_text += " of the distribution.\n "
842
843                                values.SetToolTipString(poly_text)
844                                first_orient = False
845                            ctl1.Show(True)
846                        elif ctl1.IsShown():
847                            ctl1.Hide()
848
849                        self.sizer4_4.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
850                        # text to show error sign
851                        ix = 2
852                        text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
853                        self.sizer4_4.Add(text2, (iy, ix), (1, 1),
854                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
855
856                        text2.Hide()
857
858                        ix = 3
859                        ctl2 = wx.TextCtrl(self, wx.ID_ANY,
860                                           size=(_BOX_WIDTH / 1.3, 20),
861                                           style=0)
862
863                        self.sizer4_4.Add(ctl2, (iy, ix), (1, 1),
864                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
865
866                        ctl2.Hide()
867                        if self.data.__class__.__name__ == "Data2D" or \
868                                self.enable2D:
869                            if self.is_mac:
870                                text2.Show(True)
871                                ctl2.Show(True)
872
873                        ix = 4
874                        ctl3 = ModelTextCtrl(self, wx.ID_ANY,
875                                             size=(_BOX_WIDTH / 2, 20),
876                                             style=wx.TE_PROCESS_ENTER,
877                                text_enter_callback=self._onparamRangeEnter)
878
879                        self.sizer4_4.Add(ctl3, (iy, ix), (1, 1),
880                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
881
882                        ctl3.Hide()
883
884                        ix = 5
885                        ctl4 = ModelTextCtrl(self, wx.ID_ANY,
886                                             size=(_BOX_WIDTH / 2, 20),
887                                             style=wx.TE_PROCESS_ENTER,
888                            text_enter_callback=self._onparamRangeEnter)
889                        self.sizer4_4.Add(ctl4, (iy, ix), (1, 1),
890                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
891                        ctl4.Hide()
892
893                        if self.data.__class__.__name__ == "Data2D" or \
894                                self.enable2D:
895                            ctl3.Show(True)
896                            ctl4.Show(True)
897
898                    elif p == "npts":
899                        ix = 6
900                        value = self.model.getParam(name2)
901                        Tctl = ModelTextCtrl(self, wx.ID_ANY,
902                                             size=(_BOX_WIDTH / 2.2, 20),
903                                             style=wx.TE_PROCESS_ENTER)
904
905                        Tctl.SetValue(str(format_number(value)))
906                        if self.data.__class__.__name__ == "Data2D" or \
907                                self.enable2D:
908                            Tctl.Show(True)
909                        else:
910                            Tctl.Hide()
911                        self.sizer4_4.Add(Tctl, (iy, ix), (1, 1),
912                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
913                        self.fixed_param.append([None, name2, Tctl, None, None,
914                                                 None, None, None])
915                        self.orientation_params_disp.append([None, name2,
916                                                             Tctl, None, None,
917                                                             None, None, None])
918                    elif p == "nsigmas":
919                        ix = 7
920                        value = self.model.getParam(name3)
921                        Tct2 = ModelTextCtrl(self, wx.ID_ANY,
922                                             size=(_BOX_WIDTH / 2.2, 20),
923                                             style=wx.TE_PROCESS_ENTER)
924
925                        Tct2.SetValue(str(format_number(value)))
926                        if self.data.__class__.__name__ == "Data2D" or \
927                                self.enable2D:
928                            Tct2.Show(True)
929                        else:
930                            Tct2.Hide()
931                        self.sizer4_4.Add(Tct2, (iy, ix), (1, 1),
932                                          wx.EXPAND | wx.ADJUST_MINSIZE, 0)
933
934                        self.fixed_param.append([None, name3, Tct2,
935                                                 None, None, None, None, None])
936
937                        self.orientation_params_disp.append([None, name3,
938                                        Tct2, None, None, None, None, None])
939
940                ix = 8
941                disp_box = wx.ComboBox(self, wx.ID_ANY, size=(65, -1),
942                                style=wx.CB_READONLY, name='%s' % name1)
943                for key, value in POLYDISPERSITY_MODELS.iteritems():
944                    name_disp = str(key)
945                    disp_box.Append(name_disp, value)
946                    disp_box.SetStringSelection("gaussian")
947                wx.EVT_COMBOBOX(disp_box, wx.ID_ANY, self._on_disp_func)
948                self.sizer4_4.Add(disp_box, (iy, ix), (1, 1), wx.EXPAND)
949                self.fittable_param.append([cb, name1, ctl1, text2,
950                                            ctl2, ctl3, ctl4, disp_box])
951                self.orientation_params_disp.append([cb, name1, ctl1,
952                                            text2, ctl2, ctl3, ctl4, disp_box])
953
954                if self.data.__class__.__name__ == "Data2D" or \
955                                self.enable2D:
956                    disp_box.Show(True)
957                else:
958                    disp_box.Hide()
959
960        self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict)
961
962        self.state.model = self.model.clone()
963        # save state into
964        self._copy_parameters_state(self.parameters, self.state.parameters)
965        self._copy_parameters_state(self.orientation_params_disp,
966                                     self.state.orientation_params_disp)
967        self._copy_parameters_state(self.fittable_param,
968                                    self.state.fittable_param)
969        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
970
971        wx.PostEvent(self.parent,
972                     StatusEvent(status=" Selected Distribution: Gaussian"))
973        # Fill the list of fittable parameters
974        self.get_all_checked_params()
975        self.Layout()
976
977    def _onDraw(self, event):
978        """
979        Update and Draw the model
980        """
981        if self.model is None:
982            msg = "Please select a Model first..."
983            wx.MessageBox(msg, 'Info')
984            return
985        """
986        if not self.data.is_data:
987            self.npts_x = self.Npts_total.GetValue()
988            self.Npts_fit.SetValue(self.npts_x)
989            self.create_default_data()
990        """
991        flag, is_modified = self._update_paramv_on_fit()
992
993        wx.CallAfter(self._onparamEnter_helper, is_modified)
994        if not flag:
995            msg = "The parameters are invalid"
996            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
997            return
998
999    def _onFit(self, event):
1000        """
1001        Allow to fit
1002        """
1003        if event is not None:
1004            event.Skip()
1005        if self.fit_started:
1006            self._StopFit()
1007            self.fit_started = False
1008            wx.CallAfter(self.set_fitbutton)
1009            return
1010
1011        if self.data is None:
1012            msg = "Please get Data first..."
1013            wx.MessageBox(msg, 'Info')
1014            wx.PostEvent(self._manager.parent,
1015                         StatusEvent(status="Fit: %s" % msg))
1016            return
1017        if self.model is None:
1018            msg = "Please select a Model first..."
1019            wx.MessageBox(msg, 'Info')
1020            wx.PostEvent(self._manager.parent,
1021                         StatusEvent(status="Fit: %s" % msg, type="stop"))
1022            return
1023
1024        if len(self.param_toFit) <= 0:
1025            msg = "Select at least one parameter to fit"
1026            wx.MessageBox(msg, 'Info')
1027            wx.PostEvent(self._manager.parent,
1028                         StatusEvent(status=msg, type="stop"))
1029            return
1030
1031        flag = self._update_paramv_on_fit()
1032
1033        if self.batch_on and not self._is_2D():
1034            if not self._validate_Npts_1D():
1035                return
1036
1037        if not flag:
1038            msg = "Fitting range or parameters are invalid"
1039            wx.PostEvent(self._manager.parent,
1040                         StatusEvent(status=msg, type="stop"))
1041            return
1042
1043        self.select_param()
1044
1045        # Remove or do not allow fitting on the Q=0 point, especially
1046        # when y(q=0)=None at x[0].
1047        self.qmin_x = float(self.qmin.GetValue())
1048        self.qmax_x = float(self.qmax.GetValue())
1049        self._manager._reset_schedule_problem(value=0, uid=self.uid)
1050        self._manager.schedule_for_fit(uid=self.uid, value=1)
1051        self._manager.set_fit_range(uid=self.uid, qmin=self.qmin_x,
1052                                    qmax=self.qmax_x)
1053
1054        # single fit
1055        # self._manager.onFit(uid=self.uid)
1056        self.fit_started = self._manager.onFit(uid=self.uid)
1057        wx.CallAfter(self.set_fitbutton)
1058
1059    def _onFitHelp(self, event):
1060        """
1061        Bring up the Full Fitting Documentation whenever the HELP button is
1062        clicked.
1063
1064        Calls DocumentationWindow with the path of the location within the
1065        documentation tree (after /doc/ ....".  Note that when using old
1066        versions of Wx (before 2.9) and thus not the release version of
1067        installers, the help comes up at the top level of the file as
1068        web browser does not pass anything past the # to the browser when it is
1069        running "file:///...."
1070
1071        :param evt: Triggers on clicking the help button
1072        """
1073
1074        _TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
1075        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
1076                                          "General Fitting Help")
1077
1078    def _onSmearHelp(self, event):
1079        """
1080        Bring up the instrumental resolution smearing Documentation whenever
1081        the ? button in the smearing box is clicked.
1082
1083        Calls DocumentationWindow with the path of the location within the
1084        documentation tree (after /doc/ ....".  Note that when using old
1085        versions of Wx (before 2.9) and thus not the release version of
1086        installers, the help comes up at the top level of the file as
1087        web browser does not pass anything past the # to the browser when it is
1088        running "file:///...."
1089
1090        :param evt: Triggers on clicking the help button
1091        """
1092
1093        _TreeLocation = "user/sasgui/perspectives/fitting/sm_help.html"
1094        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
1095                                          "Instrumental Resolution Smearing \
1096                                          Help")
1097
1098    def set_fitbutton(self):
1099        """
1100        Set fit button label depending on the fit_started[bool]
1101        """
1102        # Skip this feature if we are not on Windows
1103        # NOTE: the is_mac data member actually means "is no Windows".
1104        if self.is_mac:
1105            return
1106
1107        if self.fit_started:
1108            label = "Stop"
1109            color = "red"
1110        else:
1111            label = "Fit"
1112            color = "black"
1113        # self.btFit.Enable(False)
1114        self.btFit.SetLabel(label)
1115        self.btFit.SetForegroundColour(color)
1116        self.btFit.Enable(True)
1117
1118    def get_weight_flag(self):
1119        """
1120        Get flag corresponding to a given weighting dI data.
1121        """
1122        button_list = [self.dI_noweight,
1123                       self.dI_didata,
1124                       self.dI_sqrdata,
1125                       self.dI_idata]
1126        flag = 1
1127        for item in button_list:
1128            if item.GetValue():
1129                if button_list.index(item) == 0:
1130                    flag = 0  # dy = numpy.ones_like(dy_data)
1131                elif button_list.index(item) == 1:
1132                    flag = 1  # dy = dy_data
1133                elif button_list.index(item) == 2:
1134                    flag = 2  # dy = numpy.sqrt(numpy.abs(data))
1135                elif button_list.index(item) == 3:
1136                    flag = 3  # dy = numpy.abs(data)
1137                break
1138        return flag
1139
1140    def _StopFit(self, event=None):
1141        """
1142        Stop fit
1143        """
1144        if event is not None:
1145            event.Skip()
1146        self._manager.stop_fit(self.uid)
1147        self._manager._reset_schedule_problem(value=0)
1148        self._on_fit_complete()
1149
1150    def rename_model(self):
1151        """
1152        find a short name for model
1153        """
1154        if self.model is not None:
1155            self.model.name = "M" + str(self.index_model)
1156
1157    def _on_select_model(self, event=None):
1158        """
1159        call back for model selection
1160        """
1161        self.Show(False)
1162        copy_flag = False
1163        is_poly_enabled = None
1164        if event is not None:
1165            if (event.GetEventObject() == self.formfactorbox
1166                    and self.structurebox.GetLabel() != 'None')\
1167                    or event.GetEventObject() == self.structurebox\
1168                    or event.GetEventObject() == self.multifactorbox:
1169                copy_flag = self.get_copy_params()
1170                is_poly_enabled = self.enable_disp.GetValue()
1171
1172        self._on_select_model_helper()
1173        self.set_model_param_sizer(self.model)
1174        if self.model is None:
1175            self._set_bookmark_flag(False)
1176            self._keep.Enable(False)
1177            self._set_save_flag(False)
1178        self.enable_disp.SetValue(False)
1179        self.disable_disp.SetValue(True)
1180        # TODO: should not have an untrapped exception when displaying disperser
1181        # TODO: do we need to create the disperser panel on every model change?
1182        # Note: if we fix this, then remove ID_DISPERSER_HELP from basepage
1183        try:
1184            self.set_dispers_sizer()
1185        except:
1186            pass
1187        self.state.enable_disp = self.enable_disp.GetValue()
1188        self.state.disable_disp = self.disable_disp.GetValue()
1189        self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
1190        self.state.slit_smearer = self.slit_smearer.GetValue()
1191
1192        self.state.structurecombobox = self.structurebox.GetValue()
1193        self.state.formfactorcombobox = self.formfactorbox.GetValue()
1194        self.state.categorycombobox = self.categorybox.GetValue()
1195        self.enable_fit_button()
1196        if self.model is not None:
1197            self.m_name = self.model.name
1198            self.state.m_name = self.m_name
1199            self.rename_model()
1200            self._set_copy_flag(True)
1201            self._set_paste_flag(True)
1202            if self.data is not None:
1203                is_data = check_data_validity(self.data)
1204                if is_data:
1205                    self._set_bookmark_flag(not self.batch_on)
1206                    self._keep.Enable(not self.batch_on)
1207                    self._set_save_flag(True)
1208            #Setting smearing for cases with and without data.
1209            self._set_smear(self.data)
1210
1211            # more disables for 2D
1212            self._set_smear_buttons()
1213
1214            try:
1215                # update smearer sizer
1216                #This call for smearing set up caused double evaluation of
1217                #I(q) and double compilation as results
1218                #self.onSmear(None)
1219                temp_smear = None
1220                if not self.disable_smearer.GetValue():
1221                    # Set the smearer environments
1222                    temp_smear = self.current_smearer
1223            except:
1224                raise
1225                # error occured on chisqr computation
1226                # pass
1227            # event to post model to fit to fitting plugins
1228            (ModelEventbox, EVT_MODEL_BOX) = wx.lib.newevent.NewEvent()
1229
1230            # set smearing value whether or not data contain the smearing info
1231            evt = ModelEventbox(model=self.model,
1232                                smearer=temp_smear,
1233                                enable_smearer=not self.disable_smearer.GetValue(),
1234                                qmin=float(self.qmin_x),
1235                                uid=self.uid,
1236                                caption=self.window_caption,
1237                                qmax=float(self.qmax_x))
1238
1239            self._manager._on_model_panel(evt=evt)
1240            self.mbox_description.SetLabel("Model [ %s ]" %
1241                                           str(self.model.name))
1242            self.mbox_description.SetForegroundColour(wx.BLUE)
1243            self.state.model = self.model.clone()
1244            self.state.model.name = self.model.name
1245
1246        if event is not None:
1247            # post state to fit panel
1248            new_event = PageInfoEvent(page=self)
1249            wx.PostEvent(self.parent, new_event)
1250            # update list of plugins if new plugin is available
1251            custom_model = 'Customized Models'
1252            mod_cat = self.categorybox.GetStringSelection()
1253            if mod_cat == custom_model:
1254                temp = self.parent.update_model_list()
1255                if temp:
1256                    self.model_list_box = temp
1257                    current_val = self.formfactorbox.GetLabel()
1258                    pos = self.formfactorbox.GetSelection()
1259                    self._show_combox_helper()
1260                    self.formfactorbox.SetSelection(pos)
1261                    self.formfactorbox.SetValue(current_val)
1262            # when select a model only from guictr/button
1263            if is_poly_enabled is not None:
1264                self.enable_disp.SetValue(is_poly_enabled)
1265                self.disable_disp.SetValue(not is_poly_enabled)
1266                self._set_dipers_Param(event=None)
1267                self.state.enable_disp = self.enable_disp.GetValue()
1268                self.state.disable_disp = self.disable_disp.GetValue()
1269
1270            # Keep the previous param values
1271            if copy_flag:
1272                self.get_paste_params(copy_flag)
1273                wx.CallAfter(self._onDraw, None)
1274
1275        else:
1276            self._draw_model()
1277
1278        if self.batch_on:
1279            self.slit_smearer.Enable(False)
1280            self.pinhole_smearer.Enable(False)
1281            self.btEditMask.Disable()
1282            self.EditMask_title.Disable()
1283
1284        self.Show(True)
1285        self.SetupScrolling()
1286
1287    def _onparamEnter(self, event):
1288        """
1289        when enter value on panel redraw model according to changed
1290        """
1291        if self.model is None:
1292            msg = "Please select a Model first..."
1293            wx.MessageBox(msg, 'Info')
1294            return
1295
1296        # default flag
1297        flag = False
1298        self.fitrange = True
1299        # get event object
1300        tcrtl = event.GetEventObject()
1301        # Clear msg if previously shown.
1302        msg = ""
1303        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1304
1305        if check_float(tcrtl):
1306            flag = self._onparamEnter_helper()
1307            self.show_npts2fit()
1308            if self.fitrange:
1309                temp_smearer = None
1310                if not self.disable_smearer.GetValue():
1311                    temp_smearer = self.current_smearer
1312                    # set smearing value whether or not data contain the
1313                    # smearing info
1314                    if self.slit_smearer.GetValue():
1315                        flag1 = self.update_slit_smear()
1316                        flag = flag or flag1
1317                    elif self.pinhole_smearer.GetValue():
1318                        flag1 = self.update_pinhole_smear()
1319                        flag = flag or flag1
1320                elif self.data.__class__.__name__ != "Data2D" and \
1321                        not self.enable2D:
1322                    enable_smearer = not self.disable_smearer.GetValue()
1323                    self._manager.set_smearer(smearer=temp_smearer,
1324                                              fid=self.data.id,
1325                                              uid=self.uid,
1326                                              qmin=float(self.qmin_x),
1327                                              qmax=float(self.qmax_x),
1328                                              enable_smearer=enable_smearer)
1329                if flag:
1330                    # self.compute_chisqr(smearer= temp_smearer)
1331
1332                    # new state posted
1333                    if self.state_change:
1334                        # self._undo.Enable(True)
1335                        event = PageInfoEvent(page=self)
1336                        wx.PostEvent(self.parent, event)
1337                    self.state_change = False
1338            else:
1339                # invalid fit range: do nothing here:
1340                # msg already displayed in validate
1341                return
1342        else:
1343            self.save_current_state()
1344            msg = "Cannot Plot: Must enter a number!!!  "
1345            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1346
1347        self.save_current_state()
1348        return
1349
1350    def _onparamRangeEnter(self, event):
1351        """
1352        Check validity of value enter in the parameters range field
1353        """
1354        tcrtl = event.GetEventObject()
1355        # Clear msg if previously shown.
1356        msg = ""
1357        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1358        # Flag to register when a parameter has changed.
1359        is_modified = False
1360        if tcrtl.GetValue().lstrip().rstrip() != "":
1361            try:
1362                tcrtl.SetBackgroundColour(wx.WHITE)
1363                self._check_value_enter(self.fittable_param)
1364                self._check_value_enter(self.parameters)
1365            except:
1366                tcrtl.SetBackgroundColour("pink")
1367                msg = "Model Error:wrong value entered : %s" % sys.exc_value
1368                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1369                return
1370        else:
1371            tcrtl.SetBackgroundColour(wx.WHITE)
1372
1373        # self._undo.Enable(True)
1374        self.save_current_state()
1375        event = PageInfoEvent(page=self)
1376        wx.PostEvent(self.parent, event)
1377        self.state_change = False
1378
1379    def qrang_set_focus(self, event=None):
1380        """
1381        ON Qrange focus
1382        """
1383        if event is not None:
1384            event.Skip()
1385        # tcrtl = event.GetEventObject()
1386        self._validate_qrange(self.qmin, self.qmax)
1387
1388    def qrange_click(self, event):
1389        """
1390        On Qrange textctrl click, make the qrange lines in the plot
1391        """
1392        if event is not None:
1393            event.Skip()
1394        if self.data.__class__.__name__ == "Data2D":
1395            return
1396        is_click = event.LeftDown()
1397        if is_click:
1398            d_id = self.data.id
1399            d_group_id = self.data.group_id
1400            act_ctrl = event.GetEventObject()
1401            wx.PostEvent(self._manager.parent,
1402                         PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
1403                                     group_id=d_group_id, leftdown=is_click,
1404                                     active=act_ctrl))
1405
1406    def on_qrange_text(self, event):
1407        """
1408        #On q range value updated. DO not combine with qrange_click().
1409        """
1410        if event is not None:
1411            event.Skip()
1412        if self.data.__class__.__name__ == "Data2D":
1413            return
1414        act_ctrl = event.GetEventObject()
1415        d_id = self.data.id
1416        d_group_id = self.data.group_id
1417        wx.PostEvent(self._manager.parent,
1418                     PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,
1419                                     group_id=d_group_id, leftdown=False,
1420                                     active=act_ctrl))
1421        self._validate_qrange(self.qmin, self.qmax)
1422
1423    def on_key(self, event):
1424        """
1425        On Key down
1426        """
1427        event.Skip()
1428        if self.data.__class__.__name__ == "Data2D":
1429            return
1430        ctrl = event.GetEventObject()
1431        try:
1432            x_data = float(ctrl.GetValue())
1433        except:
1434            return
1435        key = event.GetKeyCode()
1436        length = len(self.data.x)
1437        indx = (numpy.abs(self.data.x - x_data)).argmin()
1438        # return array.flat[idx]
1439        if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP:
1440            indx += 1
1441            if indx >= length:
1442                indx = length - 1
1443        elif key == wx.WXK_PAGEDOWN or key == wx.WXK_NUMPAD_PAGEDOWN:
1444            indx -= 1
1445            if indx < 0:
1446                indx = 0
1447        else:
1448            return
1449        ctrl.SetValue(str(self.data.x[indx]))
1450        self._validate_qrange(self.qmin, self.qmax)
1451
1452    def _onQrangeEnter(self, event):
1453        """
1454        Check validity of value enter in the Q range field
1455        """
1456        tcrtl = event.GetEventObject()
1457        # Clear msg if previously shown.
1458        msg = ""
1459        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1460        # For theory mode
1461        if not self.data.is_data:
1462            self.npts_x = self.Npts_total.GetValue()
1463            self.Npts_fit.SetValue(self.npts_x)
1464            self.create_default_data()
1465        # Flag to register when a parameter has changed.
1466        if tcrtl.GetValue().lstrip().rstrip() != "":
1467            try:
1468                tcrtl.SetBackgroundColour(wx.WHITE)
1469                # If qmin and qmax have been modified, update qmin and qmax
1470                if self._validate_qrange(self.qmin, self.qmax):
1471                    tempmin = float(self.qmin.GetValue())
1472                    if tempmin != self.qmin_x:
1473                        self.qmin_x = tempmin
1474                    tempmax = float(self.qmax.GetValue())
1475                    if tempmax != self.qmax_x:
1476                        self.qmax_x = tempmax
1477                else:
1478                    tcrtl.SetBackgroundColour("pink")
1479                    msg = "Model Error:wrong value entered : %s" % sys.exc_value
1480                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1481                    return
1482            except:
1483                tcrtl.SetBackgroundColour("pink")
1484                msg = "Model Error:wrong value entered : %s" % sys.exc_value
1485                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1486                return
1487            # Check if # of points for theory model are valid(>0).
1488            # check for 2d
1489            if self.data.__class__.__name__ == "Data2D" or \
1490                    self.enable2D:
1491                # set mask
1492                radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
1493                                    self.data.qy_data * self.data.qy_data)
1494                index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x))
1495                index_data = (index_data) & (self.data.mask)
1496                index_data = (index_data) & (numpy.isfinite(self.data.data))
1497                if len(index_data[index_data]) < 10:
1498                    msg = "Cannot Plot :No or too little npts in"
1499                    msg += " that data range!!!  "
1500                    wx.PostEvent(self._manager.parent,
1501                                 StatusEvent(status=msg))
1502                    return
1503                else:
1504                    # self.data.mask = index_data
1505                    # self.Npts_fit.SetValue(str(len(self.data.mask)))
1506                    self.show_npts2fit()
1507            else:
1508                index_data = ((self.qmin_x <= self.data.x) &
1509                              (self.data.x <= self.qmax_x))
1510                self.Npts_fit.SetValue(str(len(self.data.x[index_data])))
1511
1512            self.npts_x = self.Npts_total.GetValue()
1513            self.create_default_data()
1514            self._save_plotting_range()
1515        else:
1516            tcrtl.SetBackgroundColour("pink")
1517            msg = "Model Error:wrong value entered!!!"
1518            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1519
1520        self._draw_model()
1521        self.save_current_state()
1522        event = PageInfoEvent(page=self)
1523        wx.PostEvent(self.parent, event)
1524        self.state_change = False
1525        return
1526
1527    def _clear_Err_on_Fit(self):
1528        """
1529        hide the error text control shown
1530        after fitting
1531        """
1532
1533        if self.is_mac:
1534            return
1535        if hasattr(self, "text2_3"):
1536            self.text2_3.Hide()
1537
1538        if len(self.parameters) > 0:
1539            for item in self.parameters:
1540                if item[0].IsShown():
1541                    # Skip the angle parameters if 1D data
1542                    if self.data.__class__.__name__ != "Data2D" and \
1543                            not self.enable2D:
1544                        if item in self.orientation_params:
1545                            continue
1546                    if item in self.param_toFit:
1547                        continue
1548                    # hide statictext +/-
1549                    if len(item) < 4:
1550                        continue
1551                    if item[3] is not None and item[3].IsShown():
1552                        item[3].Hide()
1553                    # hide textcrtl  for error after fit
1554                    if item[4] is not None and item[4].IsShown():
1555                        item[4].Hide()
1556
1557        if len(self.fittable_param) > 0:
1558            for item in self.fittable_param:
1559                if item[0].IsShown():
1560                    # Skip the angle parameters if 1D data
1561                    if self.data.__class__.__name__ != "Data2D" and \
1562                            not self.enable2D:
1563                        if item in self.orientation_params:
1564                            continue
1565                    if item in self.param_toFit:
1566                        continue
1567                    if len(item) < 4:
1568                        continue
1569                    # hide statictext +/-
1570                    if item[3] is not None and item[3].IsShown():
1571                        item[3].Hide()
1572                    # hide textcrtl  for error after fit
1573                    if item[4] is not None and item[4].IsShown():
1574                        item[4].Hide()
1575        return
1576
1577    def _get_defult_custom_smear(self):
1578        """
1579        Get the defult values for custum smearing.
1580        """
1581        # get the default values
1582        if self.dxl is None:
1583            self.dxl = 0.0
1584        if self.dxw is None:
1585            self.dxw = ""
1586        if self.dx_min is None:
1587            self.dx_min = SMEAR_SIZE_L
1588        if self.dx_max is None:
1589            self.dx_max = SMEAR_SIZE_H
1590
1591    def _get_smear_info(self):
1592        """
1593        Get the smear info from data.
1594
1595        :return: self.smear_type, self.dq_l and self.dq_r,
1596            respectively the type of the smear, dq_min and
1597            dq_max for pinhole smear data
1598            while dxl and dxw for slit smear
1599        """
1600        # default
1601        self.smear_type = None
1602        self.dq_l = None
1603        self.dq_r = None
1604        data = self.data
1605        if self.data is None:
1606            return
1607        elif self.data.__class__.__name__ == "Data2D" or \
1608            self.enable2D:
1609            if data.dqx_data is None or data.dqy_data is None:
1610                return
1611            elif self.current_smearer is not None \
1612                and data.dqx_data.any() != 0 \
1613                and data.dqx_data.any() != 0:
1614                self.smear_type = "Pinhole2d"
1615                self.dq_l = format_number(numpy.average(data.dqx_data))
1616                self.dq_r = format_number(numpy.average(data.dqy_data))
1617                return
1618            else:
1619                return
1620        # check if it is pinhole smear and get min max if it is.
1621        if data.dx is not None and numpy.any(data.dx):
1622            self.smear_type = "Pinhole"
1623            self.dq_l = data.dx[0]
1624            self.dq_r = data.dx[-1]
1625
1626        # check if it is slit smear and get min max if it is.
1627        elif data.dxl is not None or data.dxw is not None:
1628            self.smear_type = "Slit"
1629            if data.dxl is not None and not numpy.all(data.dxl, 0):
1630                self.dq_l = data.dxl[0]
1631            if data.dxw is not None and not numpy.all(data.dxw, 0):
1632                self.dq_r = data.dxw[0]
1633        # return self.smear_type,self.dq_l,self.dq_r
1634
1635    def _show_smear_sizer(self):
1636        """
1637        Show only the sizers depending on smear selection
1638        """
1639        # smear disabled
1640        if self.disable_smearer.GetValue():
1641            self.smear_description_none.Show(True)
1642        # 2Dsmear
1643        elif self._is_2D():
1644            self.smear_description_accuracy_type.Show(True)
1645            self.smear_accuracy.Show(True)
1646            self.smear_description_accuracy_type.Show(True)
1647            self.smear_description_2d.Show(True)
1648            self.smear_description_2d_x.Show(True)
1649            self.smear_description_2d_y.Show(True)
1650            if self.pinhole_smearer.GetValue():
1651                self.smear_pinhole_min.Show(True)
1652                self.smear_pinhole_max.Show(True)
1653        # smear from data
1654        elif self.enable_smearer.GetValue():
1655
1656            self.smear_description_dqdata.Show(True)
1657            if self.smear_type is not None:
1658                self.smear_description_smear_type.Show(True)
1659                if self.smear_type == 'Slit':
1660                    self.smear_description_slit_height.Show(True)
1661                    self.smear_description_slit_width.Show(True)
1662                elif self.smear_type == 'Pinhole':
1663                    self.smear_description_pin_min.Show(True)
1664                    self.smear_description_pin_max.Show(True)
1665                self.smear_description_smear_type.Show(True)
1666                self.smear_description_type.Show(True)
1667                self.smear_data_left.Show(True)
1668                self.smear_data_right.Show(True)
1669        # custom pinhole smear
1670        elif self.pinhole_smearer.GetValue():
1671            if self.smear_type == 'Pinhole':
1672                self.smear_message_new_p.Show(True)
1673                self.smear_description_pin_min.Show(True)
1674                self.smear_description_pin_max.Show(True)
1675
1676            self.smear_pinhole_min.Show(True)
1677            self.smear_pinhole_max.Show(True)
1678        # custom slit smear
1679        elif self.slit_smearer.GetValue():
1680            self.smear_message_new_s.Show(True)
1681            self.smear_description_slit_height.Show(True)
1682            self.smear_slit_height.Show(True)
1683            self.smear_description_slit_width.Show(True)
1684            self.smear_slit_width.Show(True)
1685
1686    def _hide_all_smear_info(self):
1687        """
1688        Hide all smearing messages in the set_smearer sizer
1689        """
1690        self.smear_description_none.Hide()
1691        self.smear_description_dqdata.Hide()
1692        self.smear_description_type.Hide()
1693        self.smear_description_smear_type.Hide()
1694        self.smear_description_accuracy_type.Hide()
1695        self.smear_description_2d_x.Hide()
1696        self.smear_description_2d_y.Hide()
1697        self.smear_description_2d.Hide()
1698
1699        self.smear_accuracy.Hide()
1700        self.smear_data_left.Hide()
1701        self.smear_data_right.Hide()
1702        self.smear_description_pin_min.Hide()
1703        self.smear_pinhole_min.Hide()
1704        self.smear_description_pin_max.Hide()
1705        self.smear_pinhole_max.Hide()
1706        self.smear_description_slit_height.Hide()
1707        self.smear_slit_height.Hide()
1708        self.smear_description_slit_width.Hide()
1709        self.smear_slit_width.Hide()
1710        self.smear_message_new_p.Hide()
1711        self.smear_message_new_s.Hide()
1712
1713    def _set_accuracy_list(self):
1714        """
1715        Set the list of an accuracy in 2D custum smear:
1716                Xhigh, High, Med, or Low
1717        """
1718        # list of accuracy choices
1719        list = ['Low', 'Med', 'High', 'Xhigh']
1720        for idx in range(len(list)):
1721            self.smear_accuracy.Append(list[idx], idx)
1722
1723    def _set_fun_box_list(self, fun_box):
1724        """
1725        Set the list of func for multifunctional models
1726        """
1727        # Check if it is multi_functional model
1728        if self.model.__class__ not in self.model_list_box["Multi-Functions"] \
1729                and not self.temp_multi_functional:
1730            return None
1731        # Get the func name list
1732        list = self.model.fun_list
1733        if len(list) == 0:
1734            return None
1735        # build function (combo)box
1736        ind = 0
1737        while(ind < len(list)):
1738            for key, val in list.iteritems():
1739                if (val == ind):
1740                    fun_box.Append(key, val)
1741                    break
1742            ind += 1
1743
1744    def _on_select_accuracy(self, event):
1745        """
1746        Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low
1747        """
1748        # event.Skip()
1749        # Check if the accuracy is same as before
1750        # self.smear2d_accuracy = event.GetEventObject().GetValue()
1751        self.smear2d_accuracy = self.smear_accuracy.GetValue()
1752        if self.pinhole_smearer.GetValue():
1753            self.onPinholeSmear(event=None)
1754        else:
1755            self.onSmear(event=None)
1756            if self.current_smearer is not None:
1757                self.current_smearer.set_accuracy(accuracy=\
1758                                                  self.smear2d_accuracy)
1759        event.Skip()
1760
1761    def _on_fun_box(self, event):
1762        """
1763        Select an func: Erf,Rparabola,LParabola
1764        """
1765        fun_val = None
1766        fun_box = event.GetEventObject()
1767        name = fun_box.Name
1768        value = fun_box.GetValue()
1769        if value in self.model.fun_list:
1770            fun_val = self.model.fun_list[value]
1771
1772        self.model.setParam(name, fun_val)
1773        # save state
1774        self._copy_parameters_state(self.str_parameters,
1775                                    self.state.str_parameters)
1776        # update params
1777        self._update_paramv_on_fit()
1778        # draw
1779        self._draw_model()
1780        self.Refresh()
1781        # get ready for new event
1782        event.Skip()
1783
1784    def _onMask(self, event):
1785        """
1786        Build a panel to allow to edit Mask
1787        """
1788        from sas.sasgui.guiframe.local_perspectives.plotting.masking import \
1789            MaskPanel as MaskDialog
1790
1791        self.panel = MaskDialog(base=self, data=self.data, id=wx.NewId())
1792        self.panel.ShowModal()
1793
1794    def _draw_masked_model(self, event):
1795        """
1796        Draw model image w/mask
1797        """
1798        is_valid_qrange = self._update_paramv_on_fit()
1799
1800        if is_valid_qrange and self.model is not None:
1801            self.panel.MakeModal(False)
1802            event.Skip()
1803            # try re draw the model plot if it exists
1804            self._draw_model()
1805            self.show_npts2fit()
1806        elif self.model is None:
1807            self.panel.MakeModal(False)
1808            event.Skip()
1809            self.show_npts2fit()
1810            msg = "No model is found on updating MASK in the model plot... "
1811            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1812        else:
1813            event.Skip()
1814            msg = ' Please consider your Q range, too.'
1815            self.panel.ShowMessage(msg)
1816
1817    def _set_smear(self, data):
1818        """
1819        Set_smear
1820        """
1821        if data is None:
1822            return
1823        self.current_smearer = smear_selection(data, self.model)
1824        flag = self.disable_smearer.GetValue()
1825        if self.current_smearer is None:
1826            self.enable_smearer.Disable()
1827        else:
1828            self.enable_smearer.Enable()
1829        if not flag:
1830            self.onSmear(None)
1831
1832    def get_view_mode(self):
1833        """
1834        return True if the panel allow 2D or False if 1D
1835        """
1836        return self.enable2D
1837
1838    def compute_data_set_range(self, data_list):
1839        """
1840        find the range that include all data  in the set
1841        return the minimum and the maximum values
1842        """
1843        if data_list is not None and data_list != []:
1844            for data in data_list:
1845                qmin, qmax, npts = self.compute_data_range(data)
1846                self.qmin_data_set = min(self.qmin_data_set, qmin)
1847                self.qmax_data_set = max(self.qmax_data_set, qmax)
1848                self.npts_data_set += npts
1849        return self.qmin_data_set, self.qmax_data_set, self.npts_data_set
1850
1851    def compute_data_range(self, data):
1852        """
1853        compute the minimum and the maximum range of the data
1854        return the npts contains in data
1855        :param data:
1856        """
1857        qmin, qmax, npts = None, None, None
1858        if data is not None:
1859            if not hasattr(data, "data"):
1860                try:
1861                    qmin = min(data.x)
1862                    # Maximum value of data
1863                    qmax = max(data.x)
1864                    npts = len(data.x)
1865                except:
1866                    msg = "Unable to find min/max/length of \n data named %s" %\
1867                                data.filename
1868                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
1869                                               info="error"))
1870                    raise ValueError, msg
1871
1872            else:
1873                qmin = 0
1874                try:
1875                    x = max(math.fabs(data.xmin), math.fabs(data.xmax))
1876                    y = max(math.fabs(data.ymin), math.fabs(data.ymax))
1877                except:
1878                    msg = "Unable to find min/max of \n data named %s" % \
1879                                data.filename
1880                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg,
1881                                               info="error"))
1882                    raise ValueError, msg
1883                # Maximum value of data
1884                qmax = math.sqrt(x * x + y * y)
1885                npts = len(data.data)
1886        return qmin, qmax, npts
1887
1888    def set_data(self, data):
1889        """
1890        reset the current data
1891        """
1892        id = None
1893        flag = False
1894        is_data = False
1895        npts = 0
1896        try:
1897            old_id = self.data.id
1898            old_group_id = self.data.group_id
1899        except:
1900            old_id = id
1901            old_group_id = id
1902        if self.data is not None:
1903            is_data = check_data_validity(self.data)
1904        if not is_data and data is not None:
1905                flag = True
1906        if data is not None:
1907            if is_data:
1908                self.graph_id = self.data.group_id
1909                flag = (data.id != self.data.id)
1910        self.data = data
1911        if check_data_validity(data):
1912            self.graph_id = data.group_id
1913        self.data.group_id = self.graph_id
1914
1915        if self.data is None:
1916            data_name = ""
1917            self._set_bookmark_flag(False)
1918            self._keep.Enable(False)
1919            self._set_save_flag(False)
1920        else:
1921            if self.model is not None:
1922                self._set_bookmark_flag(not self.batch_on)
1923                self._keep.Enable(not self.batch_on)
1924            if self.data.is_data:
1925                self._set_save_flag(True)
1926                self._set_preview_flag(True)
1927
1928            # more disables for 2D
1929            if self.data.__class__.__name__ == "Data2D" or \
1930                        self.enable2D:
1931                self.slit_smearer.Disable()
1932                self.pinhole_smearer.Enable(True)
1933                self.default_mask = copy.deepcopy(self.data.mask)
1934                if self.data.err_data is None or\
1935                        numpy.all(err == 1 for err in self.data.err_data) or \
1936                        not numpy.any(self.data.err_data):
1937                    self.dI_didata.Enable(False)
1938                    self.dI_noweight.SetValue(True)
1939                    self.weightbt_string = self.dI_noweight.GetLabelText()
1940                else:
1941                    self.dI_didata.Enable(True)
1942                    self.dI_didata.SetValue(True)
1943                    self.weightbt_string = self.dI_didata.GetLabelText()
1944            else:
1945                self.slit_smearer.Enable(True)
1946                self.pinhole_smearer.Enable(True)
1947
1948                if self.data.dy is None or\
1949                     numpy.all(self.data.dy == 1) or\
1950                     not numpy.any(self.data.dy):
1951                    self.dI_didata.Enable(False)
1952                    self.dI_noweight.SetValue(True)
1953                    self.weightbt_string = self.dI_noweight.GetLabelText()
1954                else:
1955                    self.dI_didata.Enable(True)
1956                    self.dI_didata.SetValue(True)
1957                    self.weightbt_string = self.dI_didata.GetLabelText()
1958            # Enable weighting radio buttons
1959            self.dI_noweight.Enable(True)
1960            self.dI_sqrdata.Enable(True)
1961            self.dI_idata.Enable(True)
1962
1963            self.formfactorbox.Enable()
1964            self.structurebox.Enable()
1965            data_name = self.data.name
1966            _, _, npts = self.compute_data_range(self.data)
1967            # set maximum range for x in linear scale
1968            if not hasattr(self.data, "data"):  # Display only for 1D data fit
1969                self.btEditMask.Disable()
1970                self.EditMask_title.Disable()
1971            else:
1972                self.btEditMask.Enable()
1973                self.EditMask_title.Enable()
1974
1975        self.Npts_total.SetValue(str(npts))
1976        # default:number of data points selected to fit
1977        self.Npts_fit.SetValue(str(npts))
1978        self.Npts_total.SetEditable(False)
1979        self.Npts_total.SetBackgroundColour(
1980                                    self.GetParent().GetBackgroundColour())
1981
1982        self.Npts_total.Bind(wx.EVT_MOUSE_EVENTS, self._npts_click)
1983        self.pointsbox.Disable()
1984        self.dataSource.SetValue(data_name)
1985        self.state.data = data
1986        self.enable_fit_button()
1987        # send graph_id to page_finder
1988        self._manager.set_graph_id(uid=self.uid, graph_id=self.graph_id)
1989        # focus the page
1990        if check_data_validity(data):
1991            self.data_box_description.SetForegroundColour(wx.BLUE)
1992
1993        if self.batch_on:
1994            self.slit_smearer.Enable(False)
1995            self.pinhole_smearer.Enable(False)
1996            self.btEditMask.Disable()
1997            self.EditMask_title.Disable()
1998
1999        self.on_set_focus(None)
2000        self.Refresh()
2001        # update model plot with new data information
2002        if flag:
2003            if self.data.__class__.__name__ == "Data2D":
2004                self.enable2D = True
2005                self.model_view.SetLabel("2D Mode")
2006            else:
2007                self.enable2D = False
2008                self.model_view.SetLabel("1D Mode")
2009            self.model_view.Disable()
2010            #  replace data plot on combo box selection
2011            # by removing the previous selected data
2012            try:
2013                wx.PostEvent(self._manager.parent,
2014                             NewPlotEvent(action="delete",
2015                                          group_id=old_group_id, id=old_id))
2016            except:
2017                pass
2018            # plot the current selected data
2019            wx.PostEvent(self._manager.parent,
2020                         NewPlotEvent(action="check", plot=self.data,
2021                                      title=str(self.data.title)))
2022            self._draw_model()
2023
2024    def _npts_click(self, event):
2025        """
2026        Prevent further handling of the mouse event on Npts_total
2027        by not calling Skip().
2028        """
2029        pass
2030
2031    def reset_page(self, state, first=False):
2032        """
2033        reset the state
2034        """
2035        try:
2036            self.reset_page_helper(state)
2037
2038            self.select_param()
2039            # Save state_fit
2040            self.save_current_state_fit()
2041        except:
2042            self._show_combox_helper()
2043            msg = "Error: This model state has missing or outdated "
2044            msg += "information.\n"
2045            msg += traceback.format_exc()
2046            wx.PostEvent(self._manager.parent,
2047                         StatusEvent(status=msg, info="error"))
2048        self._lay_out()
2049        self.Refresh()
2050
2051    def get_range(self):
2052        """
2053        return the fitting range
2054        """
2055        return float(self.qmin_x), float(self.qmax_x)
2056
2057    def get_npts2fit(self):
2058        """
2059        return numbers of data points within qrange
2060
2061        :Note: This is to normalize chisq by Npts of fit
2062
2063        """
2064        if self.data is None:
2065            return
2066        npts2fit = 0
2067        qmin, qmax = self.get_range()
2068        if self.data.__class__.__name__ == "Data2D" or \
2069                        self.enable2D:
2070            radius = numpy.sqrt(self.data.qx_data * self.data.qx_data +
2071                                self.data.qy_data * self.data.qy_data)
2072            index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x)
2073            index_data = (index_data) & (self.data.mask)
2074            index_data = (index_data) & (numpy.isfinite(self.data.data))
2075            npts2fit = len(self.data.data[index_data])
2076        else:
2077            for qx in self.data.x:
2078                if qmax >= qx >= qmin:
2079                    npts2fit += 1
2080        return npts2fit
2081
2082    def show_npts2fit(self):
2083        """
2084        setValue Npts for fitting
2085        """
2086        self.Npts_fit.SetValue(str(self.get_npts2fit()))
2087
2088    def get_chi2(self):
2089        """
2090        return the current chi2
2091        """
2092        return self.tcChi.GetValue()
2093
2094    def onsetValues(self, chisqr, p_name, out, cov):
2095        """
2096        Build the panel from the fit result
2097
2098        :param chisqr: Value of the goodness of fit metric
2099        :param p_name: the name of parameters
2100        :param out: list of parameter with the best value found during fitting
2101        :param cov: Covariance matrix
2102
2103        """
2104
2105        # make sure stop button to fit button all the time
2106        self._on_fit_complete()
2107        if out is None or not numpy.isfinite(chisqr):
2108            raise ValueError, "Fit error occured..."
2109
2110        is_modified = False
2111        has_error = False
2112        dispersity = ''
2113
2114        # Hide textctrl boxes of errors.
2115        self._clear_Err_on_Fit()
2116
2117        # Check if chi2 is finite
2118        if chisqr is not None and numpy.isfinite(chisqr):
2119            # format chi2
2120            chi2 = format_number(chisqr, True)
2121            self.tcChi.SetValue(chi2)
2122            self.tcChi.Refresh()
2123        else:
2124            self.tcChi.SetValue("-")
2125
2126        # Hide error title
2127        if self.text2_3.IsShown() and not self.is_mac:
2128            self.text2_3.Hide()
2129
2130        try:
2131            if self.enable_disp.GetValue():
2132                if hasattr(self, "text_disp_1"):
2133                    if self.text_disp_1 is not None and not self.is_mac:
2134                        self.text_disp_1.Hide()
2135        except:
2136            dispersity = None
2137            pass
2138
2139        i = 0
2140        # Set the panel when fit result are list
2141
2142        for item in self.param_toFit:
2143            if len(item) > 5 and item is not None:
2144
2145                if item[0].IsShown():
2146                    # reset error value to initial state
2147                    if not self.is_mac:
2148                        item[3].Hide()
2149                        item[4].Hide()
2150                    for ind in range(len(out)):
2151                        if item[1] == p_name[ind]:
2152                            break
2153                    if len(out) > 0 and out[ind] is not None:
2154                        val_out = format_number(out[ind], True)
2155                        item[2].SetValue(val_out)
2156
2157                    if(cov is not None and len(cov) == len(out)):
2158                        try:
2159                            if dispersity is not None:
2160                                if self.enable_disp.GetValue():
2161                                    if hasattr(self, "text_disp_1"):
2162                                        if self.text_disp_1 is not None:
2163                                            if not self.text_disp_1.IsShown()\
2164                                                  and not self.is_mac:
2165                                                self.text_disp_1.Show(True)
2166                        except:
2167                            pass
2168
2169                        if cov[ind] is not None:
2170                            if numpy.isfinite(float(cov[ind])):
2171                                val_err = format_number(cov[ind], True)
2172                                item[4].SetForegroundColour(wx.BLACK)
2173                            else:
2174                                val_err = 'NaN'
2175                                item[4].SetForegroundColour(wx.RED)
2176                            if not self.is_mac:
2177                                item[3].Show(True)
2178                                item[4].Show(True)
2179                            item[4].SetValue(val_err)
2180                            has_error = True
2181                i += 1
2182            else:
2183                raise ValueError, "onsetValues: Invalid parameters..."
2184        # Show error title when any errors displayed
2185        if has_error:
2186            if not self.text2_3.IsShown():
2187                self.text2_3.Show(True)
2188        # save current state
2189        self.save_current_state()
2190
2191        # plot model ( when drawing, do not update chisqr value again)
2192        self._draw_model(update_chisqr=False, source='fit')
2193
2194    def onWeighting(self, event):
2195        """
2196        On Weighting radio button event, sets the weightbt_string
2197        """
2198        self.weightbt_string = event.GetEventObject().GetLabelText()
2199        self._set_weight()
2200
2201    def _set_weight(self, is_2D=None):
2202        """
2203        Set weight in fit problem
2204        """
2205        # compute weight for the current data
2206        flag_weight = self.get_weight_flag()
2207        if is_2D is None:
2208            is_2D = self._is_2D()
2209        self._manager.set_fit_weight(uid=self.uid,
2210                                     flag=flag_weight,
2211                                     is2d=is_2D,
2212                                     fid=None)
2213
2214    def onPinholeSmear(self, event):
2215        """
2216        Create a custom pinhole smear object that will change the way residuals
2217        are compute when fitting
2218
2219        :Note: accuracy is given by strings'High','Med', 'Low' FOR 2d,
2220                     None for 1D
2221
2222        """
2223        # Need update param values
2224        self._update_paramv_on_fit()
2225
2226        if event is not None:
2227            tcrtl = event.GetEventObject()
2228            # event case of radio button
2229            if tcrtl.GetValue():
2230                self.dx_min = 0.0
2231                self.dx_max = 0.0
2232                is_new_pinhole = True
2233            else:
2234                is_new_pinhole = self._is_changed_pinhole()
2235        else:
2236            is_new_pinhole = True
2237        # if any value is changed
2238        if is_new_pinhole:
2239            self._set_pinhole_smear()
2240        # hide all silt sizer
2241        self._hide_all_smear_info()
2242
2243        # show relevant slit sizers
2244        self._show_smear_sizer()
2245
2246        self.sizer_set_smearer.Layout()
2247        # we need FitInside here not just self.Layout to ensure all the sizers
2248        # end up with the necessasary space to in the scroll panel. In
2249        # particular the compute and fit buttons end up on top of each other
2250        # PDB Nov 28 2015.
2251        self.FitInside()
2252
2253        if event is not None:
2254            event.Skip()
2255        # self._undo.Enable(True)
2256        self.save_current_state()
2257        event = PageInfoEvent(page=self)
2258        wx.PostEvent(self.parent, event)
2259
2260    def _is_changed_pinhole(self):
2261        """
2262        check if any of pinhole smear is changed
2263
2264        :return: True or False
2265
2266        """
2267        # get the values
2268        pin_min = self.smear_pinhole_min.GetValue()
2269        pin_max = self.smear_pinhole_max.GetValue()
2270
2271        # Check changes in slit width
2272        try:
2273            dx_min = float(pin_min)
2274        except:
2275            return True
2276        if self.dx_min != dx_min:
2277            return True
2278
2279        # Check changes in slit heigth
2280        try:
2281            dx_max = float(pin_max)
2282        except:
2283            return True
2284        if self.dx_max != dx_max:
2285            return True
2286        return False
2287
2288    def _set_pinhole_smear(self):
2289        """
2290        Set custom pinhole smear
2291
2292        :return: msg
2293
2294        """
2295        # copy data
2296        data = copy.deepcopy(self.data)
2297        if self._is_2D():
2298            self.smear_type = 'Pinhole2d'
2299            len_data = len(data.data)
2300            data.dqx_data = numpy.zeros(len_data)
2301            data.dqy_data = numpy.zeros(len_data)
2302        else:
2303            self.smear_type = 'Pinhole'
2304            len_data = len(data.x)
2305            data.dx = numpy.zeros(len_data)
2306            data.dxl = None
2307            data.dxw = None
2308        msg = None
2309
2310        get_pin_min = self.smear_pinhole_min
2311        get_pin_max = self.smear_pinhole_max
2312
2313        if not check_float(get_pin_min):
2314            get_pin_min.SetBackgroundColour("pink")
2315            msg = "Model Error:wrong value entered!!!"
2316        elif not check_float(get_pin_max):
2317            get_pin_max.SetBackgroundColour("pink")
2318            msg = "Model Error:wrong value entered!!!"
2319        else:
2320            if len_data < 2:
2321                len_data = 2
2322            self.dx_min = float(get_pin_min.GetValue())
2323            self.dx_max = float(get_pin_max.GetValue())
2324            if self.dx_min < 0:
2325                get_pin_min.SetBackgroundColour("pink")
2326                msg = "Model Error:This value can not be negative!!!"
2327            elif self.dx_max < 0:
2328                get_pin_max.SetBackgroundColour("pink")
2329                msg = "Model Error:This value can not be negative!!!"
2330            elif self.dx_min is not None and self.dx_max is not None:
2331                if self._is_2D():
2332                    data.dqx_data[data.dqx_data == 0] = self.dx_min
2333                    data.dqy_data[data.dqy_data == 0] = self.dx_max
2334                elif self.dx_min == self.dx_max:
2335                    data.dx[data.dx == 0] = self.dx_min
2336                else:
2337                    step = (self.dx_max - self.dx_min) / (len_data - 1)
2338                    data.dx = numpy.arange(self.dx_min,
2339                                           self.dx_max + step / 1.1,
2340                                           step)
2341            elif self.dx_min is not None:
2342                if self._is_2D():
2343                    data.dqx_data[data.dqx_data == 0] = self.dx_min
2344                else:
2345                    data.dx[data.dx == 0] = self.dx_min
2346            elif self.dx_max is not None:
2347                if self._is_2D():
2348                    data.dqy_data[data.dqy_data == 0] = self.dx_max
2349                else:
2350                    data.dx[data.dx == 0] = self.dx_max
2351            self.current_smearer = smear_selection(data, self.model)
2352            # 2D need to set accuracy
2353            if self._is_2D():
2354                self.current_smearer.set_accuracy(
2355                    accuracy=self.smear2d_accuracy)
2356
2357        if msg is not None:
2358            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2359        else:
2360            get_pin_min.SetBackgroundColour("white")
2361            get_pin_max.SetBackgroundColour("white")
2362        # set smearing value whether or not the data contain the smearing info
2363
2364        enable_smearer = not self.disable_smearer.GetValue()
2365        self._manager.set_smearer(smearer=self.current_smearer,
2366                                  fid=self.data.id,
2367                                  qmin=float(self.qmin_x),
2368                                  qmax=float(self.qmax_x),
2369                                  enable_smearer=enable_smearer,
2370                                  uid=self.uid)
2371        return msg
2372
2373    def update_pinhole_smear(self):
2374        """
2375        called by kill_focus on pinhole TextCntrl
2376        to update the changes
2377
2378        :return: False when wrong value was entered
2379
2380        """
2381        # msg default
2382        msg = None
2383        # check if any value is changed
2384        if self._is_changed_pinhole():
2385            msg = self._set_pinhole_smear()
2386        wx.CallAfter(self.save_current_state)
2387
2388        if msg is not None:
2389            return False
2390        else:
2391            return True
2392
2393    def onSlitSmear(self, event):
2394        """
2395        Create a custom slit smear object that will change the way residuals
2396        are compute when fitting
2397        """
2398        # Need update param values
2399        self._update_paramv_on_fit()
2400
2401        # msg default
2402        msg = None
2403        # for event given
2404        if event is not None:
2405            tcrtl = event.GetEventObject()
2406            # event case of radio button
2407            if tcrtl.GetValue():
2408                self.dxl = 0.0
2409                self.dxw = 0.0
2410                is_new_slit = True
2411            else:
2412                is_new_slit = self._is_changed_slit()
2413        else:
2414            is_new_slit = True
2415
2416        # if any value is changed
2417        if is_new_slit:
2418            msg = self._set_slit_smear()
2419
2420        # hide all silt sizer
2421        self._hide_all_smear_info()
2422        # show relevant slit sizers
2423        self._show_smear_sizer()
2424        self.sizer_set_smearer.Layout()
2425        # we need FitInside here not just self.Layout to ensure all the sizers
2426        # end up with the necessasary space to in the scroll panel. In
2427        # particular the compute and fit buttons end up on top of each other
2428        # PDB Nov 28 2015.
2429        self.FitInside()
2430
2431        if event is not None:
2432            event.Skip()
2433        self.save_current_state()
2434        event = PageInfoEvent(page=self)
2435        wx.PostEvent(self.parent, event)
2436        if msg is not None:
2437            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2438
2439    def _is_changed_slit(self):
2440        """
2441        check if any of slit lengths is changed
2442
2443        :return: True or False
2444
2445        """
2446        # get the values
2447        width = self.smear_slit_width.GetValue()
2448        height = self.smear_slit_height.GetValue()
2449
2450        # check and change the box bg color if it was pink
2451        #    but it should be white now
2452        # because this is the case that _set_slit_smear() will not handle
2453        if height.lstrip().rstrip() == "":
2454            self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2455        if width.lstrip().rstrip() == "":
2456            self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2457
2458        # Check changes in slit width
2459        if width == "":
2460            dxw = 0.0
2461        else:
2462            try:
2463                dxw = float(width)
2464            except:
2465                return True
2466        if self.dxw != dxw:
2467            return True
2468
2469        # Check changes in slit heigth
2470        if height == "":
2471            dxl = 0.0
2472        else:
2473            try:
2474                dxl = float(height)
2475            except:
2476                return True
2477        if self.dxl != dxl:
2478            return True
2479
2480        return False
2481
2482    def _set_slit_smear(self):
2483        """
2484        Set custom slit smear
2485
2486        :return: message to inform the user about the validity
2487            of the values entered for slit smear
2488        """
2489        if self.data.__class__.__name__ == "Data2D" or self.enable2D:
2490            return
2491        # make sure once more if it is smearer
2492        data = copy.deepcopy(self.data)
2493        data_len = len(data.x)
2494        data.dx = None
2495        data.dxl = None
2496        data.dxw = None
2497        msg = None
2498
2499        try:
2500            self.dxl = float(self.smear_slit_height.GetValue())
2501            data.dxl = self.dxl * numpy.ones(data_len)
2502            self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2503        except:
2504            self.dxl = None
2505            data.dxl = numpy.zeros(data_len)
2506            if self.smear_slit_height.GetValue().lstrip().rstrip() != "":
2507                self.smear_slit_height.SetBackgroundColour("pink")
2508                msg = "Wrong value entered... "
2509            else:
2510                self.smear_slit_height.SetBackgroundColour(wx.WHITE)
2511        try:
2512            self.dxw = float(self.smear_slit_width.GetValue())
2513            self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2514            data.dxw = self.dxw * numpy.ones(data_len)
2515        except:
2516            self.dxw = None
2517            data.dxw = numpy.zeros(data_len)
2518            if self.smear_slit_width.GetValue().lstrip().rstrip() != "":
2519                self.smear_slit_width.SetBackgroundColour("pink")
2520                msg = "Wrong Fit value entered... "
2521            else:
2522                self.smear_slit_width.SetBackgroundColour(wx.WHITE)
2523
2524        self.current_smearer = smear_selection(data, self.model)
2525        # set smearing value whether or not the data contain the smearing info
2526        enable_smearer = not self.disable_smearer.GetValue()
2527        self._manager.set_smearer(smearer=self.current_smearer,
2528                                  fid=self.data.id,
2529                                  qmin=float(self.qmin_x),
2530                                  qmax=float(self.qmax_x),
2531                                  enable_smearer=enable_smearer,
2532                                  uid=self.uid)
2533        return msg
2534
2535    def update_slit_smear(self):
2536        """
2537        called by kill_focus on pinhole TextCntrl
2538        to update the changes
2539
2540        :return: False when wrong value was entered
2541
2542        """
2543        # msg default
2544        msg = None
2545        # check if any value is changed
2546        if self._is_changed_slit():
2547            msg = self._set_slit_smear()
2548        # self._undo.Enable(True)
2549        self.save_current_state()
2550
2551        if msg is not None:
2552            return False
2553        else:
2554            return True
2555
2556    def onSmear(self, event):
2557        """
2558        Create a smear object that will change the way residuals
2559        are computed when fitting
2560        """
2561        if event is not None:
2562            event.Skip()
2563        if self.data is None:
2564            return
2565
2566        # Need update param values
2567        self._update_paramv_on_fit()
2568        if self.model is not None:
2569            if self.data.is_data:
2570                self._manager.page_finder[self.uid].add_data(data=self.data)
2571        temp_smearer = self.on_smear_helper()
2572
2573        self.sizer_set_smearer.Layout()
2574        # we need FitInside here not just self.Layout to ensure all the sizers
2575        # end up with the necessasary space to in the scroll panel. In
2576        # particular the compute and fit buttons end up on top of each other
2577        # PDB Nov 28 2015.
2578        self.FitInside()
2579        self._set_weight()
2580
2581        # set smearing value whether or not the data contain the smearing info
2582        enable_smearer = not self.disable_smearer.GetValue()
2583        wx.CallAfter(self._manager.set_smearer, uid=self.uid,
2584                     smearer=temp_smearer,
2585                     fid=self.data.id,
2586                     qmin=float(self.qmin_x),
2587                     qmax=float(self.qmax_x),
2588                     enable_smearer=enable_smearer)
2589
2590        self.state.enable_smearer = self.enable_smearer.GetValue()
2591        self.state.disable_smearer = self.disable_smearer.GetValue()
2592        self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
2593        self.state.slit_smearer = self.slit_smearer.GetValue()
2594
2595    def on_smear_helper(self, update=False):
2596        """
2597        Help for onSmear
2598
2599        :param update: force or not to update
2600        """
2601        self._get_smear_info()
2602        # renew smear sizer
2603        if self.smear_type is not None:
2604            self.smear_description_smear_type.SetValue(str(self.smear_type))
2605            self.smear_data_left.SetValue(str(self.dq_l))
2606            self.smear_data_right.SetValue(str(self.dq_r))
2607
2608        self._hide_all_smear_info()
2609        data = copy.deepcopy(self.data)
2610
2611        # make sure once more if it is smearer
2612        temp_smearer = smear_selection(data, self.model)
2613        if self.current_smearer != temp_smearer or update:
2614            self.current_smearer = temp_smearer
2615        if self.enable_smearer.GetValue():
2616            if self.current_smearer is None:
2617                wx.PostEvent(self._manager.parent,
2618                    StatusEvent(status="Data contains no smearing information"))
2619            else:
2620                wx.PostEvent(self._manager.parent,
2621                    StatusEvent(status="Data contains smearing information"))
2622
2623            self.smear_data_left.Show(True)
2624            self.smear_data_right.Show(True)
2625            temp_smearer = self.current_smearer
2626        elif self.disable_smearer.GetValue():
2627            self.smear_description_none.Show(True)
2628        elif self.pinhole_smearer.GetValue():
2629            self.onPinholeSmear(None)
2630        elif self.slit_smearer.GetValue():
2631            self.onSlitSmear(None)
2632        self._show_smear_sizer()
2633
2634        return temp_smearer
2635
2636    def on_complete_chisqr(self, event):
2637        """
2638        Display result chisqr on the panel
2639        :event: activated by fitting/ complete after draw
2640        """
2641        try:
2642            if event is None:
2643                output = "-"
2644            elif not numpy.isfinite(event.output):
2645                output = "-"
2646            else:
2647                output = event.output
2648            self.tcChi.SetValue(str(format_number(output, True)))
2649            self.state.tcChi = self.tcChi.GetValue()
2650        except:
2651            pass
2652
2653    def get_all_checked_params(self):
2654        """
2655        Found all parameters current check and add them to list of parameters
2656        to fit
2657        """
2658        self.param_toFit = []
2659        for item in self.parameters:
2660            if item[0].GetValue() and item not in self.param_toFit:
2661                if item[0].IsShown():
2662                    self.param_toFit.append(item)
2663        for item in self.fittable_param:
2664            if item[0].GetValue() and item not in self.param_toFit:
2665                if item[0].IsShown():
2666                    self.param_toFit.append(item)
2667        self.save_current_state_fit()
2668
2669        event = PageInfoEvent(page=self)
2670        wx.PostEvent(self.parent, event)
2671        param2fit = []
2672        for item in self.param_toFit:
2673            if item[0] and item[0].IsShown():
2674                param2fit.append(item[1])
2675        self._manager.set_param2fit(self.uid, param2fit)
2676
2677    def select_param(self, event=None):
2678        """
2679        Select TextCtrl  checked for fitting purpose and stores them
2680        in  self.param_toFit=[] list
2681        """
2682        self.param_toFit = []
2683        for item in self.parameters:
2684            # Skip t ifhe angle parameters if 1D data
2685            if self.data.__class__.__name__ != "Data2D" and\
2686                        not self.enable2D:
2687                if item in self.orientation_params:
2688                    continue
2689            # Select parameters to fit for list of primary parameters
2690            if item[0].GetValue() and item[0].IsShown():
2691                if not (item in self.param_toFit):
2692                    self.param_toFit.append(item)
2693            else:
2694                #remove parameters from the fitting list
2695                if item in self.param_toFit:
2696                    self.param_toFit.remove(item)
2697
2698        # Select parameters to fit for list of fittable parameters
2699        #        with dispersion
2700        for item in self.fittable_param:
2701            # Skip t ifhe angle parameters if 1D data
2702            if self.data.__class__.__name__ != "Data2D" and\
2703                        not self.enable2D:
2704                if item in self.orientation_params:
2705                    continue
2706            if item[0].GetValue() and item[0].IsShown():
2707                if not (item in self.param_toFit):
2708                    self.param_toFit.append(item)
2709            else:
2710                # remove parameters from the fitting list
2711                if item in self.param_toFit:
2712                    self.param_toFit.remove(item)
2713
2714        # Calculate num. of angle parameters
2715        if self.data.__class__.__name__ == "Data2D" or \
2716                       self.enable2D:
2717            len_orient_para = 0
2718        else:
2719            len_orient_para = len(self.orientation_params)  # assume even len
2720        # Total num. of angle parameters
2721        if len(self.fittable_param) > 0:
2722            len_orient_para *= 2
2723
2724        self.save_current_state_fit()
2725        if event is not None:
2726            # post state to fit panel
2727            event = PageInfoEvent(page=self)
2728            wx.PostEvent(self.parent, event)
2729
2730        param2fit = []
2731        for item in self.param_toFit:
2732            if item[0] and item[0].IsShown():
2733                param2fit.append(item[1])
2734        self._manager.set_param2fit(self.uid, param2fit)
2735
2736    def set_model_param_sizer(self, model):
2737        """
2738        Build the panel from the model content
2739
2740        :param model: the model selected in combo box for fitting purpose
2741
2742        """
2743        self.sizer3.Clear(True)
2744        self.parameters = []
2745        self.str_parameters = []
2746        self.param_toFit = []
2747        self.fittable_param = []
2748        self.fixed_param = []
2749        self.orientation_params = []
2750        self.orientation_params_disp = []
2751
2752        if model is None:
2753            self.sizer3.Layout()
2754            self.SetupScrolling()
2755            return
2756
2757        box_description = wx.StaticBox(self, wx.ID_ANY, str("Model Parameters"))
2758        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
2759        sizer = wx.GridBagSizer(5, 5)
2760        # save the current model
2761        self.model = model
2762
2763        keys = self.model.getParamList()
2764
2765        # list of dispersion parameters
2766        self.disp_list = self.model.getDispParamList()
2767
2768        def custom_compare(a, b):
2769            """
2770            Custom compare to order, first by alphabets then second by number.
2771            """
2772            # number at the last digit
2773            a_last = a[len(a) - 1]
2774            b_last = b[len(b) - 1]
2775            # default
2776            num_a = None
2777            num_b = None
2778            # split the names
2779            a2 = a.lower().split('_')
2780            b2 = b.lower().split('_')
2781            # check length of a2, b2
2782            len_a2 = len(a2)
2783            len_b2 = len(b2)
2784            # check if it contains a int number(<10)
2785            try:
2786                num_a = int(a_last)
2787            except:
2788                pass
2789            try:
2790                num_b = int(b_last)
2791            except:
2792                pass
2793            # Put 'scale' near the top; happens
2794            # when numbered param name exists
2795            if a == 'scale':
2796                return -1
2797            # both have a number
2798            if num_a is not None and num_b is not None:
2799                if num_a > num_b:
2800                    return -1
2801                # same number
2802                elif num_a == num_b:
2803                    # different last names
2804                    if a2[len_a2 - 1] != b2[len_b2 - 1] and num_a != 0:
2805                        return -cmp(a2[len_a2 - 1], b2[len_b2 - 1])
2806                    else:
2807                        return cmp(a, b)
2808                else:
2809                    return 1
2810            # one of them has a number
2811            elif num_a is not None:
2812                return 1
2813            elif num_b is not None:
2814                return -1
2815            # no numbers
2816            else:
2817                return cmp(a.lower(), b.lower())
2818       
2819        # keys obtained now from ordered dict, so commenting alphabetical
2820        # ordering keys.sort(custom_compare)
2821
2822        iy = 0
2823        ix = 0
2824        sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Parameter'),
2825                  (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2826        ix += 1
2827        self.text2_2 = wx.StaticText(self, wx.ID_ANY, 'Value')
2828        sizer.Add(self.text2_2, (iy, ix), (1, 1),
2829                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2830        ix += 2
2831        self.text2_3 = wx.StaticText(self, wx.ID_ANY, 'Error')
2832        sizer.Add(self.text2_3, (iy, ix), (1, 1),
2833                  wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2834        if not self.is_mac:
2835            self.text2_3.Hide()
2836        ix += 1
2837        self.text2_min = wx.StaticText(self, wx.ID_ANY, 'Min')
2838        sizer.Add(self.text2_min, (iy, ix), (1, 1),
2839                  wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2840        # self.text2_min.Hide()
2841        ix += 1
2842        self.text2_max = wx.StaticText(self, wx.ID_ANY, 'Max')
2843        sizer.Add(self.text2_max, (iy, ix), (1, 1),
2844                  wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2845        # self.text2_max.Hide()
2846        ix += 1
2847        self.text2_4 = wx.StaticText(self, wx.ID_ANY, '[Units]')
2848        sizer.Add(self.text2_4, (iy, ix), (1, 1),
2849                  wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2850        self.text2_4.Hide()
2851
2852        CHECK_STATE = False
2853        for item in keys:
2854
2855            if item not in self.disp_list and not item in \
2856                    self.model.orientation_params:
2857
2858                # prepare a spot to store errors
2859                if item not in self.model.details:
2860                    self.model.details[item] = ["", None, None]
2861
2862                iy += 1
2863                ix = 0
2864                if (self.model.__class__ in
2865                    self.model_list_box["Multi-Functions"] or
2866                    self.temp_multi_functional)\
2867                    and (item in self.model.non_fittable):
2868                    non_fittable_name = wx.StaticText(self, wx.ID_ANY, item)
2869                    sizer.Add(non_fittable_name, (iy, ix), (1, 1),
2870                            wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 21)
2871                    # add parameter value
2872                    ix += 1
2873                    value = self.model.getParam(item)
2874                    if len(self.model.fun_list) > 0:
2875                        # num = item.split('_')[1][5:7]
2876                        fun_box = wx.ComboBox(self, wx.ID_ANY, size=(100, -1),
2877                                    style=wx.CB_READONLY, name='%s' % item)
2878                        self._set_fun_box_list(fun_box)
2879                        fun_box.SetSelection(0)
2880                        # self.fun_box.SetToolTipString("A function
2881                        #    describing the interface")
2882                        wx.EVT_COMBOBOX(fun_box, wx.ID_ANY, self._on_fun_box)
2883                    else:
2884                        fun_box = ModelTextCtrl(self, wx.ID_ANY,
2885                                                size=(_BOX_WIDTH, 20),
2886                                style=wx.TE_PROCESS_ENTER, name='%s' % item)
2887                        fun_box.SetToolTipString(
2888                                "Hit 'Enter' after typing to update the plot.")
2889                        fun_box.SetValue(format_number(value, True))
2890                    sizer.Add(fun_box, (iy, ix), (1, 1), wx.EXPAND)
2891                    self.str_parameters.append([None, item, fun_box,
2892                                                None, None, None,
2893                                                None, None])
2894                else:
2895                    # add parameters name with checkbox for selecting to fit
2896                    cb = wx.CheckBox(self, wx.ID_ANY, item)
2897                    cb.SetValue(CHECK_STATE)
2898                    cb.SetToolTipString(" Check mark to fit.")
2899                    # cb.SetValue(True)
2900                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
2901
2902                    sizer.Add(cb, (iy, ix), (1, 1),
2903                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
2904
2905                    # add parameter value
2906                    ix += 1
2907                    value = self.model.getParam(item)
2908                    ctl1 = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
2909                                         style=wx.TE_PROCESS_ENTER)
2910                    ctl1.SetToolTipString(
2911                                "Hit 'Enter' after typing to update the plot.")
2912                    ctl1.SetValue(format_number(value, True))
2913                    sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
2914                    # text to show error sign
2915                    ix += 1
2916                    text2 = wx.StaticText(self, wx.ID_ANY, '+/-')
2917                    sizer.Add(text2, (iy, ix), (1, 1),
2918                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2919                    if not self.is_mac:
2920                        text2.Hide()
2921                    ix += 1
2922                    ctl2 = wx.TextCtrl(self, wx.ID_ANY,
2923                                       size=(_BOX_WIDTH / 1.2, 20), style=0)
2924                    sizer.Add(ctl2, (iy, ix), (1, 1),
2925                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2926                    if not self.is_mac:
2927                        ctl2.Hide()
2928
2929                    ix += 1
2930                    ctl3 = ModelTextCtrl(self, wx.ID_ANY,
2931                                         size=(_BOX_WIDTH / 1.9, 20),
2932                                         style=wx.TE_PROCESS_ENTER,
2933                                text_enter_callback=self._onparamRangeEnter)
2934                    min_bound = self.model.details[item][1]
2935                    if min_bound is not None:
2936                        ctl3.SetValue(format_number(min_bound, True))
2937
2938                    sizer.Add(ctl3, (iy, ix), (1, 1),
2939                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2940
2941                    ix += 1
2942                    ctl4 = ModelTextCtrl(self, wx.ID_ANY,
2943                                         size=(_BOX_WIDTH / 1.9, 20),
2944                                         style=wx.TE_PROCESS_ENTER,
2945                                text_enter_callback=self._onparamRangeEnter)
2946                    max_bound = self.model.details[item][2]
2947                    if max_bound is not None:
2948                        ctl4.SetValue(format_number(max_bound, True))
2949                    sizer.Add(ctl4, (iy, ix), (1, 1),
2950                              wx.EXPAND | wx.FIXED_MINSIZE, 0)
2951
2952                    ix += 1
2953                    # Units
2954                    if item in self.model.details:
2955                        units = wx.StaticText(self, wx.ID_ANY,
2956                            self.model.details[item][0], style=wx.ALIGN_LEFT)
2957                    else:
2958                        units = wx.StaticText(self, wx.ID_ANY, "",
2959                                              style=wx.ALIGN_LEFT)
2960                    sizer.Add(units, (iy, ix), (1, 1),
2961                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
2962
2963                    self.parameters.append([cb, item, ctl1,
2964                                            text2, ctl2, ctl3, ctl4, units])
2965
2966        iy += 1
2967        sizer.Add((10, 10), (iy, ix), (1, 1),
2968                  wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
2969
2970        # type can be either Guassian or Array
2971        if len(self.model.dispersion.values()) > 0:
2972            type = self.model.dispersion.values()[0]["type"]
2973        else:
2974            type = "Gaussian"
2975
2976        iy += 1
2977        ix = 0
2978        # Add tile for orientational angle
2979        for item in keys:
2980            if item in self.model.orientation_params:
2981                orient_angle = wx.StaticText(self, wx.ID_ANY, '[For 2D only]:')
2982                mag_on_button = wx.Button(self, wx.ID_ANY, "Magnetic ON")
2983                mag_on_button.SetToolTipString("Turn Pol Beam/Mag scatt on/off")
2984                mag_on_button.Bind(wx.EVT_BUTTON, self._on_mag_on)
2985                mag_angle_help_button = wx.Button(self, wx.ID_ANY,
2986                                                  "Magnetic angles?")
2987                mag_angle_help_button.SetToolTipString("see angle definitions")
2988                mag_help_button = wx.Button(self, wx.ID_ANY, "Mag HELP")
2989                mag_help_button.SetToolTipString("Help on pol beam/mag fitting")
2990                mag_help_button.Bind(wx.EVT_BUTTON, self._on_mag_help)
2991                mag_angle_help_button.Bind(wx.EVT_BUTTON,
2992                                            self._on_mag_angle_help)
2993                sizer.Add(orient_angle, (iy, ix), (1, 1),
2994                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
2995                iy += 1
2996                sizer.Add(mag_on_button, (iy, ix), (1, 1),
2997                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
2998                ix += 1
2999                sizer.Add(mag_angle_help_button, (iy, ix), (1, 1),
3000                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
3001                sizer.Add(mag_help_button, (iy, ix + 1), (1, 1),
3002                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15)
3003
3004                # handle the magnetic buttons
3005                # clean this up so that assume mag is off then turn
3006                # all buttons on IF mag has mag and has 2D
3007                if not self._has_magnetic:
3008                    mag_on_button.Show(False)
3009                elif not self.data.__class__.__name__ == "Data2D":
3010                    mag_on_button.Show(False)
3011                else:
3012                    mag_on_button.Show(True)
3013                mag_help_button.Show(False)
3014                mag_angle_help_button.Show(False)
3015                if mag_on_button.IsShown():
3016                    if self.magnetic_on:
3017                        mag_on_button.SetLabel("Magnetic OFF")
3018                        mag_help_button.Show(True)
3019                        mag_angle_help_button.Show(True)
3020                    else:
3021                        mag_on_button.SetLabel("Magnetic ON")
3022                        mag_help_button.Show(False)
3023                        mag_angle_help_button.Show(False)
3024
3025                if not self.data.__class__.__name__ == "Data2D" and \
3026                        not self.enable2D:
3027                    orient_angle.Hide()
3028                else:
3029                    orient_angle.Show(True)
3030                break
3031
3032        # For Gaussian only
3033        if type.lower() != "array":
3034            for item in self.model.orientation_params:
3035                if not self.magnetic_on:
3036                    if item in self.model.magnetic_params:
3037                        continue
3038                if item not in self.disp_list:
3039                    # prepare a spot to store min max
3040                    if item not in self.model.details:
3041                        self.model.details[item] = ["", None, None]
3042
3043                    iy += 1
3044                    ix = 0
3045                    # add parameters name with checkbox for selecting to fit
3046                    cb = wx.CheckBox(self, wx.ID_ANY, item)
3047                    cb.SetValue(CHECK_STATE)
3048                    cb.SetToolTipString("Check mark to fit")
3049                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param)
3050                    if self.data.__class__.__name__ == "Data2D" or \
3051                            self.enable2D:
3052                        cb.Show(True)
3053                    else:
3054                        cb.Hide()
3055                    sizer.Add(cb, (iy, ix), (1, 1),
3056                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5)
3057
3058                    # add parameter value
3059                    ix += 1
3060                    value = self.model.getParam(item)
3061                    ctl1 = ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
3062                                         style=wx.TE_PROCESS_ENTER)
3063                    ctl1.SetToolTipString(
3064                                "Hit 'Enter' after typing to update the plot.")
3065                    ctl1.SetValue(format_number(value, True))
3066                    if self.data.__class__.__name__ == "Data2D" or \
3067                            self.enable2D:
3068                        ctl1.Show(True)
3069                    else:
3070                        ctl1.Hide()
3071                    sizer.Add(ctl1, (iy, ix), (1, 1), wx.EXPAND)
3072                    # text to show error sign
3073                    ix += 1
3074                    text2 = wx.StaticText(self, -1, '+/-')
3075                    sizer.Add(text2, (iy, ix), (1, 1),
3076                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
3077
3078                    text2.Hide()
3079                    ix += 1
3080                    ctl2 = wx.TextCtrl(self, -1,
3081                                       size=(_BOX_WIDTH / 1.2, 20), style=0)
3082                    sizer.Add(ctl2, (iy, ix), (1, 1),
3083                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
3084
3085                    ctl2.Hide()
3086
3087                    ix += 1
3088                    ctl3 = ModelTextCtrl(self, -1,
3089                                         size=(_BOX_WIDTH / 1.8, 20),
3090                                         style=wx.TE_PROCESS_ENTER,
3091                                text_enter_callback=self._onparamRangeEnter)
3092
3093                    sizer.Add(ctl3, (iy, ix), (1, 1),
3094                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
3095                    ctl3.Hide()
3096
3097                    ix += 1
3098                    ctl4 = ModelTextCtrl(self, -1,
3099                                         size=(_BOX_WIDTH / 1.8, 20),
3100                                         style=wx.TE_PROCESS_ENTER,
3101                            text_enter_callback=self._onparamRangeEnter)
3102                    sizer.Add(ctl4, (iy, ix), (1, 1),
3103                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
3104
3105                    ctl4.Hide()
3106
3107                    if self.data.__class__.__name__ == "Data2D" or \
3108                            self.enable2D:
3109                        if self.is_mac:
3110                            text2.Show(True)
3111                            ctl2.Show(True)
3112                        ctl3.Show(True)
3113                        ctl4.Show(True)
3114
3115                    ix += 1
3116                    # Units
3117                    if item in self.model.details:
3118                        units = wx.StaticText(self, -1,
3119                                              self.model.details[item][0],
3120                                              style=wx.ALIGN_LEFT)
3121                    else:
3122                        units = wx.StaticText(self, -1, "",
3123                                              style=wx.ALIGN_LEFT)
3124                    if self.data.__class__.__name__ == "Data2D" or \
3125                            self.enable2D:
3126                        units.Show(True)
3127                    else:
3128                        units.Hide()
3129
3130                    sizer.Add(units, (iy, ix), (1, 1),
3131                              wx.EXPAND | wx.ADJUST_MINSIZE, 0)
3132
3133                    self.parameters.append([cb, item, ctl1,
3134                                            text2, ctl2, ctl3, ctl4, units])
3135                    self.orientation_params.append([cb, item, ctl1,
3136                                            text2, ctl2, ctl3, ctl4, units])
3137
3138        iy += 1
3139        box_description.SetForegroundColour(wx.BLUE)
3140        # Display units text on panel
3141        for item in keys:
3142            if item in self.model.details:
3143                self.text2_4.Show()
3144        # Fill the list of fittable parameters
3145        self.get_all_checked_params()
3146        self.save_current_state_fit()
3147        boxsizer1.Add(sizer)
3148        self.sizer3.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
3149        self.sizer3.Layout()
3150        self.Layout()
3151
3152    def on_right_down(self, event):
3153        """
3154        Get key stroke event
3155        """
3156        if self.data is None:
3157            return
3158        # Figuring out key combo: Cmd for copy, Alt for paste
3159        if event.AltDown() and event.ShiftDown():
3160            flag = True
3161        elif event.AltDown() or event.ShiftDown():
3162            flag = False
3163        else:
3164            return
3165        # make event free
3166        event.Skip()
3167        # messages depending on the flag
3168        if not flag:
3169            infor = 'warning'
3170            # inform msg to wx
3171            wx.PostEvent(self._manager.parent,
3172                        StatusEvent(status=msg, info=infor))
3173
3174    def _onModel2D(self, event):
3175        """
3176        toggle view of model from 1D to 2D  or 2D from 1D
3177        """
3178        if self.model_view.GetLabelText() == "Show 2D":
3179            self.model_view.SetLabel("Show 1D")
3180            self.enable2D = True
3181
3182        else:
3183            self.model_view.SetLabel("Show 2D")
3184            self.enable2D = False
3185        self.Show(False)
3186        self.create_default_data()
3187        self._manager.store_data(self.uid, data_list=[self.data])
3188
3189        self.set_model_param_sizer(self.model)
3190        self._set_sizer_dispersion()
3191        self._set_weight(is_2D=self.enable2D)
3192        self._set_smear_buttons()
3193        self.Show(True)
3194        self.SetupScrolling()
3195        self._draw_model()
3196
3197        self.state.enable2D = copy.deepcopy(self.enable2D)
3198
3199    def _set_smear_buttons(self):
3200        """
3201        Set semarer radio buttons
3202        """
3203        # more disables for 2D
3204        if self.data.__class__.__name__ == "Data2D" or \
3205                    self.enable2D:
3206            self.slit_smearer.Disable()
3207            self.pinhole_smearer.Enable(True)
3208            self.default_mask = copy.deepcopy(self.data.mask)
3209        else:
3210            self.slit_smearer.Enable(True)
3211            self.pinhole_smearer.Enable(True)
3212
3213
3214class BGTextCtrl(wx.TextCtrl):
3215    """
3216    Text control used to display outputs.
3217    No editing allowed. The background is
3218    grayed out. User can't select text.
3219    """
3220    def __init__(self, *args, **kwds):
3221        wx.TextCtrl.__init__(self, *args, **kwds)
3222        self.SetEditable(False)
3223        self.SetBackgroundColour(self.GetParent().parent.GetBackgroundColour())
3224
3225        # Bind to mouse event to avoid text highlighting
3226        # The event will be skipped once the call-back
3227        # is called.
3228        self.Bind(wx.EVT_MOUSE_EVENTS, self._click)
3229
3230    def _click(self, event):
3231        """
3232        Prevent further handling of the mouse event
3233        by not calling Skip().
3234        """
3235        pass
Note: See TracBrowser for help on using the repository browser.