source: sasview/src/sas/sasgui/perspectives/fitting/fitpage.py @ 6c382da

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.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 6c382da was 6c382da, checked in by Paul Kienzle <pkienzle@…>, 5 years ago

support alternate distributions in save/load and copy/paste. Closes #669

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