source: sasview/src/sas/sasgui/perspectives/fitting/basepage.py @ d85f1d8a

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.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since d85f1d8a was d85f1d8a, checked in by krzywon, 7 years ago

Saving and then loading in same save state working with custom pinhole dQ as a percentage. #850

  • Property mode set to 100644
File size: 142.9 KB
Line 
1"""
2Base Page for fitting
3"""
4import sys
5import os
6import wx
7import numpy
8import time
9import copy
10import math
11import json
12import logging
13import traceback
14
15from collections import defaultdict
16from wx.lib.scrolledpanel import ScrolledPanel
17
18from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
19
20from sas.sasgui.guiframe.panel_base import PanelBase
21from sas.sasgui.guiframe.utils import format_number, check_float, IdList, \
22    check_int
23from sas.sasgui.guiframe.events import PanelOnFocusEvent
24from sas.sasgui.guiframe.events import StatusEvent
25from sas.sasgui.guiframe.events import AppendBookmarkEvent
26from sas.sasgui.guiframe.dataFitting import Data2D
27from sas.sasgui.guiframe.dataFitting import Data1D
28from sas.sasgui.guiframe.dataFitting import check_data_validity
29from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
30from sas.sascalc.dataloader.data_info import Detector
31from sas.sascalc.dataloader.data_info import Source
32from sas.sasgui.perspectives.fitting.pagestate import PageState
33from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller
34from sas.sasgui.guiframe.documentation_window import DocumentationWindow
35
36
37(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent()
38(PreviousStateEvent, EVT_PREVIOUS_STATE) = wx.lib.newevent.NewEvent()
39(NextStateEvent, EVT_NEXT_STATE) = wx.lib.newevent.NewEvent()
40
41_BOX_WIDTH = 76
42_QMIN_DEFAULT = 0.0005
43_QMAX_DEFAULT = 0.5
44_NPTS_DEFAULT = 50
45# Control panel width
46if sys.platform.count("win32") > 0:
47    PANEL_WIDTH = 450
48    FONT_VARIANT = 0
49    ON_MAC = False
50else:
51    PANEL_WIDTH = 500
52    FONT_VARIANT = 1
53    ON_MAC = True
54
55CUSTOM_MODEL = 'Plugin Models'
56
57class BasicPage(ScrolledPanel, PanelBase):
58    """
59    This class provide general structure of the fitpanel page
60    """
61    # Internal name for the AUI manager
62    window_name = "Fit Page"
63    # Title to appear on top of the window
64    window_caption = "Fit Page "
65
66    # These two buttons have specific IDs since they seem to be created more
67    # frequently than they need to.  In particular, set_dispers_sizer() is
68    # called by _on_select_model
69    ID_BOOKMARK = wx.NewId()
70    ID_DISPERSER_HELP = wx.NewId()
71    _id_pool = IdList()
72
73    def __init__(self, parent, color='blue', **kwargs):
74        """
75        """
76        ScrolledPanel.__init__(self, parent, **kwargs)
77        PanelBase.__init__(self, parent)
78        self.SetupScrolling()
79        # Set window's font size
80        self.SetWindowVariant(variant=FONT_VARIANT)
81        self.SetBackgroundColour(color)
82
83        self._ids = iter(self._id_pool)
84        # parent of the page
85        self.parent = parent
86        # manager is the fitting plugin
87        # owner of the page (fitting plugin)
88        self.event_owner = None
89        # current model
90        self.model = None
91        self.m_name = None
92        self.index_model = None
93        self.panel = None
94        # data
95        self.data = None
96        # list of available data
97        self.data_list = []
98        self.mask = None
99        self.uid = wx.NewId()
100        self.graph_id = None
101        # Q range for data set
102        self.qmin_data_set = numpy.inf
103        self.qmax_data_set = None
104        self.npts_data_set = 0
105        # Q range
106        self.qmin = None
107        self.qmax = None
108        self.qmax_x = _QMAX_DEFAULT
109        self.qmin_x = _QMIN_DEFAULT
110        self.npts_x = _NPTS_DEFAULT
111        # total number of point: float
112        self.npts = None
113        self.num_points = None
114        # smear default
115        self.current_smearer = None
116        # 2D smear accuracy default
117        self.smear2d_accuracy = 'Low'
118        # slit smear:
119        self.dxl = None
120        self.dxw = None
121        # pinhole smear
122        self.dx_percent = None
123        # smear attrbs
124        self.enable_smearer = None
125        self.disable_smearer = None
126        self.pinhole_smearer = None
127        self.slit_smearer = None
128        # weight attrbs
129        self.dI_noweight = None
130        self.dI_didata = None
131        self.dI_sqrdata = None
132        self.dI_idata = None
133        # other attrbs
134        self.dq_l = None
135        self.dq_r = None
136        self.tcChi = None
137        self.disp_box = None
138        self.model_disp = None
139        self.Npts_fit = None
140        self.Npts_total = None
141        self.theory_qmin = None
142        self.theory_qmax = None
143        self.theory_qmin_x = None
144        self.theory_qmax_x = None
145        self.btEditMask = None
146        self.btFit = None
147        self.sld_axes = None
148        self.multi_factor = None
149
150        self.disp_cb_dict = {}
151
152        # self.state = PageState(parent=parent)
153        # dictionary containing list of models
154        self.model_list_box = {}
155
156        # Data member to store the dispersion object created
157        self._disp_obj_dict = {}
158        # selected parameters to apply dispersion
159        self.disp_cb_dict = {}
160        # smearer object
161        self.enable2D = False
162        self._has_magnetic = False
163        self.magnetic_on = False
164        self.is_mac = ON_MAC
165        self.formfactorbox = None
166        self.structurebox = None
167        self.categorybox = None
168        # list of model parameters. each item must have same length
169        # each item related to a given parameters
170        # [cb state, name, value, "+/-", error of fit, min, max , units]
171        self.parameters = []
172        # non-fittable parameter whose value is astring
173        self.str_parameters = []
174        # list of parameters to fit , must be like self.parameters
175        self.param_toFit = []
176        # list of looking like parameters but with non fittable parameters info
177        self.fixed_param = []
178        # list of looking like parameters but with  fittable parameters info
179        self.fittable_param = []
180        # list of dispersion parameters
181        self.disp_list = []
182        self.disp_name = ""
183
184        # list of orientation parameters
185        self.orientation_params = []
186        self.orientation_params_disp = []
187#       Self.model should ALWAYS be None here.  It was set to none above in
188#       this long init setting.  no obvious function call in between setting
189#       and this - commenting out on 4/8/2014 by PDB.  Remove once clear
190#       it is pointless.
191#        if self.model is not None:
192#            self.disp_list = self.model.getDispParamList()
193        self.temp_multi_functional = False
194        # enable model 2D draw
195        self.enable2D = False
196        # check that the fit range is correct to plot the model again
197        self.fitrange = True
198        # Create memento to save the current state
199        self.state = PageState(parent=self.parent,
200                               model=self.model, data=self.data)
201        # flag to determine if state has change
202        self.state_change = False
203        # save customized array
204        self.values = {}   # type: Dict[str, List[float, ...]]
205        self.weights = {}   # type: Dict[str, List[float, ...]]
206        # retrieve saved state
207        self.number_saved_state = 0
208        # dictionary of saved state
209        self.saved_states = {}
210        # Create context menu for page
211        self.popUpMenu = wx.Menu()
212
213        wx_id = self._ids.next()
214        self._keep = wx.MenuItem(self.popUpMenu, wx_id, "Add bookmark",
215                                 " Keep the panel status to recall it later")
216        self.popUpMenu.AppendItem(self._keep)
217        self._keep.Enable(False)
218        self._set_bookmark_flag(False)
219        self._set_save_flag(False)
220        wx.EVT_MENU(self, wx_id, self.on_bookmark)
221        self.popUpMenu.AppendSeparator()
222
223        # Default locations
224        self._default_save_location = os.getcwd()
225        # save initial state on context menu
226        # self.onSave(event=None)
227        self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
228
229        # bind key event
230        self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down)
231
232        # create the basic structure of the panel with empty sizer
233        self.define_page_structure()
234        # drawing Initial dispersion parameters sizer
235        self.set_dispers_sizer()
236
237        # layout
238        self.set_layout()
239
240    def set_index_model(self, index):
241        """
242        Index related to this page
243        """
244        self.index_model = index
245
246    def create_default_data(self):
247        """
248        Given the user selection, creates a 1D or 2D data
249        Only when the page is on theory mode.
250        """
251        if not hasattr(self, "model_view"):
252            return
253        toggle_mode_on = self.model_view.IsEnabled()
254        if toggle_mode_on:
255            if self.enable2D and not check_data_validity(self.data):
256                self._create_default_2d_data()
257            else:
258                if self.pointsbox.GetValue():
259                    self._create_log_1d_data()
260                else:
261                    self._create_default_1d_data()
262
263            if self.model is not None:
264                if not self.data.is_data:
265                    self._manager.page_finder[self.uid].set_fit_data(
266                        data=[self.data])
267            self.on_smear_helper(update=True)
268            self.state.enable_smearer = self.enable_smearer.GetValue()
269            self.state.disable_smearer = self.disable_smearer.GetValue()
270            self.state.pinhole_smearer = self.pinhole_smearer.GetValue()
271            self.state.slit_smearer = self.slit_smearer.GetValue()
272
273    def _create_default_1d_data(self):
274        """
275        Create default data for fitting perspective
276        Only when the page is on theory mode.
277        :warning: This data is never plotted.
278
279        """
280        x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x,
281                           num=self.npts_x, endpoint=True)
282        self.data = Data1D(x=x)
283        self.data.xaxis('\\rm{Q}', "A^{-1}")
284        self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
285        self.data.is_data = False
286        self.data.id = str(self.uid) + " data"
287        self.data.group_id = str(self.uid) + " Model1D"
288
289    def _create_log_1d_data(self):
290        """
291        Create log-spaced data for fitting perspective
292        Only when the page is on theory mode.
293        :warning: This data is never plotted.
294
295        """
296        if self.qmin_x >= 1.e-10:
297            qmin = numpy.log10(self.qmin_x)
298        else:
299            qmin = -10.
300
301        if self.qmax_x <= 1.e10:
302            qmax = numpy.log10(self.qmax_x)
303        else:
304            qmax = 10.
305
306        x = numpy.logspace(start=qmin, stop=qmax,
307                           num=self.npts_x, endpoint=True, base=10.0)
308        self.data = Data1D(x=x)
309        self.data.xaxis('\\rm{Q}', "A^{-1}")
310        self.data.yaxis('\\rm{Intensity}', "cm^{-1}")
311        self.data.is_data = False
312        self.data.id = str(self.uid) + " data"
313        self.data.group_id = str(self.uid) + " Model1D"
314
315    def _create_default_2d_data(self):
316        """
317        Create 2D data by default
318        Only when the page is on theory mode.
319        :warning: This data is never plotted.
320        """
321        self.data = Data2D()
322        qmax = self.qmax_x / math.sqrt(2)
323        self.data.xaxis('\\rm{Q_{x}}', 'A^{-1}')
324        self.data.yaxis('\\rm{Q_{y}}', 'A^{-1}')
325        self.data.is_data = False
326        self.data.id = str(self.uid) + " data"
327        self.data.group_id = str(self.uid) + " Model2D"
328        # Default values
329        self.data.detector.append(Detector())
330        index = len(self.data.detector) - 1
331        self.data.detector[index].distance = 8000   # mm
332        self.data.source.wavelength = 6             # A
333        self.data.detector[index].pixel_size.x = 5  # mm
334        self.data.detector[index].pixel_size.y = 5  # mm
335        self.data.detector[index].beam_center.x = qmax
336        self.data.detector[index].beam_center.y = qmax
337        xmax = qmax
338        xmin = -qmax
339        ymax = qmax
340        ymin = -qmax
341        qstep = self.npts_x
342
343        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
344        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
345        # use data info instead
346        new_x = numpy.tile(x, (len(y), 1))
347        new_y = numpy.tile(y, (len(x), 1))
348        new_y = new_y.swapaxes(0, 1)
349        # all data reuire now in 1d array
350        qx_data = new_x.flatten()
351        qy_data = new_y.flatten()
352        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
353        # set all True (standing for unmasked) as default
354        mask = numpy.ones(len(qx_data), dtype=bool)
355        # store x and y bin centers in q space
356        x_bins = x
357        y_bins = y
358
359        self.data.source = Source()
360        self.data.data = numpy.ones(len(mask))
361        self.data.err_data = numpy.ones(len(mask))
362        self.data.qx_data = qx_data
363        self.data.qy_data = qy_data
364        self.data.q_data = q_data
365        self.data.mask = mask
366        self.data.x_bins = x_bins
367        self.data.y_bins = y_bins
368        # max and min taking account of the bin sizes
369        self.data.xmin = xmin
370        self.data.xmax = xmax
371        self.data.ymin = ymin
372        self.data.ymax = ymax
373
374    def on_set_focus(self, event):
375        """
376        On Set Focus, update guimanger and menu
377        """
378        if self._manager is not None:
379            wx.PostEvent(self._manager.parent, PanelOnFocusEvent(panel=self))
380            self.on_tap_focus()
381
382    def on_tap_focus(self):
383        """
384        Update menu1 on cliking the page tap
385        """
386        if self._manager.menu1 is not None:
387            chain_menu = self._manager.menu1.FindItemById(
388                                                   self._manager.id_reset_flag)
389            chain_menu.Enable(self.batch_on)
390            sim_menu = self._manager.menu1.FindItemById(self._manager.id_simfit)
391            flag = self.data.is_data\
392                            and (self.model is not None)
393            sim_menu.Enable(not self.batch_on and flag)
394            batch_menu = \
395                    self._manager.menu1.FindItemById(self._manager.id_batchfit)
396            batch_menu.Enable(self.batch_on and flag)
397
398    def onContextMenu(self, event):
399        """
400        Retrieve the state selected state
401        """
402        pos = event.GetPosition()
403        pos = self.ScreenToClient(pos)
404        self.PopupMenu(self.popUpMenu, pos)
405
406    def onUndo(self, event):
407        """
408        Cancel the previous action
409        """
410        event = PreviousStateEvent(page=self)
411        wx.PostEvent(self.parent, event)
412
413    def onRedo(self, event):
414        """
415        Restore the previous action cancelled
416        """
417        event = NextStateEvent(page=self)
418        wx.PostEvent(self.parent, event)
419
420    def define_page_structure(self):
421        """
422        Create empty sizer for a panel
423        """
424        self.vbox = wx.BoxSizer(wx.VERTICAL)
425        self.sizer0 = wx.BoxSizer(wx.VERTICAL)
426        self.sizer1 = wx.BoxSizer(wx.VERTICAL)
427        self.sizer2 = wx.BoxSizer(wx.VERTICAL)
428        self.sizer3 = wx.BoxSizer(wx.VERTICAL)
429        self.sizer4 = wx.BoxSizer(wx.VERTICAL)
430        self.sizer5 = wx.BoxSizer(wx.VERTICAL)
431        self.sizer6 = wx.BoxSizer(wx.VERTICAL)
432
433        self.sizer0.SetMinSize((PANEL_WIDTH, -1))
434        self.sizer1.SetMinSize((PANEL_WIDTH, -1))
435        self.sizer2.SetMinSize((PANEL_WIDTH, -1))
436        self.sizer3.SetMinSize((PANEL_WIDTH, -1))
437        self.sizer4.SetMinSize((PANEL_WIDTH, -1))
438        self.sizer5.SetMinSize((PANEL_WIDTH, -1))
439        self.sizer6.SetMinSize((PANEL_WIDTH, -1))
440
441        self.vbox.Add(self.sizer0)
442        self.vbox.Add(self.sizer1)
443        self.vbox.Add(self.sizer2)
444        self.vbox.Add(self.sizer3)
445        self.vbox.Add(self.sizer4)
446        self.vbox.Add(self.sizer5)
447        self.vbox.Add(self.sizer6)
448
449    def set_layout(self):
450        """
451        layout
452        """
453        self.vbox.Layout()
454        self.vbox.Fit(self)
455        self.SetSizer(self.vbox)
456        self.Centre()
457
458    def set_owner(self, owner):
459        """
460        set owner of fitpage
461
462        :param owner: the class responsible of plotting
463
464        """
465        self.event_owner = owner
466        self.state.event_owner = owner
467
468    def get_state(self):
469        """
470        return the current page state
471        """
472        return self.state
473
474    def get_data(self):
475        """
476        return the current data
477        """
478        return self.data
479
480    def get_data_list(self):
481        """
482        return the current data
483        """
484        return self.data_list
485
486    def set_manager(self, manager):
487        """
488        set panel manager
489
490        :param manager: instance of plugin fitting
491
492        """
493        self._manager = manager
494        self.state.manager = manager
495
496    def populate_box(self, model_dict):
497        """
498        Store list of model
499
500        :param model_dict: dictionary containing list of models
501
502        """
503        self.model_list_box = model_dict
504        self.state.model_list_box = self.model_list_box
505        self.initialize_combox()
506
507    def set_model_dictionary(self, model_dict):
508        """
509        Store a dictionary linking model name -> model object
510
511        :param model_dict: dictionary containing list of models
512        """
513        self.model_dict = model_dict
514
515    def initialize_combox(self):
516        """
517        put default value in the combo box
518        """
519        if self.model_list_box is not None and len(self.model_list_box) > 0:
520            self._populate_box(self.structurebox,
521                               self.model_list_box["Structure Factors"])
522            self.structurebox.Insert("None", 0, None)
523            self.structurebox.SetSelection(0)
524            self.structurebox.Hide()
525            self.text2.Hide()
526            self.structurebox.Disable()
527            self.text2.Disable()
528
529    def set_dispers_sizer(self):
530        """
531        fill sizer containing dispersity info
532        """
533        # print "==== entering set_dispers_sizer ==="
534        self.sizer4.Clear(True)
535        name = "Polydispersity and Orientational Distribution"
536        box_description = wx.StaticBox(self, wx.ID_ANY, name)
537        box_description.SetForegroundColour(wx.BLUE)
538        boxsizer1 = wx.StaticBoxSizer(box_description, wx.VERTICAL)
539        # ----------------------------------------------------
540        self.disable_disp = wx.RadioButton(self, wx.ID_ANY, 'Off', (10, 10),
541                                           style=wx.RB_GROUP)
542        self.enable_disp = wx.RadioButton(self, wx.ID_ANY, 'On', (10, 30))
543        # best size for MAC and PC
544        if ON_MAC:
545            size_q = (30, 20)
546        else:
547            size_q = (20, 15)
548        self.disp_help_bt = wx.Button(self, self.ID_DISPERSER_HELP, '?',
549                                      style=wx.BU_EXACTFIT,
550                                      size=size_q)
551        self.disp_help_bt.Bind(wx.EVT_BUTTON, self.on_pd_help_clicked,
552                               id=self.disp_help_bt.GetId())
553        self.disp_help_bt.SetToolTipString("Help for polydispersion.")
554
555        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
556                  id=self.disable_disp.GetId())
557        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param,
558                  id=self.enable_disp.GetId())
559        # MAC needs SetValue
560        self.disable_disp.SetValue(True)
561        sizer_dispersion = wx.BoxSizer(wx.HORIZONTAL)
562        sizer_dispersion.Add((20, 20))
563        name = ""  # Polydispersity and \nOrientational Distribution "
564        sizer_dispersion.Add(wx.StaticText(self, wx.ID_ANY, name))
565        sizer_dispersion.Add(self.enable_disp)
566        sizer_dispersion.Add((20, 20))
567        sizer_dispersion.Add(self.disable_disp)
568        sizer_dispersion.Add((25, 20))
569        sizer_dispersion.Add(self.disp_help_bt)
570
571        # fill a sizer for dispersion
572        boxsizer1.Add(sizer_dispersion, 0,
573                      wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,
574                      border=5)
575        self.sizer4_4 = wx.GridBagSizer(6, 5)
576
577        boxsizer1.Add(self.sizer4_4)
578        # -----------------------------------------------------
579        self.sizer4.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
580        self.sizer4_4.Layout()
581        self.sizer4.Layout()
582        self.Layout()
583
584        self.Refresh()
585        # saving the state of enable dispersity button
586        self.state.enable_disp = self.enable_disp.GetValue()
587        self.state.disable_disp = self.disable_disp.GetValue()
588        self.SetupScrolling()
589
590    def onResetModel(self, event):
591        """
592        Reset model state
593        """
594        menu = event.GetEventObject()
595        # post help message for the selected model
596        msg = menu.GetHelpString(event.GetId())
597        msg += " reloaded"
598        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
599        self.Show(False)
600        name = menu.GetLabel(event.GetId())
601        self._on_select_model_helper()
602        if self.model is not None:
603            self.m_name = self.model.name
604        if name in self.saved_states.keys():
605            previous_state = self.saved_states[name]
606            # reset state of checkbox,textcrtl  and  regular parameters value
607
608            self.reset_page(previous_state)
609        self.state.m_name = self.m_name
610        self.Show(True)
611
612    def on_preview(self, event):
613        """
614        Report the current fit results
615        """
616        # Get plot image from plotpanel
617        images, canvases = self.get_images()
618        # get the report dialog
619        self.state.report(images, canvases)
620
621    def on_save(self, event):
622        """
623        Save the current state into file
624        """
625        self.save_current_state()
626        new_state = self.state.clone()
627        # Ask the user the location of the file to write to.
628        path = None
629        if self.parent is not None:
630            self._default_save_location = \
631                        self._manager.parent._default_save_location
632        dlg = wx.FileDialog(self, "Choose a file", self._default_save_location,
633                            self.window_caption, "*.fitv", wx.SAVE)
634
635        if dlg.ShowModal() == wx.ID_OK:
636            path = dlg.GetPath()
637            self._default_save_location = os.path.dirname(path)
638            self._manager.parent._default_save_location = \
639                self._default_save_location
640        else:
641            return None
642        # MAC always needs the extension for saving
643        extens = ".fitv"
644        # Make sure the ext included in the file name
645        fName = os.path.splitext(path)[0] + extens
646        # the manager write the state into file
647        self._manager.save_fit_state(filepath=fName, fitstate=new_state)
648        return new_state
649
650    def on_copy(self, event):
651        """
652        Copy Parameter values to the clipboad
653        """
654        if event is not None:
655            event.Skip()
656        # It seems MAC needs wxCallAfter
657        if event.GetId() == GUIFRAME_ID.COPYEX_ID:
658            print "copy excel"
659            wx.CallAfter(self.get_copy_excel)
660        elif event.GetId() == GUIFRAME_ID.COPYLAT_ID:
661            print "copy latex"
662            wx.CallAfter(self.get_copy_latex)
663        else:
664            wx.CallAfter(self.get_copy)
665
666    def on_paste(self, event):
667        """
668        Paste Parameter values to the panel if possible
669        """
670        # if event is not None:
671        #    event.Skip()
672        # It seems MAC needs wxCallAfter for the setvalues
673        # for multiple textctrl items, otherwise it tends to crash once a while
674        wx.CallAfter(self.get_paste)
675        # messages depending on the flag
676        # self._copy_info(True)
677
678    def _copy_info(self, flag):
679        """
680        Send event depending on flag
681
682        : Param flag: flag that distinguishes the event
683        """
684        # messages depending on the flag
685        if flag is None:
686            msg = " Parameter values are copied to the clipboard..."
687            infor = 'warning'
688        elif flag:
689            msg = " Parameter values are pasted from the clipboard..."
690            infor = "warning"
691        else:
692            msg = "Error occurred: "
693            msg += "No valid parameter values to paste from the clipboard..."
694            infor = "warning"
695        # inform msg to wx
696        wx.PostEvent(self._manager.parent,
697                     StatusEvent(status=msg, info=infor))
698
699    def _get_time_stamp(self):
700        """
701        return time and date stings
702        """
703        # date and time
704        year, month, day, hour, minute, second, _, _, _ = time.localtime()
705        current_time = str(hour) + ":" + str(minute) + ":" + str(second)
706        current_date = str(month) + "/" + str(day) + "/" + str(year)
707        return current_time, current_date
708
709    def on_bookmark(self, event):
710        """
711        save history of the data and model
712        """
713        if self.model is None:
714            msg = "Can not bookmark; Please select Data and Model first..."
715            wx.MessageBox(msg, 'Info')
716            return
717        self.save_current_state()
718        new_state = self.state.clone()
719        # Add model state on context menu
720        self.number_saved_state += 1
721        current_time, current_date = self._get_time_stamp()
722        # name= self.model.name+"[%g]"%self.number_saved_state
723        name = "Fitting: %g]" % self.number_saved_state
724        name += self.model.__class__.__name__
725        name += "bookmarked at %s on %s" % (current_time, current_date)
726        self.saved_states[name] = new_state
727
728        # Add item in the context menu
729        msg = "Model saved at %s on %s" % (current_time, current_date)
730        # post help message for the selected model
731        msg += " Saved! right click on this page to retrieve this model"
732        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
733
734        self.popUpMenu.Append(self.ID_BOOKMARK, name, str(msg))
735        wx.EVT_MENU(self, self.ID_BOOKMARK, self.onResetModel)
736        wx.PostEvent(self._manager.parent,
737                     AppendBookmarkEvent(title=name,
738                                         hint=str(msg),
739                                         handler=self._back_to_bookmark))
740
741    def _back_to_bookmark(self, event):
742        """
743        Back to bookmark
744        """
745        self._manager.on_perspective(event)
746        self.onResetModel(event)
747        self._draw_model()
748
749    def onSetFocus(self, evt):
750        """
751        highlight the current textcrtl and hide the error text control shown
752        after fitting
753        """
754        return
755
756    def read_file(self, path):
757        """
758        Read two columns file
759
760        :param path: the path to the file to read
761
762        """
763        try:
764            if path is None:
765                status = " Selected Distribution was not loaded: %s" % path
766                wx.PostEvent(self._manager.parent,
767                             StatusEvent(status=status))
768                return None, None
769            input_f = open(path, 'r')
770            buff = input_f.read()
771            lines = buff.split('\n')
772            input_f.close()
773            angles = []
774            weights = []
775            for line in lines:
776                toks = line.split()
777                try:
778                    angle = float(toks[0])
779                    weight = float(toks[1])
780                    angles.append(angle)
781                    weights.append(weight)
782                except Exception:
783                    # Skip non-data lines
784                    logging.error(traceback.format_exc())
785            return numpy.array(angles), numpy.array(weights)
786        except:
787            raise
788
789    def createMemento(self):
790        """
791        return the current state of the page
792        """
793        return self.state.clone()
794
795    def save_current_state(self):
796        """
797        Store current state
798        """
799        # save model option
800        if self.model is not None:
801            self.disp_list = self.model.getDispParamList()
802            self.state.disp_list = copy.deepcopy(self.disp_list)
803            self.state.model = self.model.clone()
804
805            # model combobox: complex code because of mac's silent error
806            if self.structurebox is not None:
807                if self.structurebox.IsShown():
808                    self.state.structurecombobox = 'None'
809                    s_select = self.structurebox.GetSelection()
810                    if s_select > 0:
811                        self.state.structurecombobox = \
812                            self.structurebox.GetString(s_select)
813            if self.formfactorbox is not None:
814                f_select = self.formfactorbox.GetSelection()
815                if f_select > 0:
816                    self.state.formfactorcombobox = \
817                        self.formfactorbox.GetString(f_select)
818        if self.categorybox is not None:
819            cb_select = self.categorybox.GetSelection()
820            if cb_select > 0:
821                self.state.categorycombobox = \
822                    self.categorybox.GetString(cb_select)
823
824        self.state.enable2D = copy.deepcopy(self.enable2D)
825        self.state.values = copy.deepcopy(self.values)
826        self.state.weights = copy.deepcopy(self.weights)
827        # save data
828        self.state.data = copy.deepcopy(self.data)
829        self.state.qmax_x = self.qmax_x
830        self.state.qmin_x = self.qmin_x
831        self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
832        self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
833        self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
834        self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
835        self.state.dq_l = self.dq_l
836        self.state.dq_r = self.dq_r
837        if hasattr(self, "enable_disp"):
838            self.state.enable_disp = self.enable_disp.GetValue()
839            self.state.disable_disp = self.disable_disp.GetValue()
840
841        self.state.smearer = copy.deepcopy(self.current_smearer)
842        if hasattr(self, "enable_smearer"):
843            self.state.enable_smearer = \
844                                copy.deepcopy(self.enable_smearer.GetValue())
845            self.state.disable_smearer = \
846                                copy.deepcopy(self.disable_smearer.GetValue())
847
848        self.state.pinhole_smearer = \
849                                copy.deepcopy(self.pinhole_smearer.GetValue())
850        self.state.dx_percent = copy.deepcopy(self.dx_percent)
851        self.state.dxl = copy.deepcopy(self.dxl)
852        self.state.dxw = copy.deepcopy(self.dxw)
853        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
854
855        if len(self._disp_obj_dict) > 0:
856            for k, v in self._disp_obj_dict.iteritems():
857                self.state._disp_obj_dict[k] = v.type
858
859            self.state.values = copy.deepcopy(self.values)
860            self.state.weights = copy.deepcopy(self.weights)
861        # save plotting range
862        self._save_plotting_range()
863
864        self.state.orientation_params = []
865        self.state.orientation_params_disp = []
866        self.state.parameters = []
867        self.state.fittable_param = []
868        self.state.fixed_param = []
869        self.state.str_parameters = []
870
871        # save checkbutton state and txtcrtl values
872        self._copy_parameters_state(self.str_parameters,
873                                    self.state.str_parameters)
874        self._copy_parameters_state(self.orientation_params,
875                                     self.state.orientation_params)
876        self._copy_parameters_state(self.orientation_params_disp,
877                                    self.state.orientation_params_disp)
878
879        self._copy_parameters_state(self.parameters, self.state.parameters)
880        self._copy_parameters_state(self.fittable_param,
881                                    self.state.fittable_param)
882        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
883        # save chisqr
884        self.state.tcChi = self.tcChi.GetValue()
885
886    def save_current_state_fit(self):
887        """
888        Store current state for fit_page
889        """
890        # save model option
891        if self.model is not None:
892            self.disp_list = self.model.getDispParamList()
893            self.state.disp_list = copy.deepcopy(self.disp_list)
894            self.state.model = self.model.clone()
895
896        self.state.enable2D = copy.deepcopy(self.enable2D)
897        self.state.values = copy.deepcopy(self.values)
898        self.state.weights = copy.deepcopy(self.weights)
899        # save data
900        self.state.data = copy.deepcopy(self.data)
901
902        if hasattr(self, "enable_disp"):
903            self.state.enable_disp = self.enable_disp.GetValue()
904            self.state.disable_disp = self.disable_disp.GetValue()
905
906        self.state.smearer = copy.deepcopy(self.current_smearer)
907        if hasattr(self, "enable_smearer"):
908            self.state.enable_smearer = \
909                                copy.deepcopy(self.enable_smearer.GetValue())
910            self.state.disable_smearer = \
911                                copy.deepcopy(self.disable_smearer.GetValue())
912
913        self.state.pinhole_smearer = \
914                                copy.deepcopy(self.pinhole_smearer.GetValue())
915        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())
916        self.state.dI_noweight = copy.deepcopy(self.dI_noweight.GetValue())
917        self.state.dI_didata = copy.deepcopy(self.dI_didata.GetValue())
918        self.state.dI_sqrdata = copy.deepcopy(self.dI_sqrdata.GetValue())
919        self.state.dI_idata = copy.deepcopy(self.dI_idata.GetValue())
920        if hasattr(self, "disp_box") and self.disp_box is not None:
921            self.state.disp_box = self.disp_box.GetCurrentSelection()
922
923            if len(self.disp_cb_dict) > 0:
924                for k, v in self.disp_cb_dict.iteritems():
925                    if v is None:
926                        self.state.disp_cb_dict[k] = v
927                    else:
928                        try:
929                            self.state.disp_cb_dict[k] = v.GetValue()
930                        except:
931                            self.state.disp_cb_dict[k] = None
932            if len(self._disp_obj_dict) > 0:
933                for k, v in self._disp_obj_dict.iteritems():
934                    self.state._disp_obj_dict[k] = v.type
935
936            self.state.values = copy.deepcopy(self.values)
937            self.state.weights = copy.deepcopy(self.weights)
938
939        # save plotting range
940        self._save_plotting_range()
941
942        # save checkbutton state and txtcrtl values
943        self._copy_parameters_state(self.orientation_params,
944                                    self.state.orientation_params)
945        self._copy_parameters_state(self.orientation_params_disp,
946                                    self.state.orientation_params_disp)
947        self._copy_parameters_state(self.parameters, self.state.parameters)
948        self._copy_parameters_state(self.fittable_param,
949                                    self.state.fittable_param)
950        self._copy_parameters_state(self.fixed_param, self.state.fixed_param)
951
952    def check_invalid_panel(self):
953        """
954        check if the user can already perform some action with this panel
955        """
956        if self.data is None:
957            self.disable_smearer.SetValue(True)
958            self.disable_disp.SetValue(True)
959            msg = "Please load Data and select Model to start..."
960            wx.MessageBox(msg, 'Info')
961            return True
962
963    def set_model_state(self, state):
964        """
965        reset page given a model state
966        """
967        self.disp_cb_dict = state.disp_cb_dict
968        self.disp_list = state.disp_list
969
970        # fill model combobox
971        self._show_combox_helper()
972        # select the current model
973        try:
974            # to support older version
975            category_pos = int(state.categorycombobox)
976        except:
977            category_pos = 0
978            for ind_cat in range(self.categorybox.GetCount()):
979                if self.categorycombobox.GetString(ind_cat) == \
980                                        state.categorycombobox:
981                    category_pos = int(ind_cat)
982                    break
983
984        self.categorybox.Select(category_pos)
985        try:
986            # to support older version
987            formfactor_pos = int(state.formfactorcombobox)
988        except:
989            formfactor_pos = 0
990            for ind_form in range(self.formfactorbox.GetCount()):
991                if self.formfactorbox.GetString(ind_form) == \
992                                        state.formfactorcombobox:
993                    formfactor_pos = int(ind_form)
994                    break
995
996        self.formfactorbox.Select(formfactor_pos)
997
998        try:
999            # to support older version
1000            structfactor_pos = int(state.structurecombobox)
1001        except:
1002            structfactor_pos = 0
1003            for ind_struct in range(self.structurebox.GetCount()):
1004                if self.structurebox.GetString(ind_struct) == \
1005                                        state.structurecombobox:
1006                    structfactor_pos = int(ind_struct)
1007                    break
1008
1009        self.structurebox.SetSelection(structfactor_pos)
1010
1011        if state.multi_factor is not None:
1012            self.multifactorbox.SetSelection(state.multi_factor)
1013
1014        # reset state of checkbox,textcrtl  and  regular parameters value
1015        self._reset_parameters_state(self.orientation_params_disp,
1016                                     state.orientation_params_disp)
1017        self._reset_parameters_state(self.orientation_params,
1018                                     state.orientation_params)
1019        self._reset_parameters_state(self.str_parameters,
1020                                     state.str_parameters)
1021        self._reset_parameters_state(self.parameters, state.parameters)
1022        # display dispersion info layer
1023        self.enable_disp.SetValue(state.enable_disp)
1024        self.disable_disp.SetValue(state.disable_disp)
1025
1026        if hasattr(self, "disp_box") and self.disp_box is not None:
1027            self.disp_box.SetSelection(state.disp_box)
1028            n = self.disp_box.GetCurrentSelection()
1029            dispersity = self.disp_box.GetClientData(n)
1030            name = dispersity.__name__
1031            self._set_dipers_Param(event=None)
1032
1033            if name == "ArrayDispersion":
1034
1035                for item in self.disp_cb_dict.keys():
1036
1037                    if hasattr(self.disp_cb_dict[item], "SetValue"):
1038                        self.disp_cb_dict[item].SetValue(
1039                                                    state.disp_cb_dict[item])
1040                        # Create the dispersion objects
1041                        disp_model = POLYDISPERSITY_MODELS['array']()
1042                        if hasattr(state, "values") and \
1043                                 self.disp_cb_dict[item].GetValue():
1044                            if len(state.values) > 0:
1045                                self.values = state.values
1046                                self.weights = state.weights
1047                                disp_model.set_weights(self.values,
1048                                                       state.weights)
1049                            else:
1050                                self._reset_dispersity()
1051
1052                        self._disp_obj_dict[item] = disp_model
1053                        # Set the new model as the dispersion object
1054                        # for the selected parameter
1055                        self.model.set_dispersion(item, disp_model)
1056
1057                        self.model._persistency_dict[item] = \
1058                                                [state.values, state.weights]
1059
1060            else:
1061                keys = self.model.getParamList()
1062                for item in keys:
1063                    if item in self.disp_list and \
1064                            item not in self.model.details:
1065                        self.model.details[item] = ["", None, None]
1066                self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1067                self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1068        # smearing info  restore
1069        if hasattr(self, "enable_smearer"):
1070            # set smearing value whether or not the data
1071            # contain the smearing info
1072            self.enable_smearer.SetValue(state.enable_smearer)
1073            self.disable_smearer.SetValue(state.disable_smearer)
1074            self.onSmear(event=None)
1075        self.pinhole_smearer.SetValue(state.pinhole_smearer)
1076        self.slit_smearer.SetValue(state.slit_smearer)
1077
1078        self.dI_noweight.SetValue(state.dI_noweight)
1079        self.dI_didata.SetValue(state.dI_didata)
1080        self.dI_sqrdata.SetValue(state.dI_sqrdata)
1081        self.dI_idata.SetValue(state.dI_idata)
1082
1083        # we have two more options for smearing
1084        if self.pinhole_smearer.GetValue():
1085            self.onPinholeSmear(event=None)
1086        elif self.slit_smearer.GetValue():
1087            self.onSlitSmear(event=None)
1088
1089        # reset state of checkbox,textcrtl  and dispersity parameters value
1090        self._reset_parameters_state(self.fittable_param, state.fittable_param)
1091        self._reset_parameters_state(self.fixed_param, state.fixed_param)
1092
1093        # draw the model with previous parameters value
1094        self._onparamEnter_helper()
1095        self.select_param(event=None)
1096        # Save state_fit
1097        self.save_current_state_fit()
1098        self._lay_out()
1099        self.Refresh()
1100
1101    def get_cat_combo_box_pos(self, state):
1102        """
1103        Iterate through the categories to find the structurefactor
1104        :return: combo_box_position
1105        """
1106        for key, value in self.master_category_dict.iteritems():
1107            formfactor = state.formfactorcombobox.split(":")
1108            if isinstance(formfactor, list):
1109                formfactor = formfactor[0]
1110            for list_item in value:
1111                if formfactor in list_item:
1112                    return self.categorybox.Items.index(key)
1113        return 0
1114
1115    def reset_page_helper(self, state):
1116        """
1117        Use page_state and change the state of existing page
1118
1119        :precondition: the page is already drawn or created
1120
1121        :postcondition: the state of the underlying data changes as well as the
1122            state of the graphic interface
1123        """
1124        if state is None:
1125            return
1126        # set data, etc. from the state
1127        # reset page between theory and fitting from bookmarking
1128        data = state.data
1129
1130        if data is None:
1131            data_min = state.qmin
1132            data_max = state.qmax
1133            self.qmin_x = data_min
1134            self.qmax_x = data_max
1135            self.qmin.SetValue(str(data_min))
1136            self.qmax.SetValue(str(data_max))
1137
1138            self.state.data = data
1139            self.state.qmin = self.qmin_x
1140            self.state.qmax = self.qmax_x
1141        else:
1142            self.set_data(data)
1143
1144        self.enable2D = state.enable2D
1145        try:
1146            self.magnetic_on = state.magnetic_on
1147        except:
1148            # Backward compatibility (for older state files)
1149            self.magnetic_on = False
1150
1151        self.disp_cb_dict = state.disp_cb_dict
1152        self.disp_list = state.disp_list
1153
1154        # fill model combobox
1155        self._show_combox_helper()
1156        # select the current model
1157        state._convert_to_sasmodels()
1158        state.categorycombobox = unicode(state.categorycombobox)
1159        if state.categorycombobox in self.categorybox.Items:
1160            category_pos = self.categorybox.Items.index(
1161                state.categorycombobox)
1162        else:
1163            # Look in master list for model name (model.lower)
1164            category_pos = self.get_cat_combo_box_pos(state)
1165
1166        self.categorybox.Select(category_pos)
1167        self._show_combox(None)
1168        from models import PLUGIN_NAME_BASE
1169        if self.categorybox.GetValue() == CUSTOM_MODEL \
1170                and PLUGIN_NAME_BASE not in state.formfactorcombobox:
1171            state.formfactorcombobox = \
1172                PLUGIN_NAME_BASE + state.formfactorcombobox
1173        formfactor_pos = 0
1174        for ind_form in range(self.formfactorbox.GetCount()):
1175            if self.formfactorbox.GetString(ind_form) == \
1176                                                (state.formfactorcombobox):
1177                formfactor_pos = int(ind_form)
1178                break
1179
1180        self.formfactorbox.Select(formfactor_pos)
1181
1182        structfactor_pos = 0
1183        if state.structurecombobox is not None:
1184            state.structurecombobox = unicode(state.structurecombobox)
1185            for ind_struct in range(self.structurebox.GetCount()):
1186                if self.structurebox.GetString(ind_struct) == \
1187                                                (state.structurecombobox):
1188                    structfactor_pos = int(ind_struct)
1189                    break
1190
1191        self.structurebox.SetSelection(structfactor_pos)
1192
1193        if state.multi_factor is not None:
1194            self.multifactorbox.SetSelection(state.multi_factor)
1195
1196        # draw the panel according to the new model parameter
1197        self._on_select_model(event=None)
1198
1199        # take care of 2D button
1200        if data is None and self.model_view.IsEnabled():
1201            if self.enable2D:
1202                self.model_view.SetLabel("2D Mode")
1203            else:
1204                self.model_view.SetLabel("1D Mode")
1205
1206        # reset state of checkbox,textcrtl  and  regular parameters value
1207        self._reset_parameters_state(self.orientation_params_disp,
1208                                     state.orientation_params_disp)
1209        self._reset_parameters_state(self.orientation_params,
1210                                     state.orientation_params)
1211        self._reset_parameters_state(self.str_parameters,
1212                                     state.str_parameters)
1213        self._reset_parameters_state(self.parameters, state.parameters)
1214        # display dispersion info layer
1215        self.enable_disp.SetValue(state.enable_disp)
1216        self.disable_disp.SetValue(state.disable_disp)
1217        # If the polydispersion is ON
1218        if state.enable_disp:
1219            # reset dispersion according the state
1220            self._set_dipers_Param(event=None)
1221            self._reset_page_disp_helper(state)
1222        # plotting range restore
1223        self._reset_plotting_range(state)
1224        # smearing info  restore
1225        if hasattr(self, "enable_smearer"):
1226            # set smearing value whether or not the data
1227            # contain the smearing info
1228            self.enable_smearer.SetValue(state.enable_smearer)
1229            self.disable_smearer.SetValue(state.disable_smearer)
1230            self.onSmear(event=None)
1231        self.pinhole_smearer.SetValue(state.pinhole_smearer)
1232        self.slit_smearer.SetValue(state.slit_smearer)
1233        try:
1234            self.dI_noweight.SetValue(state.dI_noweight)
1235            self.dI_didata.SetValue(state.dI_didata)
1236            self.dI_sqrdata.SetValue(state.dI_sqrdata)
1237            self.dI_idata.SetValue(state.dI_idata)
1238        except:
1239            # to support older state file formats
1240            self.dI_noweight.SetValue(False)
1241            self.dI_didata.SetValue(True)
1242            self.dI_sqrdata.SetValue(False)
1243            self.dI_idata.SetValue(False)
1244
1245        # we have two more options for smearing
1246        if self.pinhole_smearer.GetValue():
1247            self.dx_percent = state.dx_percent
1248            if self.dx_percent is not None:
1249                self.smear_pinhole_percent.SetValue(str(self.dx_percent))
1250            self.onPinholeSmear(event=None)
1251        elif self.slit_smearer.GetValue():
1252            self.dxl = state.dxl
1253            self.dxw = state.dxw
1254            if self.dxl is not None:
1255                self.smear_slit_height.SetValue(str(self.dxl))
1256            if self.dxw is not None:
1257                self.smear_slit_width.SetValue(str(self.dxw))
1258            else:
1259                self.smear_slit_width.SetValue('')
1260            self.onSlitSmear(event=None)
1261
1262        # reset state of checkbox,textcrtl  and dispersity parameters value
1263        self._reset_parameters_state(self.fittable_param, state.fittable_param)
1264        self._reset_parameters_state(self.fixed_param, state.fixed_param)
1265
1266        # draw the model with previous parameters value
1267        self._onparamEnter_helper()
1268        # reset the value of chisqr when not consistent with the value computed
1269        self.tcChi.SetValue(str(self.state.tcChi))
1270        # reset context menu items
1271        self._reset_context_menu()
1272
1273        # set the value of the current state to the state given as parameter
1274        self.state = state.clone()
1275        self.state.m_name = self.m_name
1276
1277    def _reset_page_disp_helper(self, state):
1278        """
1279        Help to rest page for dispersions
1280        """
1281        keys = self.model.getParamList()
1282        for item in keys:
1283            if item in self.disp_list and \
1284                            item not in self.model.details:
1285                self.model.details[item] = ["", None, None]
1286        # for k,v in self.state.disp_cb_dict.iteritems():
1287        self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1288        self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1289        self.values = copy.deepcopy(state.values)
1290        self.weights = copy.deepcopy(state.weights)
1291
1292        for key, disp_type in state._disp_obj_dict.iteritems():
1293            # disp_model = disp
1294            disp_model = POLYDISPERSITY_MODELS[disp_type]()
1295            self._disp_obj_dict[key] = disp_model
1296            param_name = key.split('.')[0]
1297            # Try to set dispersion only when available
1298            # for eg., pass the orient. angles for 1D Cal
1299            try:
1300                self.model.set_dispersion(param_name, disp_model)
1301                self.model._persistency_dict[key] = \
1302                    [state.values, state.weights]
1303            except Exception:
1304                logging.error(traceback.format_exc())
1305            selection = self._find_polyfunc_selection(disp_model)
1306            for list in self.fittable_param:
1307                if list[1] == key and list[7] is not None:
1308                    list[7].SetSelection(selection)
1309                    # For the array disp_model, set the values and weights
1310                    if selection == 1:
1311                        disp_model.set_weights(self.values[key],
1312                                               self.weights[key])
1313                        try:
1314                            # Diables all fittable params for array
1315                            list[0].SetValue(False)
1316                            list[0].Disable()
1317                            list[2].Disable()
1318                            list[5].Disable()
1319                            list[6].Disable()
1320                        except Exception:
1321                            logging.error(traceback.format_exc())
1322            # For array, disable all fixed params
1323            if selection == 1:
1324                for item in self.fixed_param:
1325                    if item[1].split(".")[0] == key.split(".")[0]:
1326                        # try it and pass it for the orientation for 1D
1327                        try:
1328                            item[2].Disable()
1329                        except Exception:
1330                            logging.error(traceback.format_exc())
1331
1332    def _selectDlg(self):
1333        """
1334        open a dialog file to select the customized polydispersity function
1335        """
1336        if self.parent is not None:
1337            self._default_save_location = \
1338                        self._manager.parent.get_save_location()
1339        dlg = wx.FileDialog(self, "Choose a weight file",
1340                            self._default_save_location, "",
1341                            "*.*", wx.OPEN)
1342        path = None
1343        if dlg.ShowModal() == wx.ID_OK:
1344            path = dlg.GetPath()
1345        dlg.Destroy()
1346        return path
1347
1348    def _reset_context_menu(self):
1349        """
1350        reset the context menu
1351        """
1352        ids = iter(self._id_pool)  # Reusing ids for context menu
1353        for name, _ in self.state.saved_states.iteritems():
1354            self.number_saved_state += 1
1355            # Add item in the context menu
1356            wx_id = ids.next()
1357            msg = 'Save model and state %g' % self.number_saved_state
1358            self.popUpMenu.Append(wx_id, name, msg)
1359            wx.EVT_MENU(self, wx_id, self.onResetModel)
1360
1361    def _reset_plotting_range(self, state):
1362        """
1363        Reset the plotting range to a given state
1364        """
1365        self.qmin.SetValue(str(state.qmin))
1366        self.qmax.SetValue(str(state.qmax))
1367
1368    def _save_typeOfmodel(self):
1369        """
1370        save radiobutton containing the type model that can be selected
1371        """
1372        # self.state.shape_rbutton = self.shape_rbutton.GetValue()
1373        # self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
1374        # self.state.struct_rbutton = self.struct_rbutton.GetValue()
1375        # self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
1376        self.state.structurecombobox = self.structurebox.GetValue()
1377        self.state.formfactorcombobox = self.formfactorbox.GetValue()
1378        self.state.categorycombobox = self.categorybox.GetValue()
1379
1380        # post state to fit panel
1381        event = PageInfoEvent(page=self)
1382        wx.PostEvent(self.parent, event)
1383
1384    def _save_plotting_range(self):
1385        """
1386        save the state of plotting range
1387        """
1388        self.state.qmin = self.qmin_x
1389        self.state.qmax = self.qmax_x
1390        self.state.npts = self.npts_x
1391
1392    def _onparamEnter_helper(self, is_modified=False):
1393        """
1394        check if values entered by the user are changed and valid to replot
1395        model
1396        """
1397        # Flag to register when a parameter has changed.
1398        # is_modified = False
1399        self.fitrange = True
1400        is_2Ddata = False
1401        # self._undo.Enable(True)
1402        # check if 2d data
1403        if self.data.__class__.__name__ == "Data2D":
1404            is_2Ddata = True
1405        if self.model is not None:
1406            # Either we get a is_modified = True passed in because
1407            # _update_paramv_on_fit() has been called already or
1408            # we need to check here ourselves.
1409            if not is_modified:
1410                is_modified = (self._check_value_enter(self.fittable_param)
1411                               or self._check_value_enter(self.fixed_param)
1412                               or self._check_value_enter(self.parameters))
1413
1414            # Here we should check whether the boundaries have been modified.
1415            # If qmin and qmax have been modified, update qmin and qmax and
1416            # set the is_modified flag to True
1417            if self._validate_qrange(self.qmin, self.qmax):
1418                tempmin = float(self.qmin.GetValue())
1419                if tempmin != self.qmin_x:
1420                    self.qmin_x = tempmin
1421                    is_modified = True
1422                tempmax = float(self.qmax.GetValue())
1423                if tempmax != self.qmax_x:
1424                    self.qmax_x = tempmax
1425                    is_modified = True
1426                if is_2Ddata:
1427                    is_modified = self._validate_Npts()
1428                else:
1429                    is_modified = self._validate_Npts_1D()
1430            else:
1431                self.fitrange = False
1432
1433            # if any value is modify draw model with new value
1434            if not self.fitrange:
1435                # self.btFit.Disable()
1436                if is_2Ddata:
1437                    self.btEditMask.Disable()
1438            else:
1439                if is_2Ddata and self.data.is_data and not self.batch_on:
1440                    self.btEditMask.Enable(True)
1441            if is_modified and self.fitrange:
1442                # Theory case: need to get npts value to draw
1443                self.npts_x = float(self.Npts_total.GetValue())
1444                self.Npts_fit.SetValue(str(self.Npts_total.GetValue()))
1445                self._save_plotting_range()
1446                self.create_default_data()
1447                self.state_change = True
1448                self._draw_model()
1449                # Time delay has been introduced to prevent _handle error
1450                # on Windows
1451                # This part of code is executed when model is selected and
1452                # it's parameters are changed (with respect to previously
1453                # selected model). There are two Iq evaluations occuring one
1454                # after another and therefore there may be compilation error
1455                # if model is calculated for the first time.
1456                # This seems to be Windows only issue - haven't tested on Linux
1457                # though.The proper solution (other than time delay) requires
1458                # more fundemental code refatoring
1459                # Wojtek P. Nov 7, 2016
1460                if not ON_MAC:
1461                    time.sleep(0.1)
1462                self.Refresh()
1463
1464        # logging.info("is_modified flag set to %g",is_modified)
1465        return is_modified
1466
1467    def _update_paramv_on_fit(self):
1468        """
1469        make sure that update param values just before the fitting
1470        """
1471        # flag for qmin qmax check values
1472        flag = True
1473        self.fitrange = True
1474        is_modified = False
1475
1476        # wx.PostEvent(self._manager.parent, StatusEvent(status=" \
1477        # updating ... ",type="update"))
1478
1479        # So make sure that update param values on_Fit.
1480        # self._undo.Enable(True)
1481        if self.model is not None:
1482            if self.Npts_total.GetValue() != self.Npts_fit.GetValue():
1483                if not self.data.is_data:
1484                    self._manager.page_finder[self.uid].set_fit_data(
1485                        data=[self.data])
1486            # Check the values
1487            is_modified = (self._check_value_enter(self.fittable_param)
1488                           or self._check_value_enter(self.fixed_param)
1489                           or self._check_value_enter(self.parameters))
1490
1491            # If qmin and qmax have been modified, update qmin and qmax and
1492            # Here we should check whether the boundaries have been modified.
1493            # If qmin and qmax have been modified, update qmin and qmax and
1494            # set the is_modified flag to True
1495            self.fitrange = self._validate_qrange(self.qmin, self.qmax)
1496            if self.fitrange:
1497                tempmin = float(self.qmin.GetValue())
1498                if tempmin != self.qmin_x:
1499                    self.qmin_x = tempmin
1500                tempmax = float(self.qmax.GetValue())
1501                if tempmax != self.qmax_x:
1502                    self.qmax_x = tempmax
1503                if tempmax == tempmin:
1504                    flag = False
1505                temp_smearer = None
1506                if not self.disable_smearer.GetValue():
1507                    temp_smearer = self.current_smearer
1508                    if self.slit_smearer.GetValue():
1509                        flag = self.update_slit_smear()
1510                    elif self.pinhole_smearer.GetValue():
1511                        flag = self.update_pinhole_smear()
1512                    else:
1513                        enable_smearer = not self.disable_smearer.GetValue()
1514                        self._manager.set_smearer(smearer=temp_smearer,
1515                                                  uid=self.uid,
1516                                                  fid=self.data.id,
1517                                                  qmin=float(self.qmin_x),
1518                                                  qmax=float(self.qmax_x),
1519                                                  enable_smearer=enable_smearer,
1520                                                  draw=False)
1521                elif not self._is_2D():
1522                    enable_smearer = not self.disable_smearer.GetValue()
1523                    self._manager.set_smearer(smearer=temp_smearer,
1524                                              qmin=float(self.qmin_x),
1525                                              uid=self.uid,
1526                                              fid=self.data.id,
1527                                              qmax=float(self.qmax_x),
1528                                              enable_smearer=enable_smearer,
1529                                              draw=False)
1530                    if self.data is not None:
1531                        index_data = ((self.qmin_x <= self.data.x) &
1532                                      (self.data.x <= self.qmax_x))
1533                        val = str(len(self.data.x[index_data]))
1534                        self.Npts_fit.SetValue(val)
1535                    else:
1536                        # No data in the panel
1537                        try:
1538                            self.npts_x = float(self.Npts_total.GetValue())
1539                        except:
1540                            flag = False
1541                            return flag
1542                    flag = True
1543                if self._is_2D():
1544                    # only 2D case set mask
1545                    flag = self._validate_Npts()
1546                    if not flag:
1547                        return flag
1548            else:
1549                flag = False
1550        else:
1551            flag = False
1552
1553        # For invalid q range, disable the mask editor and fit button, vs.
1554        if not self.fitrange:
1555            if self._is_2D():
1556                self.btEditMask.Disable()
1557        else:
1558            if self._is_2D() and self.data.is_data and not self.batch_on:
1559                self.btEditMask.Enable(True)
1560
1561        if not flag:
1562            msg = "Cannot Plot or Fit :Must select a "
1563            msg += " model or Fitting range is not valid!!!  "
1564            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1565
1566        try:
1567            self.save_current_state()
1568        except Exception:
1569            logging.error(traceback.format_exc())
1570
1571        return flag, is_modified
1572
1573    def _reset_parameters_state(self, listtorestore, statelist):
1574        """
1575        Reset the parameters at the given state
1576        """
1577        if len(statelist) == 0 or len(listtorestore) == 0:
1578            return
1579
1580        for j in range(len(listtorestore)):
1581            for param in statelist:
1582                if param[1] == listtorestore[j][1]:
1583                    item_page = listtorestore[j]
1584                    item_page_info = param
1585                    if (item_page_info[1] == "theta" or item_page_info[1] ==
1586                            "phi") and not self._is_2D():
1587                        break
1588                    # change the state of the check box for simple parameters
1589                    if item_page[0] is not None:
1590                        item_page[0].SetValue(item_page_info[0])
1591                    if item_page[2] is not None:
1592                        item_page[2].SetValue(item_page_info[2])
1593                        if item_page[2].__class__.__name__ == "ComboBox":
1594                            if item_page_info[2] in self.model.fun_list:
1595                                fun_val = self.model.fun_list[item_page_info[2]]
1596                                self.model.setParam(item_page_info[1], fun_val)
1597                    if item_page[3] is not None:
1598                        # show or hide text +/-
1599                        if item_page_info[2]:
1600                            item_page[3].Show(True)
1601                        else:
1602                            item_page[3].Hide()
1603                    if item_page[4] is not None:
1604                        # show of hide the text crtl for fitting error
1605                        if item_page_info[4][0]:
1606                            item_page[4].Show(True)
1607                            item_page[4].SetValue(str(item_page_info[4][1]))
1608                        else:
1609                            item_page[3].Hide()
1610                    if item_page[5] is not None:
1611                        # show of hide the text crtl for fitting error
1612                        item_page[5].Show(True)
1613                        item_page[5].SetValue(str(item_page_info[5][1]))
1614                    if item_page[6] is not None:
1615                        # show of hide the text crtl for fitting error
1616                        item_page[6].Show(True)
1617                        item_page[6].SetValue(str(item_page_info[6][1]))
1618                    break
1619
1620    def _reset_strparam_state(self, listtorestore, statelist):
1621        """
1622        Reset the string parameters at the given state
1623        """
1624        if len(statelist) == 0:
1625            return
1626
1627        listtorestore = copy.deepcopy(statelist)
1628
1629        for j in range(len(listtorestore)):
1630            item_page = listtorestore[j]
1631            item_page_info = statelist[j]
1632            # change the state of the check box for simple parameters
1633
1634            if item_page[0] is not None:
1635                item_page[0].SetValue(format_number(item_page_info[0], True))
1636
1637            if item_page[2] is not None:
1638                param_name = item_page_info[1]
1639                value = item_page_info[2]
1640                selection = value
1641                if value in self.model.fun_list:
1642                    selection = self.model.fun_list[value]
1643                item_page[2].SetValue(selection)
1644                self.model.setParam(param_name, selection)
1645
1646    def _copy_parameters_state(self, listtocopy, statelist):
1647        """
1648        copy the state of button
1649
1650        :param listtocopy: the list of check button to copy
1651        :param statelist: list of state object to store the current state
1652
1653        """
1654        if len(listtocopy) == 0:
1655            return
1656
1657        for item in listtocopy:
1658
1659            checkbox_state = None
1660            if item[0] is not None:
1661                checkbox_state = item[0].GetValue()
1662            parameter_name = item[1]
1663            parameter_value = None
1664            if item[2] is not None:
1665                parameter_value = item[2].GetValue()
1666            static_text = None
1667            if item[3] is not None:
1668                static_text = item[3].IsShown()
1669            error_value = None
1670            error_state = None
1671            if item[4] is not None:
1672                error_value = item[4].GetValue()
1673                error_state = item[4].IsShown()
1674
1675            min_value = None
1676            min_state = None
1677            if item[5] is not None:
1678                min_value = item[5].GetValue()
1679                min_state = item[5].IsShown()
1680
1681            max_value = None
1682            max_state = None
1683            if item[6] is not None:
1684                max_value = item[6].GetValue()
1685                max_state = item[6].IsShown()
1686            unit = None
1687            if item[7] is not None:
1688                unit = item[7].GetLabel()
1689
1690            statelist.append([checkbox_state, parameter_name, parameter_value,
1691                              static_text, [error_state, error_value],
1692                              [min_state, min_value],
1693                              [max_state, max_value], unit])
1694
1695    def _draw_model(self, update_chisqr=True, source='model'):
1696        """
1697        Method to draw or refresh a plotted model.
1698        The method will use the data member from the model page
1699        to build a call to the fitting perspective manager.
1700
1701        :param chisqr: update chisqr value [bool]
1702        """
1703        wx.CallAfter(self._draw_model_after, update_chisqr, source)
1704
1705    def _draw_model_after(self, update_chisqr=True, source='model'):
1706        """
1707        Method to draw or refresh a plotted model.
1708        The method will use the data member from the model page
1709        to build a call to the fitting perspective manager.
1710
1711        :param chisqr: update chisqr value [bool]
1712        """
1713        # if self.check_invalid_panel():
1714        #    return
1715        if self.model is not None:
1716            temp_smear = None
1717            if hasattr(self, "enable_smearer"):
1718                if not self.disable_smearer.GetValue():
1719                    temp_smear = self.current_smearer
1720            # compute weight for the current data
1721            from sas.sasgui.perspectives.fitting.utils import get_weight
1722            flag = self.get_weight_flag()
1723            weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
1724            toggle_mode_on = self.model_view.IsEnabled()
1725            is_2d = self._is_2D()
1726            self._manager.draw_model(self.model,
1727                                     data=self.data,
1728                                     smearer=temp_smear,
1729                                     qmin=float(self.qmin_x),
1730                                     qmax=float(self.qmax_x),
1731                                     page_id=self.uid,
1732                                     toggle_mode_on=toggle_mode_on,
1733                                     state=self.state,
1734                                     enable2D=is_2d,
1735                                     update_chisqr=update_chisqr,
1736                                     source='model',
1737                                     weight=weight)
1738
1739    def _on_show_sld(self, event=None):
1740        """
1741        Plot SLD profile
1742        """
1743        # get profile data
1744        x, y = self.model.getProfile()
1745
1746        from sas.sasgui.plottools import Data1D as pf_data1d
1747        # from sas.sasgui.perspectives.theory.profile_dialog import SLDPanel
1748        from sas.sasgui.guiframe.local_perspectives.plotting.profile_dialog \
1749            import SLDPanel
1750        sld_data = pf_data1d(x, y)
1751        sld_data.name = 'SLD'
1752        sld_data.axes = self.sld_axes
1753        self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes,
1754                              id=wx.ID_ANY)
1755        self.panel.ShowModal()
1756
1757    def _set_multfactor_combobox(self, multiplicity=10):
1758        """
1759        Set comboBox for multitfactor of CoreMultiShellModel
1760        :param multiplicit: no. of multi-functionality
1761        """
1762        # build content of the combobox
1763        for idx in range(0, multiplicity):
1764            self.multifactorbox.Append(str(idx), int(idx))
1765        self._hide_multfactor_combobox()
1766
1767    def _show_multfactor_combobox(self):
1768        """
1769        Show the comboBox of muitfactor of CoreMultiShellModel
1770        """
1771        if not self.mutifactor_text.IsShown():
1772            self.mutifactor_text.Show(True)
1773            self.mutifactor_text1.Show(True)
1774        if not self.multifactorbox.IsShown():
1775            self.multifactorbox.Show(True)
1776
1777    def _hide_multfactor_combobox(self):
1778        """
1779        Hide the comboBox of muitfactor of CoreMultiShellModel
1780        """
1781        if self.mutifactor_text.IsShown():
1782            self.mutifactor_text.Hide()
1783            self.mutifactor_text1.Hide()
1784        if self.multifactorbox.IsShown():
1785            self.multifactorbox.Hide()
1786
1787    def formfactor_combo_init(self):
1788        """
1789        First time calls _show_combox_helper
1790        """
1791        self._show_combox(None)
1792
1793    def _show_combox_helper(self):
1794        """
1795        Fill panel's combo box according to the type of model selected
1796        """
1797
1798        mod_cat = self.categorybox.GetStringSelection()
1799        self.structurebox.SetSelection(0)
1800        self.structurebox.Disable()
1801        self.formfactorbox.Clear()
1802        if mod_cat is None:
1803            return
1804        m_list = []
1805        try:
1806            if mod_cat == CUSTOM_MODEL:
1807                for model in self.model_list_box[mod_cat]:
1808                    m_list.append(self.model_dict[model.name])
1809            else:
1810                cat_dic = self.master_category_dict[mod_cat]
1811                for (model, enabled) in cat_dic:
1812                    if enabled:
1813                        m_list.append(self.model_dict[model])
1814        except Exception:
1815            msg = traceback.format_exc()
1816            wx.PostEvent(self._manager.parent,
1817                         StatusEvent(status=msg, info="error"))
1818        self._populate_box(self.formfactorbox, m_list)
1819
1820    def _on_modify_cat(self, event=None):
1821        """
1822        Called when category manager is opened
1823        """
1824        self._manager.parent.on_category_panel(event)
1825
1826    def _show_combox(self, event=None):
1827        """
1828        Show combox box associate with type of model selected
1829        """
1830        self.Show(False)
1831        self._show_combox_helper()
1832        self._on_select_model(event=None)
1833        self.Show(True)
1834        self._save_typeOfmodel()
1835        self.sizer4_4.Layout()
1836        self.sizer4.Layout()
1837        self.Layout()
1838        self.Refresh()
1839
1840    def _populate_box(self, combobox, list):
1841        """
1842        fill combox box with dict item
1843
1844        :param list: contains item to fill the combox
1845            item must model class
1846        """
1847        mlist = []
1848        for models in list:
1849            if models.name != "NoStructure":
1850                mlist.append((models.name, models))
1851
1852        # Sort the models
1853        mlist_sorted = sorted(mlist)
1854        for item in mlist_sorted:
1855            combobox.Append(item[0], item[1])
1856        return 0
1857
1858    def _onQrangeEnter(self, event):
1859        """
1860        Check validity of value enter in the Q range field
1861
1862        """
1863        tcrtl = event.GetEventObject()
1864        # Clear msg if previously shown.
1865        msg = ""
1866        wx.PostEvent(self.parent, StatusEvent(status=msg))
1867        # Flag to register when a parameter has changed.
1868        if tcrtl.GetValue().lstrip().rstrip() != "":
1869            try:
1870                float(tcrtl.GetValue())
1871                tcrtl.SetBackgroundColour(wx.WHITE)
1872                # If qmin and qmax have been modified, update qmin and qmax
1873                if self._validate_qrange(self.qmin, self.qmax):
1874                    tempmin = float(self.qmin.GetValue())
1875                    if tempmin != self.qmin_x:
1876                        self.qmin_x = tempmin
1877                    tempmax = float(self.qmax.GetValue())
1878                    if tempmax != self.qmax_x:
1879                        self.qmax_x = tempmax
1880                else:
1881                    tcrtl.SetBackgroundColour("pink")
1882                    msg = "Model Error: wrong value entered: %s" % \
1883                          sys.exc_info()[1]
1884                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1885                    return
1886            except:
1887                tcrtl.SetBackgroundColour("pink")
1888                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1889                wx.PostEvent(self.parent, StatusEvent(status=msg))
1890                return
1891            # Check if # of points for theory model are valid(>0).
1892            if self.npts is not None:
1893                if check_float(self.npts):
1894                    temp_npts = float(self.npts.GetValue())
1895                    if temp_npts != self.num_points:
1896                        self.num_points = temp_npts
1897                else:
1898                    msg = "Cannot plot: No points in Q range!!!  "
1899                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1900        else:
1901            tcrtl.SetBackgroundColour("pink")
1902            msg = "Model Error: wrong value entered!!!"
1903            wx.PostEvent(self.parent, StatusEvent(status=msg))
1904        self.save_current_state()
1905        event = PageInfoEvent(page=self)
1906        wx.PostEvent(self.parent, event)
1907        self.state_change = False
1908        # Draw the model for a different range
1909        if not self.data.is_data:
1910            self.create_default_data()
1911        self._draw_model()
1912
1913    def _theory_qrange_enter(self, event):
1914        """
1915        Check validity of value enter in the Q range field
1916        """
1917
1918        tcrtl = event.GetEventObject()
1919        # Clear msg if previously shown.
1920        msg = ""
1921        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1922        # Flag to register when a parameter has changed.
1923        is_modified = False
1924        if tcrtl.GetValue().lstrip().rstrip() != "":
1925            try:
1926                value = float(tcrtl.GetValue())
1927                tcrtl.SetBackgroundColour(wx.WHITE)
1928
1929                # If qmin and qmax have been modified, update qmin and qmax
1930                if self._validate_qrange(self.theory_qmin, self.theory_qmax):
1931                    tempmin = float(self.theory_qmin.GetValue())
1932                    if tempmin != self.theory_qmin_x:
1933                        self.theory_qmin_x = tempmin
1934                    tempmax = float(self.theory_qmax.GetValue())
1935                    if tempmax != self.qmax_x:
1936                        self.theory_qmax_x = tempmax
1937                else:
1938                    tcrtl.SetBackgroundColour("pink")
1939                    msg = "Model Error: wrong value entered: %s" % \
1940                          sys.exc_info()[1]
1941                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1942                    return
1943            except:
1944                tcrtl.SetBackgroundColour("pink")
1945                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1946                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1947                return
1948            # Check if # of points for theory model are valid(>0).
1949            if self.Npts_total.IsEditable():
1950                if check_float(self.Npts_total):
1951                    temp_npts = float(self.Npts_total.GetValue())
1952                    if temp_npts != self.num_points:
1953                        self.num_points = temp_npts
1954                        is_modified = True
1955                else:
1956                    msg = "Cannot Plot: No points in Q range!!!  "
1957                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1958        else:
1959            tcrtl.SetBackgroundColour("pink")
1960            msg = "Model Error: wrong value entered!!!"
1961            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1962        self.save_current_state()
1963        event = PageInfoEvent(page=self)
1964        wx.PostEvent(self.parent, event)
1965        self.state_change = False
1966        # Draw the model for a different range
1967        self.create_default_data()
1968        self._draw_model()
1969
1970    def _on_select_model_helper(self):
1971        """
1972        call back for model selection
1973        """
1974        # reset dictionary containing reference to dispersion
1975        self._disp_obj_dict = {}
1976        self.disp_cb_dict = {}
1977        self.temp_multi_functional = False
1978        f_id = self.formfactorbox.GetCurrentSelection()
1979        # For MAC
1980        form_factor = None
1981        if f_id >= 0:
1982            form_factor = self.formfactorbox.GetClientData(f_id)
1983
1984        if form_factor is None or \
1985            not hasattr(form_factor, 'is_form_factor') or \
1986                not form_factor.is_form_factor:
1987            self.structurebox.Hide()
1988            self.text2.Hide()
1989            self.structurebox.Disable()
1990            self.structurebox.SetSelection(0)
1991            self.text2.Disable()
1992        else:
1993            self.structurebox.Show()
1994            self.text2.Show()
1995            self.structurebox.Enable()
1996            self.text2.Enable()
1997
1998        if form_factor is not None:
1999            # set multifactor for Mutifunctional models
2000            if form_factor.is_multiplicity_model:
2001                m_id = self.multifactorbox.GetCurrentSelection()
2002                multiplicity = form_factor.multiplicity_info[0]
2003                self.multifactorbox.Clear()
2004                self._set_multfactor_combobox(multiplicity)
2005                self._show_multfactor_combobox()
2006                # ToDo: this info should be called directly from the model
2007                text = form_factor.multiplicity_info[1]  # 'No. of Shells: '
2008
2009                self.mutifactor_text.SetLabel(text)
2010                if m_id > multiplicity - 1:
2011                    # default value
2012                    m_id = 1
2013
2014                self.multi_factor = self.multifactorbox.GetClientData(m_id)
2015                if self.multi_factor is None:
2016                    self.multi_factor = 0
2017                self.multifactorbox.SetSelection(m_id)
2018                # Check len of the text1 and max_multiplicity
2019                text = ''
2020                if form_factor.multiplicity_info[0] == \
2021                        len(form_factor.multiplicity_info[2]):
2022                    text = form_factor.multiplicity_info[2][self.multi_factor]
2023                self.mutifactor_text1.SetLabel(text)
2024                # Check if model has  get sld profile.
2025                if len(form_factor.multiplicity_info[3]) > 0:
2026                    self.sld_axes = form_factor.multiplicity_info[3]
2027                    self.show_sld_button.Show(True)
2028                else:
2029                    self.sld_axes = ""
2030            else:
2031                self._hide_multfactor_combobox()
2032                self.show_sld_button.Hide()
2033                self.multi_factor = None
2034        else:
2035            self._hide_multfactor_combobox()
2036            self.show_sld_button.Hide()
2037            self.multi_factor = None
2038
2039        s_id = self.structurebox.GetCurrentSelection()
2040        struct_factor = self.structurebox.GetClientData(s_id)
2041
2042        if struct_factor is not None:
2043            from sasmodels.sasview_model import MultiplicationModel
2044            self.model = MultiplicationModel(form_factor(self.multi_factor),
2045                                             struct_factor())
2046            # multifunctional form factor
2047            if len(form_factor.non_fittable) > 0:
2048                self.temp_multi_functional = True
2049        elif form_factor is not None:
2050            if self.multi_factor is not None:
2051                self.model = form_factor(self.multi_factor)
2052            else:
2053                # old style plugin models do not accept a multiplicity argument
2054                self.model = form_factor()
2055        else:
2056            self.model = None
2057            return
2058
2059        # check if model has magnetic parameters
2060        if len(self.model.magnetic_params) > 0:
2061            self._has_magnetic = True
2062        else:
2063            self._has_magnetic = False
2064        # post state to fit panel
2065        self.state.parameters = []
2066        self.state.model = self.model
2067        self.state.qmin = self.qmin_x
2068        self.state.multi_factor = self.multi_factor
2069        self.disp_list = self.model.getDispParamList()
2070        self.state.disp_list = self.disp_list
2071        self.on_set_focus(None)
2072        self.Layout()
2073
2074    def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2075        """
2076        Verify that the Q range controls have valid values
2077        and that Qmin < Qmax.
2078
2079        :param qmin_ctrl: text control for Qmin
2080        :param qmax_ctrl: text control for Qmax
2081
2082        :return: True is the Q range is value, False otherwise
2083
2084        """
2085        qmin_validity = check_float(qmin_ctrl)
2086        qmax_validity = check_float(qmax_ctrl)
2087        if not (qmin_validity and qmax_validity):
2088            return False
2089        else:
2090            qmin = float(qmin_ctrl.GetValue())
2091            qmax = float(qmax_ctrl.GetValue())
2092            if qmin < qmax:
2093                # Make sure to set both colours white.
2094                qmin_ctrl.SetBackgroundColour(wx.WHITE)
2095                qmin_ctrl.Refresh()
2096                qmax_ctrl.SetBackgroundColour(wx.WHITE)
2097                qmax_ctrl.Refresh()
2098            else:
2099                qmin_ctrl.SetBackgroundColour("pink")
2100                qmin_ctrl.Refresh()
2101                qmax_ctrl.SetBackgroundColour("pink")
2102                qmax_ctrl.Refresh()
2103                msg = "Invalid Q range: Q min must be smaller than Q max"
2104                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2105                return False
2106        return True
2107
2108    def _validate_Npts(self):
2109        """
2110        Validate the number of points for fitting is more than 10 points.
2111        If valid, setvalues Npts_fit otherwise post msg.
2112        """
2113        # default flag
2114        flag = True
2115        # Theory
2116        if self.data is None and self.enable2D:
2117            return flag
2118        for data in self.data_list:
2119            # q value from qx and qy
2120            radius = numpy.sqrt(data.qx_data * data.qx_data +
2121                                data.qy_data * data.qy_data)
2122            # get unmasked index
2123            index_data = (float(self.qmin.GetValue()) <= radius) & \
2124                         (radius <= float(self.qmax.GetValue()))
2125            index_data = (index_data) & (data.mask)
2126            index_data = (index_data) & (numpy.isfinite(data.data))
2127
2128            if len(index_data[index_data]) < 10:
2129                # change the color pink.
2130                self.qmin.SetBackgroundColour("pink")
2131                self.qmin.Refresh()
2132                self.qmax.SetBackgroundColour("pink")
2133                self.qmax.Refresh()
2134                msg = "Data Error: "
2135                msg += "Too few points in %s." % data.name
2136                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2137                self.fitrange = False
2138                flag = False
2139            else:
2140                self.Npts_fit.SetValue(str(len(index_data[index_data])))
2141                self.fitrange = True
2142
2143        return flag
2144
2145    def _validate_Npts_1D(self):
2146        """
2147        Validate the number of points for fitting is more than 5 points.
2148        If valid, setvalues Npts_fit otherwise post msg.
2149        """
2150        # default flag
2151        flag = True
2152        # Theory
2153        if self.data is None:
2154            return flag
2155        for data in self.data_list:
2156            # q value from qx and qy
2157            radius = data.x
2158            # get unmasked index
2159            index_data = (float(self.qmin.GetValue()) <= radius) & \
2160                         (radius <= float(self.qmax.GetValue()))
2161            index_data = (index_data) & (numpy.isfinite(data.y))
2162
2163            if len(index_data[index_data]) < 5:
2164                # change the color pink.
2165                self.qmin.SetBackgroundColour("pink")
2166                self.qmin.Refresh()
2167                self.qmax.SetBackgroundColour("pink")
2168                self.qmax.Refresh()
2169                msg = "Data Error: "
2170                msg += "Too few points in %s." % data.name
2171                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2172                self.fitrange = False
2173                flag = False
2174            else:
2175                self.Npts_fit.SetValue(str(len(index_data[index_data])))
2176                self.fitrange = True
2177
2178        return flag
2179
2180    def _check_value_enter(self, list):
2181        """
2182        :param list: model parameter and panel info
2183        :Note: each item of the list should be as follow:
2184            item=[check button state, parameter's name,
2185                paramater's value, string="+/-",
2186                parameter's error of fit,
2187                parameter's minimum value,
2188                parameter's maximum value ,
2189                parameter's units]
2190
2191        Returns True if the model parameters have changed.
2192        """
2193        is_modified = False
2194        for item in list:
2195            # skip angle parameters for 1D
2196            if not self.enable2D and item in self.orientation_params:
2197                continue
2198
2199            value_ctrl = item[2]
2200            if not value_ctrl.IsEnabled():
2201                # ArrayDispersion disables PD, Min, Max, Npts, Nsigs
2202                continue
2203
2204            name = item[1]
2205            value_str = value_ctrl.GetValue().strip()
2206            if name.endswith(".npts"):
2207                validity = check_int(value_ctrl)
2208                if not validity:
2209                    continue
2210                value = int(value_str)
2211
2212            elif name.endswith(".nsigmas"):
2213                validity = check_float(value_ctrl)
2214                if not validity:
2215                    continue
2216                value = float(value_str)
2217
2218            else:  # value or polydispersity
2219
2220                # Check that min, max and value are floats
2221                min_ctrl, max_ctrl = item[5], item[6]
2222                min_str = min_ctrl.GetValue().strip()
2223                max_str = max_ctrl.GetValue().strip()
2224                validity = check_float(value_ctrl)
2225                if min_str != "":
2226                    validity = validity and check_float(min_ctrl)
2227                if max_str != "":
2228                    validity = validity and check_float(max_ctrl)
2229                if not validity:
2230                    continue
2231
2232                # Check that min is less than max
2233                low = -numpy.inf if min_str == "" else float(min_str)
2234                high = numpy.inf if max_str == "" else float(max_str)
2235                if high < low:
2236                    min_ctrl.SetBackgroundColour("pink")
2237                    min_ctrl.Refresh()
2238                    max_ctrl.SetBackgroundColour("pink")
2239                    max_ctrl.Refresh()
2240                    # msg = "Invalid fit range for %s: min must be smaller
2241                    # than max"%name
2242                    # wx.PostEvent(self._manager.parent,
2243                    # StatusEvent(status=msg))
2244                    continue
2245
2246                # Force value between min and max
2247                value = float(value_str)
2248                if value < low:
2249                    value = low
2250                    value_ctrl.SetValue(format_number(value))
2251                elif value > high:
2252                    value = high
2253                    value_ctrl.SetValue(format_number(value))
2254
2255                if name not in self.model.details.keys():
2256                    self.model.details[name] = ["", None, None]
2257                old_low, old_high = self.model.details[name][1:3]
2258                if old_low != low or old_high != high:
2259                    # The configuration has changed but it won't change the
2260                    # computed curve so no need to set is_modified to True
2261                    # is_modified = True
2262                    self.model.details[name][1:3] = low, high
2263
2264            # Update value in model if it has changed
2265            if value != self.model.getParam(name):
2266                self.model.setParam(name, value)
2267                is_modified = True
2268
2269        return is_modified
2270
2271    def _set_dipers_Param(self, event):
2272        """
2273        respond to self.enable_disp and self.disable_disp radio box.
2274        The dispersity object is reset inside the model into Gaussian.
2275        When the user select yes , this method display a combo box for
2276        more selection when the user selects No,the combo box disappears.
2277        Redraw the model with the default dispersity (Gaussian)
2278        """
2279        # On selction if no model exists.
2280        if self.model is None:
2281            self.disable_disp.SetValue(True)
2282            msg = "Please select a Model first..."
2283            wx.MessageBox(msg, 'Info')
2284            wx.PostEvent(self._manager.parent,
2285                         StatusEvent(status="Polydispersion: %s" % msg))
2286            return
2287
2288        self._reset_dispersity()
2289
2290        if self.model is None:
2291            self.model_disp.Hide()
2292            self.sizer4_4.Clear(True)
2293            return
2294
2295        if self.enable_disp.GetValue():
2296            # layout for model containing no dispersity parameters
2297
2298            self.disp_list = self.model.getDispParamList()
2299
2300            if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0:
2301                self._layout_sizer_noDipers()
2302            else:
2303                # set gaussian sizer
2304                self._on_select_Disp(event=None)
2305        else:
2306            self.sizer4_4.Clear(True)
2307
2308        # post state to fit panel
2309        self.save_current_state()
2310        if event is not None:
2311            event = PageInfoEvent(page=self)
2312            wx.PostEvent(self.parent, event)
2313        # draw the model with the current dispersity
2314
2315        # Wojtek P, Oct 8, 2016: Calling draw_model seems to be unessecary.
2316        # By comenting it we save an extra Iq calculation
2317        # self._draw_model()
2318
2319        # Need to use FitInside again here to replace the next four lines.
2320        # Otherwised polydispersity off does not resize the scrollwindow.
2321        # PDB Nov 28, 2015
2322        self.FitInside()
2323#        self.sizer4_4.Layout()
2324#        self.sizer5.Layout()
2325#        self.Layout()
2326#        self.Refresh()
2327
2328    def _layout_sizer_noDipers(self):
2329        """
2330        Draw a sizer with no dispersity info
2331        """
2332        ix = 0
2333        iy = 1
2334        self.fittable_param = []
2335        self.fixed_param = []
2336        self.orientation_params_disp = []
2337
2338        self.sizer4_4.Clear(True)
2339        text = "No polydispersity available for this model"
2340        model_disp = wx.StaticText(self, wx.ID_ANY, text)
2341        self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
2342                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 10)
2343        self.sizer4_4.Layout()
2344        self.sizer4.Layout()
2345
2346    def _reset_dispersity(self):
2347        """
2348        put gaussian dispersity into current model
2349        """
2350        if len(self.param_toFit) > 0:
2351            for item in self.fittable_param:
2352                if item in self.param_toFit:
2353                    self.param_toFit.remove(item)
2354
2355            for item in self.orientation_params_disp:
2356                if item in self.param_toFit:
2357                    self.param_toFit.remove(item)
2358
2359        self.fittable_param = []
2360        self.fixed_param = []
2361        self.orientation_params_disp = []
2362        self.values = {}
2363        self.weights = {}
2364
2365        # from sas.models.dispersion_models import GaussianDispersion
2366        from sasmodels.weights import GaussianDispersion
2367        if len(self.disp_cb_dict) == 0:
2368            self.save_current_state()
2369            self.sizer4_4.Clear(True)
2370            self.Layout()
2371            return
2372        if (len(self.disp_cb_dict) > 0):
2373            for p in self.disp_cb_dict:
2374                # The parameter was un-selected.
2375                # Go back to Gaussian model (with 0 pts)
2376                disp_model = GaussianDispersion()
2377
2378                self._disp_obj_dict[p] = disp_model
2379                # Set the new model as the dispersion object
2380                # for the selected parameter
2381                try:
2382                    self.model.set_dispersion(p, disp_model)
2383                except Exception:
2384                    logging.error(traceback.format_exc())
2385
2386        # save state into
2387        self.save_current_state()
2388        self.Layout()
2389        self.Refresh()
2390
2391    def _on_select_Disp(self, event):
2392        """
2393        allow selecting different dispersion
2394        self.disp_list should change type later .now only gaussian
2395        """
2396        self._set_sizer_dispersion()
2397
2398        # Redraw the model
2399        #  Wojtek P. Nov 7, 2016: Redrawing seems to be unnecessary here
2400        # self._draw_model()
2401        # self._undo.Enable(True)
2402        event = PageInfoEvent(page=self)
2403        wx.PostEvent(self.parent, event)
2404
2405        self.sizer4_4.Layout()
2406        self.sizer4.Layout()
2407        self.SetupScrolling()
2408
2409    def _on_disp_func(self, event=None):
2410        """
2411        Select a distribution function for the polydispersion
2412
2413        :Param event: ComboBox event
2414        """
2415        # get ready for new event
2416        if event is not None:
2417            event.Skip()
2418        # Get event object
2419        disp_box = event.GetEventObject()
2420
2421        # Try to select a Distr. function
2422        try:
2423            disp_box.SetBackgroundColour("white")
2424            selection = disp_box.GetCurrentSelection()
2425            param_name = disp_box.Name.split('.')[0]
2426            disp_name = disp_box.GetValue()
2427            dispersity = disp_box.GetClientData(selection)
2428
2429            # disp_model =  GaussianDispersion()
2430            disp_model = dispersity()
2431            # Get param names to reset the values of the param
2432            name1 = param_name + ".width"
2433            name2 = param_name + ".npts"
2434            name3 = param_name + ".nsigmas"
2435            # Check Disp. function whether or not it is 'array'
2436            if disp_name.lower() == "array":
2437                value2 = ""
2438                value3 = ""
2439                value1 = self._set_array_disp(name=name1, disp=disp_model)
2440            else:
2441                self._del_array_values(name1)
2442                # self._reset_array_disp(param_name)
2443                self._disp_obj_dict[name1] = disp_model
2444                self.model.set_dispersion(param_name, disp_model)
2445                self.state._disp_obj_dict[name1] = disp_model.type
2446
2447                value1 = str(format_number(self.model.getParam(name1), True))
2448                value2 = str(format_number(self.model.getParam(name2)))
2449                value3 = str(format_number(self.model.getParam(name3)))
2450            # Reset fittable polydispersin parameter value
2451            for item in self.fittable_param:
2452                if item[1] == name1:
2453                    item[2].SetValue(value1)
2454                    item[5].SetValue("")
2455                    item[6].SetValue("")
2456                    # Disable for array
2457                    if disp_name.lower() == "array":
2458                        item[0].SetValue(False)
2459                        item[0].Disable()
2460                        item[2].Disable()
2461                        item[3].Show(False)
2462                        item[4].Show(False)
2463                        item[5].Disable()
2464                        item[6].Disable()
2465                    else:
2466                        item[0].Enable()
2467                        item[2].Enable()
2468                        item[3].Show(True)
2469                        item[4].Show(True)
2470                        item[5].Enable()
2471                        item[6].Enable()
2472                    break
2473            # Reset fixed polydispersion params
2474            for item in self.fixed_param:
2475                if item[1] == name2:
2476                    item[2].SetValue(value2)
2477                    # Disable Npts for array
2478                    if disp_name.lower() == "array":
2479                        item[2].Disable()
2480                    else:
2481                        item[2].Enable()
2482                if item[1] == name3:
2483                    item[2].SetValue(value3)
2484                    # Disable Nsigs for array
2485                    if disp_name.lower() == "array":
2486                        item[2].Disable()
2487                    else:
2488                        item[2].Enable()
2489
2490            # Make sure the check box updated
2491            self.get_all_checked_params()
2492
2493            # update params
2494            self._update_paramv_on_fit()
2495            # draw
2496            self._draw_model()
2497            self.Refresh()
2498        except Exception:
2499            logging.error(traceback.format_exc())
2500            # Error msg
2501            msg = "Error occurred:"
2502            msg += " Could not select the distribution function..."
2503            msg += " Please select another distribution function."
2504            disp_box.SetBackgroundColour("pink")
2505            # Focus on Fit button so that users can see the pinky box
2506            self.btFit.SetFocus()
2507            wx.PostEvent(self._manager.parent,
2508                         StatusEvent(status=msg, info="error"))
2509
2510    def _set_array_disp(self, name=None, disp=None):
2511        """
2512        Set array dispersion
2513
2514        :param name: name of the parameter for the dispersion to be set
2515        :param disp: the polydisperion object
2516        """
2517        # The user wants this parameter to be averaged.
2518        # Pop up the file selection dialog.
2519        path = self._selectDlg()
2520        # Array data
2521        values = []
2522        weights = []
2523        # If nothing was selected, just return
2524        if path is None:
2525            self.disp_cb_dict[name].SetValue(False)
2526            # self.noDisper_rbox.SetValue(True)
2527            return
2528        self._default_save_location = os.path.dirname(path)
2529        if self._manager is not None:
2530            self._manager.parent._default_save_location = \
2531                             self._default_save_location
2532
2533        basename = os.path.basename(path)
2534        values, weights = self.read_file(path)
2535
2536        # If any of the two arrays is empty, notify the user that we won't
2537        # proceed
2538        if len(self.param_toFit) > 0:
2539            if name in self.param_toFit:
2540                self.param_toFit.remove(name)
2541
2542        # Tell the user that we are about to apply the distribution
2543        msg = "Applying loaded %s distribution: %s" % (name, path)
2544        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2545        self._set_array_disp_model(name=name, disp=disp,
2546                                   values=values, weights=weights)
2547        return basename
2548
2549    def _set_array_disp_model(self, name=None, disp=None,
2550                              values=[], weights=[]):
2551        """
2552        Set array dispersion model
2553
2554        :param name: name of the parameter for the dispersion to be set
2555        :param disp: the polydisperion object
2556        """
2557        disp.set_weights(values, weights)
2558        self._disp_obj_dict[name] = disp
2559        self.model.set_dispersion(name.split('.')[0], disp)
2560        self.state._disp_obj_dict[name] = disp.type
2561        self.values[name] = values
2562        self.weights[name] = weights
2563        # Store the object to make it persist outside the
2564        # scope of this method
2565        # TODO: refactor model to clean this up?
2566        self.state.values = {}
2567        self.state.weights = {}
2568        self.state.values = copy.deepcopy(self.values)
2569        self.state.weights = copy.deepcopy(self.weights)
2570
2571        # Set the new model as the dispersion object for the
2572        # selected parameter
2573        # self.model.set_dispersion(p, disp_model)
2574        # Store a reference to the weights in the model object
2575        # so that
2576        # it's not lost when we use the model within another thread.
2577        self.state.model = self.model.clone()
2578        self.model._persistency_dict[name.split('.')[0]] = \
2579            [values, weights]
2580        self.state.model._persistency_dict[name.split('.')[0]] = \
2581            [values, weights]
2582
2583    def _del_array_values(self, name=None):
2584        """
2585        Reset array dispersion
2586
2587        :param name: name of the parameter for the dispersion to be set
2588        """
2589        # Try to delete values and weight of the names array dic if exists
2590        try:
2591            if name in self.values:
2592                del self.values[name]
2593                del self.weights[name]
2594                # delete all other dic
2595                del self.state.values[name]
2596                del self.state.weights[name]
2597                del self.model._persistency_dict[name.split('.')[0]]
2598                del self.state.model._persistency_dict[name.split('.')[0]]
2599        except Exception:
2600            logging.error(traceback.format_exc())
2601
2602    def _lay_out(self):
2603        """
2604        returns self.Layout
2605
2606        :Note: Mac seems to like this better when self.
2607            Layout is called after fitting.
2608        """
2609        self._sleep4sec()
2610        self.Layout()
2611        return
2612
2613    def _sleep4sec(self):
2614        """
2615            sleep for 1 sec only applied on Mac
2616            Note: This 1sec helps for Mac not to crash on self.
2617            Layout after self._draw_model
2618        """
2619        if ON_MAC:
2620            time.sleep(1)
2621
2622    def _find_polyfunc_selection(self, disp_func=None):
2623        """
2624        FInd Comboox selection from disp_func
2625
2626        :param disp_function: dispersion distr. function
2627        """
2628        # Find the selection
2629        if disp_func is not None:
2630            try:
2631                return POLYDISPERSITY_MODELS.values().index(disp_func.__class__)
2632            except ValueError:
2633                pass  # Fall through to default class
2634        return POLYDISPERSITY_MODELS.keys().index('gaussian')
2635
2636    def on_reset_clicked(self, event):
2637        """
2638        On 'Reset' button  for Q range clicked
2639        """
2640        flag = True
2641        # For 3 different cases: Data2D, Data1D, and theory
2642        if self.model is None:
2643            msg = "Please select a model first..."
2644            wx.MessageBox(msg, 'Info')
2645            flag = False
2646            return
2647
2648        elif self.data.__class__.__name__ == "Data2D":
2649            data_min = 0
2650            x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2651            y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2652            self.qmin_x = data_min
2653            self.qmax_x = math.sqrt(x * x + y * y)
2654            # self.data.mask = numpy.ones(len(self.data.data),dtype=bool)
2655            # check smearing
2656            if not self.disable_smearer.GetValue():
2657                # set smearing value whether or
2658                # not the data contain the smearing info
2659                if self.pinhole_smearer.GetValue():
2660                    flag = self.update_pinhole_smear()
2661                else:
2662                    flag = True
2663
2664        elif self.data is None:
2665            self.qmin_x = _QMIN_DEFAULT
2666            self.qmax_x = _QMAX_DEFAULT
2667            self.num_points = _NPTS_DEFAULT
2668            self.state.npts = self.num_points
2669
2670        elif self.data.__class__.__name__ != "Data2D":
2671            self.qmin_x = min(self.data.x)
2672            self.qmax_x = max(self.data.x)
2673            # check smearing
2674            if not self.disable_smearer.GetValue():
2675                # set smearing value whether or
2676                # not the data contain the smearing info
2677                if self.slit_smearer.GetValue():
2678                    flag = self.update_slit_smear()
2679                elif self.pinhole_smearer.GetValue():
2680                    flag = self.update_pinhole_smear()
2681                else:
2682                    flag = True
2683        else:
2684            flag = False
2685
2686        if flag is False:
2687            msg = "Cannot Plot :Must enter a number!!!  "
2688            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2689        else:
2690            # set relative text ctrs.
2691            self.qmin.SetValue(str(self.qmin_x))
2692            self.qmax.SetValue(str(self.qmax_x))
2693            self.show_npts2fit()
2694            # At this point, some button and variables satatus (disabled?)
2695            # should be checked such as color that should be reset to
2696            # white in case that it was pink.
2697            self._onparamEnter_helper()
2698
2699        self.save_current_state()
2700        self.state.qmin = self.qmin_x
2701        self.state.qmax = self.qmax_x
2702
2703        # reset the q range values
2704        self._reset_plotting_range(self.state)
2705        self._draw_model()
2706
2707    def select_log(self, event):
2708        """
2709        Log checked to generate log spaced points for theory model
2710        """
2711
2712    def get_images(self):
2713        """
2714        Get the images of the plots corresponding this panel for report
2715
2716        : return graphs: list of figures
2717        : Need Move to guiframe
2718        """
2719        # set list of graphs
2720        graphs = []
2721        canvases = []
2722        res_item = None
2723        # call gui_manager
2724        gui_manager = self._manager.parent
2725        # loops through the panels [dic]
2726        for _, item2 in gui_manager.plot_panels.iteritems():
2727            data_title = self.data.group_id
2728            # try to get all plots belonging to this control panel
2729            try:
2730                g_id = item2.group_id
2731                if g_id == data_title or \
2732                        str(g_id).count("res" + str(self.graph_id)) or \
2733                        str(g_id).count(str(self.uid)) > 0:
2734                    if str(g_id).count("res" + str(self.graph_id)) > 0:
2735                        res_item = [item2.figure, item2.canvas]
2736                    else:
2737                        # append to the list
2738                        graphs.append(item2.figure)
2739                        canvases.append(item2.canvas)
2740            except Exception:
2741                # Not for control panels
2742                logging.error(traceback.format_exc())
2743        # Make sure the resduals plot goes to the last
2744        if res_item is not None:
2745            graphs.append(res_item[0])
2746            canvases.append(res_item[1])
2747        # return the list of graphs
2748        return graphs, canvases
2749
2750    def on_function_help_clicked(self, event):
2751        """
2752        Function called when 'Help' button is pressed next to model
2753        of interest.  This calls DocumentationWindow from
2754        documentation_window.py. It will load the top level of the model
2755        help documenation sphinx generated html if no model is presented.
2756        If a model IS present then if documention for that model exists
2757        it will load to that  point otherwise again it will go to the top.
2758        For Wx2.8 and below is used (i.e. non-released through installer)
2759        a browser is loaded and the top of the model documentation only is
2760        accessible because webbrowser module does not pass anything after
2761        the # to the browser.
2762
2763        :param event: on Help Button pressed event
2764        """
2765
2766        if self.model is not None:
2767            name = self.formfactorbox.GetValue()
2768            _TreeLocation = 'user/models/' + name.lower()+'.html'
2769            _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2770                                              "", name + " Help")
2771        else:
2772            _TreeLocation = 'user/index.html'
2773            _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2774                                              "", "General Model Help")
2775
2776    def on_model_help_clicked(self, event):
2777        """
2778        Function called when 'Description' button is pressed next to model
2779        of interest.  This calls the Description embedded in the model. This
2780        should work with either Wx2.8 and lower or higher. If no model is
2781        selected it will give the message that a model must be chosen first
2782        in the box that would normally contain the description.  If a badly
2783        behaved model is encountered which has no description then it will
2784        give the message that none is available.
2785
2786        :param event: on Description Button pressed event
2787        """
2788
2789        if self.model is None:
2790            name = 'index.html'
2791        else:
2792            name = self.formfactorbox.GetValue()
2793
2794        msg = 'Model description:\n'
2795        info = "Info"
2796        if self.model is not None:
2797            # frame.Destroy()
2798            if str(self.model.description).rstrip().lstrip() == '':
2799                msg += "Sorry, no information is available for this model."
2800            else:
2801                msg += self.model.description + '\n'
2802            wx.MessageBox(msg, info)
2803        else:
2804            msg += "You must select a model to get information on this"
2805            wx.MessageBox(msg, info)
2806
2807    def _on_mag_angle_help(self, event):
2808        """
2809        Bring up Magnetic Angle definition bmp image whenever the ? button
2810        is clicked. Calls DocumentationWindow with the path of the location
2811        within the documentation tree (after /doc/ ....". When using old
2812        versions of Wx (i.e. before 2.9 and therefore not part of release
2813        versions distributed via installer) it brings up an image viewer
2814        box which allows the user to click through the rest of the images in
2815        the directory.  Not ideal but probably better than alternative which
2816        would bring up the entire discussion of how magnetic models work?
2817        Specially since it is not likely to be accessed.  The normal release
2818        versions bring up the normal image box.
2819
2820        :param evt: Triggers on clicking ? in Magnetic Angles? box
2821        """
2822
2823        _TreeLocation = "_images/M_angles_pic.bmp"
2824        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2825                                          "Magnetic Angle Defintions")
2826
2827    def _on_mag_help(self, event):
2828        """
2829        Bring up Magnetic Angle definition bmp image whenever the ? button
2830        is clicked. Calls DocumentationWindow with the path of the location
2831        within the documentation tree (after /doc/ ....". When using old
2832        versions of Wx (i.e. before 2.9 and therefore not part of release
2833        versions distributed via installer) it brings up an image viewer
2834        box which allows the user to click through the rest of the images in
2835        the directory.  Not ideal but probably better than alternative which
2836        would bring up the entire discussion of how magnetic models work?
2837        Specially since it is not likely to be accessed.  The normal release
2838        versions bring up the normal image box.
2839
2840        :param evt: Triggers on clicking ? in Magnetic Angles? box
2841        """
2842
2843        _TreeLocation = "user/magnetism.html"
2844        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2845                                          "Polarized Beam/Magnetc Help")
2846
2847    def _on_mag_on(self, event):
2848        """
2849        Magnetic Parameters ON/OFF
2850        """
2851        button = event.GetEventObject()
2852
2853        if button.GetLabel().count('ON') > 0:
2854            self.magnetic_on = True
2855            button.SetLabel("Magnetic OFF")
2856            m_value = 1.0e-06
2857            for key in self.model.magnetic_params:
2858                if key.count('M0') > 0:
2859                    self.model.setParam(key, m_value)
2860                    m_value += 0.5e-06
2861        else:
2862            self.magnetic_on = False
2863            button.SetLabel("Magnetic ON")
2864            for key in self.model.magnetic_params:
2865                if key.count('M0') > 0:
2866                    # reset mag value to zero fo safety
2867                    self.model.setParam(key, 0.0)
2868
2869        self.Show(False)
2870        self.set_model_param_sizer(self.model)
2871        # self._set_sizer_dispersion()
2872        self.state.magnetic_on = self.magnetic_on
2873        self.SetupScrolling()
2874        self.Show(True)
2875
2876    def on_pd_help_clicked(self, event):
2877        """
2878        Bring up Polydispersity Documentation whenever the ? button is clicked.
2879        Calls DocumentationWindow with the path of the location within the
2880        documentation tree (after /doc/ ....".  Note that when using old
2881        versions of Wx (before 2.9) and thus not the release version of
2882        istallers, the help comes up at the top level of the file as
2883        webbrowser does not pass anything past the # to the browser when it is
2884        running "file:///...."
2885
2886        :param event: Triggers on clicking ? in polydispersity box
2887        """
2888
2889        _TreeLocation = "user/sasgui/perspectives/fitting/pd_help.html"
2890        _PageAnchor = ""
2891        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2892                                          _PageAnchor, "Polydispersity Help")
2893
2894    def on_left_down(self, event):
2895        """
2896        Get key stroke event
2897        """
2898        # Figuring out key combo: Cmd for copy, Alt for paste
2899        if event.CmdDown() and event.ShiftDown():
2900            self.get_paste()
2901        elif event.CmdDown():
2902            self.get_copy()
2903        else:
2904            event.Skip()
2905            return
2906        # make event free
2907        event.Skip()
2908
2909    def get_copy(self):
2910        """
2911        Get copy params to clipboard
2912        """
2913        content = self.get_copy_params()
2914        flag = self.set_clipboard(content)
2915        self._copy_info(flag)
2916        return flag
2917
2918    def get_copy_params(self):
2919        """
2920        Get the string copies of the param names and values in the tap
2921        """
2922        content = 'sasview_parameter_values:'
2923        # Do it if params exist
2924        if self.parameters:
2925
2926            # go through the parameters
2927            strings = self._get_copy_helper(self.parameters,
2928                                           self.orientation_params)
2929            content += strings
2930
2931            # go through the fittables
2932            strings = self._get_copy_helper(self.fittable_param,
2933                                           self.orientation_params_disp)
2934            content += strings
2935
2936            # go through the fixed params
2937            strings = self._get_copy_helper(self.fixed_param,
2938                                           self.orientation_params_disp)
2939            content += strings
2940
2941            # go through the str params
2942            strings = self._get_copy_helper(self.str_parameters,
2943                                           self.orientation_params)
2944            content += strings
2945            return content
2946        else:
2947            return False
2948
2949    def get_copy_excel(self):
2950        """
2951        Get copy params to clipboard
2952        """
2953        content = self.get_copy_params_excel()
2954        flag = self.set_clipboard(content)
2955        self._copy_info(flag)
2956        return flag
2957
2958    def get_copy_params_excel(self):
2959        """
2960        Get the string copies of the param names and values in the tap
2961        """
2962        content = ''
2963
2964        crlf = chr(13) + chr(10)
2965        tab = chr(9)
2966
2967        # Do it if params exist
2968        if self.parameters:
2969
2970            for param in self.parameters:
2971                content += param[1]  # parameter name
2972                content += tab
2973                content += param[1] + "_err"
2974                content += tab
2975
2976            content += crlf
2977
2978            # row of values and errors...
2979            for param in self.parameters:
2980                content += param[2].GetValue()  # value
2981                content += tab
2982                content += param[4].GetValue()  # error
2983                content += tab
2984
2985            return content
2986        else:
2987            return False
2988
2989    def get_copy_latex(self):
2990        """
2991        Get copy params to clipboard
2992        """
2993        content = self.get_copy_params_latex()
2994        flag = self.set_clipboard(content)
2995        self._copy_info(flag)
2996        return flag
2997
2998    def get_copy_params_latex(self):
2999        """
3000        Get the string copies of the param names and values in the tap
3001        """
3002        content = '\\begin{table}'
3003        content += '\\begin{tabular}[h]'
3004
3005        crlf = chr(13) + chr(10)
3006        tab = chr(9)
3007
3008        # Do it if params exist
3009        if self.parameters:
3010
3011            content += '{|'
3012            for param in self.parameters:
3013                content += 'l|l|'
3014            content += '}\hline'
3015            content += crlf
3016
3017            for index, param in enumerate(self.parameters):
3018                content += param[1].replace('_', '\_')  # parameter name
3019                content += ' & '
3020                content += param[1].replace('_', '\_') + "\_err"
3021                if index < len(self.parameters) - 1:
3022                    content += ' & '
3023            content += '\\\\ \\hline'
3024            content += crlf
3025
3026            # row of values and errors...
3027            for index, param in enumerate(self.parameters):
3028                content += param[2].GetValue()  # parameter value
3029                content += ' & '
3030                content += param[4].GetValue()  # parameter error
3031                if index < len(self.parameters) - 1:
3032                    content += ' & '
3033            content += '\\\\ \\hline'
3034            content += crlf
3035
3036            content += '\\end{tabular}'
3037            content += '\\end{table}'
3038            return content
3039        else:
3040            return False
3041
3042    def set_clipboard(self, content=None):
3043        """
3044        Put the string to the clipboard
3045        """
3046        if not content:
3047            return False
3048        if wx.TheClipboard.Open():
3049            wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
3050            wx.TheClipboard.Close()
3051            return True
3052        return None
3053
3054    def _get_copy_helper(self, param, orient_param):
3055        """
3056        Helping get value and name of the params
3057
3058        : param param:  parameters
3059        : param orient_param = oritational params
3060        : return content: strings [list] [name,value:....]
3061        """
3062        content = ''
3063        bound_hi = ''
3064        bound_lo = ''
3065        # go through the str params
3066        for item in param:
3067            # copy only the params shown
3068            if not item[2].IsShown():
3069                continue
3070            disfunc = ''
3071            try:
3072                if item[7].__class__.__name__ == 'ComboBox':
3073                    disfunc = str(item[7].GetValue())
3074            except Exception:
3075                logging.error(traceback.format_exc())
3076
3077            # 2D
3078            if self.data.__class__.__name__ == "Data2D":
3079                try:
3080                    check = item[0].GetValue()
3081                except Exception:
3082                    check = None
3083                name = item[1]
3084                value = item[2].GetValue()
3085            # 1D
3086            else:
3087                # for 1D all parameters except orientation
3088                if not item[1] in orient_param:
3089                    try:
3090                        check = item[0].GetValue()
3091                    except:
3092                        check = None
3093                    name = item[1]
3094                    value = item[2].GetValue()
3095
3096            # Bounds
3097            try:
3098                bound_lo = item[5].GetValue()
3099                bound_hi = item[6].GetValue()
3100            except Exception:
3101                # harmless - need to just pass
3102                pass
3103
3104            # add to the content
3105            if disfunc != '':
3106
3107                disfunc = ',' + disfunc
3108            # Need to support array func for copy/paste
3109            try:
3110                if disfunc.count('array') > 0:
3111                    disfunc += ','
3112                    for val in self.values[name]:
3113                        disfunc += ' ' + str(val)
3114                    disfunc += ','
3115                    for weight in self.weights[name]:
3116                        disfunc += ' ' + str(weight)
3117            except Exception:
3118                logging.error(traceback.format_exc())
3119            content += name + ',' + str(check) + ',' + value + disfunc + ',' + \
3120                       bound_lo + ',' + bound_hi + ':'
3121
3122        return content
3123
3124    def get_clipboard(self):
3125        """
3126        Get strings in the clipboard
3127        """
3128        text = ""
3129        # Get text from the clip board
3130        if wx.TheClipboard.Open():
3131            if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
3132                data = wx.TextDataObject()
3133                # get wx dataobject
3134                success = wx.TheClipboard.GetData(data)
3135                # get text
3136                if success:
3137                    text = data.GetText()
3138                else:
3139                    text = ''
3140            # close clipboard
3141            wx.TheClipboard.Close()
3142        return text
3143
3144    def get_paste(self):
3145        """
3146        Paste params from the clipboard
3147        """
3148        text = self.get_clipboard()
3149        flag = self.get_paste_params(text)
3150        self._copy_info(flag)
3151        return flag
3152
3153    def get_paste_params(self, text=''):
3154        """
3155        Get the string copies of the param names and values in the tap
3156        """
3157        context = {}
3158        # put the text into dictionary
3159        lines = text.split(':')
3160        if lines[0] != 'sasview_parameter_values':
3161            self._copy_info(False)
3162            return False
3163        for line in lines[1:-1]:
3164            if len(line) != 0:
3165                item = line.split(',')
3166                check = item[1]
3167                name = item[0]
3168                value = item[2]
3169                # Transfer the text to content[dictionary]
3170                context[name] = [check, value]
3171
3172                # limits
3173                limit_lo = item[3]
3174                context[name].append(limit_lo)
3175                limit_hi = item[4]
3176                context[name].append(limit_hi)
3177
3178            # ToDo: PlugIn this poly disp function for pasting
3179            try:
3180                poly_func = item[5]
3181                context[name].append(poly_func)
3182                try:
3183                    # take the vals and weights for  array
3184                    array_values = item[6].split(' ')
3185                    array_weights = item[7].split(' ')
3186                    val = [float(a_val) for a_val in array_values[1:]]
3187                    weit = [float(a_weit) for a_weit in array_weights[1:]]
3188
3189                    context[name].append(val)
3190                    context[name].append(weit)
3191                except:
3192                    raise
3193            except:
3194                poly_func = ''
3195                context[name].append(poly_func)
3196
3197        # Do it if params exist
3198        if self.parameters:
3199            # go through the parameters
3200            self._get_paste_helper(self.parameters,
3201                                   self.orientation_params, context)
3202
3203            # go through the fittables
3204            self._get_paste_helper(self.fittable_param,
3205                                   self.orientation_params_disp,
3206                                   context)
3207
3208            # go through the fixed params
3209            self._get_paste_helper(self.fixed_param,
3210                                   self.orientation_params_disp, context)
3211
3212            # go through the str params
3213            self._get_paste_helper(self.str_parameters,
3214                                   self.orientation_params, context)
3215
3216            return True
3217        return None
3218
3219    def _get_paste_helper(self, param, orient_param, content):
3220        """
3221        Helping set values of the params
3222
3223        : param param:  parameters
3224        : param orient_param: oritational params
3225        : param content: dictionary [ name, value: name1.value1,...]
3226        """
3227        # go through the str params
3228        for item in param:
3229            # 2D
3230            if self.data.__class__.__name__ == "Data2D":
3231                name = item[1]
3232                if name in content.keys():
3233                    values = content[name]
3234                    check = values[0]
3235                    pd = values[1]
3236
3237                    if name.count('.') > 0:
3238                        # If this is parameter.width, then pd may be a floating
3239                        # point value or it may be an array distribution.
3240                        # Nothing to do for parameter.npts or parameter.nsigmas.
3241                        try:
3242                            float(pd)
3243                            if name.endswith('.npts'):
3244                                pd = int(pd)
3245                        except Exception:
3246                            # continue
3247                            if not pd and pd != '':
3248                                continue
3249                    item[2].SetValue(str(pd))
3250                    if item in self.fixed_param and pd == '':
3251                        # Only array func has pd == '' case.
3252                        item[2].Enable(False)
3253                    else:
3254                        item[2].Enable(True)
3255                    if item[2].__class__.__name__ == "ComboBox":
3256                        if content[name][1] in self.model.fun_list:
3257                            fun_val = self.model.fun_list[content[name][1]]
3258                            self.model.setParam(name, fun_val)
3259                    try:
3260                        item[5].SetValue(str(values[-3]))
3261                        item[6].SetValue(str(values[-2]))
3262                    except Exception:
3263                        # passing as harmless non-update
3264                        pass
3265
3266                    value = content[name][1:]
3267                    self._paste_poly_help(item, value)
3268                    if check == 'True':
3269                        is_true = True
3270                    elif check == 'False':
3271                        is_true = False
3272                    else:
3273                        is_true = None
3274                    if is_true is not None:
3275                        item[0].SetValue(is_true)
3276            # 1D
3277            else:
3278                # for 1D all parameters except orientation
3279                if not item[1] in orient_param:
3280                    name = item[1]
3281                    if name in content.keys():
3282                        check = content[name][0]
3283                        # Avoid changing combox content
3284                        value = content[name][1:]
3285                        pd = value[0]
3286                        if name.count('.') > 0:
3287                            # If this is parameter.width, then pd may be a
3288                            # floating point value or it may be an array
3289                            # distribution. Nothing to do for parameter.npts or
3290                            # parameter.nsigmas.
3291                            try:
3292                                pd = float(pd)
3293                                if name.endswith('.npts'):
3294                                    pd = int(pd)
3295                            except:
3296                                # continue
3297                                if not pd and pd != '':
3298                                    continue
3299                        item[2].SetValue(str(pd))
3300                        if item in self.fixed_param and pd == '':
3301                            # Only array func has pd == '' case.
3302                            item[2].Enable(False)
3303                        else:
3304                            item[2].Enable(True)
3305                        if item[2].__class__.__name__ == "ComboBox":
3306                            if value[0] in self.model.fun_list:
3307                                fun_val = self.model.fun_list[value[0]]
3308                                self.model.setParam(name, fun_val)
3309                                # save state
3310                        try:
3311                            item[5].SetValue(str(value[-3]))
3312                            item[6].SetValue(str(value[-2]))
3313                        except Exception:
3314                            # passing as harmless non-update
3315                            pass
3316
3317                        self._paste_poly_help(item, value)
3318                        if check == 'True':
3319                            is_true = True
3320                        elif check == 'False':
3321                            is_true = False
3322                        else:
3323                            is_true = None
3324                        if is_true is not None:
3325                            item[0].SetValue(is_true)
3326
3327        self.select_param(event=None)
3328        self.Refresh()
3329
3330    def _paste_poly_help(self, item, value):
3331        """
3332        Helps get paste for poly function
3333
3334        *item* is the parameter name
3335
3336        *value* depends on which parameter is being processed, and whether it
3337        has array polydispersity.
3338
3339        For parameters without array polydispersity:
3340
3341            parameter => ['FLOAT', '']
3342            parameter.width => ['FLOAT', 'DISTRIBUTION', '']
3343            parameter.npts => ['FLOAT', '']
3344            parameter.nsigmas => ['FLOAT', '']
3345
3346        For parameters with array polydispersity:
3347
3348            parameter => ['FLOAT', '']
3349            parameter.width => ['FILENAME', 'array', [x1, ...], [w1, ...]]
3350            parameter.npts => ['FLOAT', '']
3351            parameter.nsigmas => ['FLOAT', '']
3352        """
3353        # Do nothing if not setting polydispersity
3354        if len(value[3]) == 0:
3355            return
3356
3357        try:
3358            name = item[7].Name
3359            param_name = name.split('.')[0]
3360            item[7].SetValue(value[1])
3361            selection = item[7].GetCurrentSelection()
3362            dispersity = item[7].GetClientData(selection)
3363            disp_model = dispersity()
3364
3365            if value[1] == 'array':
3366                pd_vals = numpy.array(value[2])
3367                pd_weights = numpy.array(value[3])
3368                if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
3369                    msg = ("bad array distribution parameters for %s"
3370                           % param_name)
3371                    raise ValueError(msg)
3372                self._set_disp_cb(True, item=item)
3373                self._set_array_disp_model(name=name,
3374                                           disp=disp_model,
3375                                           values=pd_vals,
3376                                           weights=pd_weights)
3377            else:
3378                self._set_disp_cb(False, item=item)
3379                self._disp_obj_dict[name] = disp_model
3380                self.model.set_dispersion(param_name, disp_model)
3381                self.state._disp_obj_dict[name] = disp_model.type
3382                # TODO: It's not an array, why update values and weights?
3383                self.model._persistency_dict[param_name] = \
3384                    [self.values, self.weights]
3385                self.state.values = self.values
3386                self.state.weights = self.weights
3387
3388        except Exception:
3389            logging.error(traceback.format_exc())
3390            print "Error in BasePage._paste_poly_help: %s" % \
3391                  sys.exc_info()[1]
3392
3393    def _set_disp_cb(self, isarray, item):
3394        """
3395        Set cb for array disp
3396        """
3397        if isarray:
3398            item[0].SetValue(False)
3399            item[0].Enable(False)
3400            item[2].Enable(False)
3401            item[3].Show(False)
3402            item[4].Show(False)
3403            item[5].SetValue('')
3404            item[5].Enable(False)
3405            item[6].SetValue('')
3406            item[6].Enable(False)
3407        else:
3408            item[0].Enable()
3409            item[2].Enable()
3410            item[3].Show(True)
3411            item[4].Show(True)
3412            item[5].Enable()
3413            item[6].Enable()
3414
3415    def update_pinhole_smear(self):
3416        """
3417            Method to be called by sub-classes
3418            Moveit; This method doesn't belong here
3419        """
3420        print "BasicPage.update_pinhole_smear was called: skipping"
3421        return
3422
3423    def _read_category_info(self):
3424        """
3425        Reads the categories in from file
3426        """
3427        # # ILL mod starts here - July 2012 kieranrcampbell@gmail.com
3428        self.master_category_dict = defaultdict(list)
3429        self.by_model_dict = defaultdict(list)
3430        self.model_enabled_dict = defaultdict(bool)
3431        categorization_file = CategoryInstaller.get_user_file()
3432        with open(categorization_file, 'rb') as f:
3433            self.master_category_dict = json.load(f)
3434        self._regenerate_model_dict()
3435
3436    def _regenerate_model_dict(self):
3437        """
3438        regenerates self.by_model_dict which has each model name as the
3439        key and the list of categories belonging to that model
3440        along with the enabled mapping
3441        """
3442        self.by_model_dict = defaultdict(list)
3443        for category in self.master_category_dict:
3444            for (model, enabled) in self.master_category_dict[category]:
3445                self.by_model_dict[model].append(category)
3446                self.model_enabled_dict[model] = enabled
3447
3448    def _populate_listbox(self):
3449        """
3450        fills out the category list box
3451        """
3452        uncat_str = 'Plugin Models'
3453        self._read_category_info()
3454
3455        self.categorybox.Clear()
3456        cat_list = sorted(self.master_category_dict.keys())
3457        if uncat_str not in cat_list:
3458            cat_list.append(uncat_str)
3459
3460        for category in cat_list:
3461            if category != '':
3462                self.categorybox.Append(category)
3463
3464        if self.categorybox.GetSelection() == wx.NOT_FOUND:
3465            self.categorybox.SetSelection(0)
3466        else:
3467            self.categorybox.SetSelection(
3468                self.categorybox.GetSelection())
3469        # self._on_change_cat(None)
3470
3471    def _on_change_cat(self, event):
3472        """
3473        Callback for category change action
3474        """
3475        self.model_name = None
3476        category = self.categorybox.GetStringSelection()
3477        if category is None:
3478            return
3479        self.model_box.Clear()
3480
3481        if category == 'Plugin Models':
3482            for model in self.model_list_box[category]:
3483                str_m = str(model).split(".")[0]
3484                self.model_box.Append(str_m)
3485
3486        else:
3487            for (model, enabled) in sorted(self.master_category_dict[category],
3488                                           key=lambda name: name[0]):
3489                if(enabled):
3490                    self.model_box.Append(model)
3491
3492    def _fill_model_sizer(self, sizer):
3493        """
3494        fill sizer containing model info
3495        """
3496        # This should only be called once per fit tab
3497        # print "==== Entering _fill_model_sizer"
3498        # Add model function Details button in fitpanel.
3499        # The following 3 lines are for Mac. Let JHC know before modifying...
3500        title = "Model"
3501        self.formfactorbox = None
3502        self.multifactorbox = None
3503        self.mbox_description = wx.StaticBox(self, wx.ID_ANY, str(title))
3504        boxsizer1 = wx.StaticBoxSizer(self.mbox_description, wx.VERTICAL)
3505        sizer_cat = wx.BoxSizer(wx.HORIZONTAL)
3506        self.mbox_description.SetForegroundColour(wx.RED)
3507        wx_id = self._ids.next()
3508        self.model_func = wx.Button(self, wx_id, 'Help', size=(80, 23))
3509        self.model_func.Bind(wx.EVT_BUTTON, self.on_function_help_clicked,
3510                             id=wx_id)
3511        self.model_func.SetToolTipString("Full Model Function Help")
3512        wx_id = self._ids.next()
3513        self.model_help = wx.Button(self, wx_id, 'Description', size=(80, 23))
3514        self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,
3515                             id=wx_id)
3516        self.model_help.SetToolTipString("Short Model Function Description")
3517        wx_id = self._ids.next()
3518        self.model_view = wx.Button(self, wx_id, "Show 2D", size=(80, 23))
3519        self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=wx_id)
3520        hint = "toggle view of model from 1D to 2D  or 2D to 1D"
3521        self.model_view.SetToolTipString(hint)
3522
3523        cat_set_box = wx.StaticBox(self, wx.ID_ANY, 'Category')
3524        sizer_cat_box = wx.StaticBoxSizer(cat_set_box, wx.HORIZONTAL)
3525        sizer_cat_box.SetMinSize((200, 50))
3526        self.categorybox = wx.ComboBox(self, wx.ID_ANY,
3527                                       style=wx.CB_READONLY)
3528        self.categorybox.SetToolTip(wx.ToolTip("Select a Category/Type"))
3529        self._populate_listbox()
3530        wx.EVT_COMBOBOX(self.categorybox, wx.ID_ANY, self._show_combox)
3531        # self.shape_rbutton = wx.RadioButton(self, wx.ID_ANY, 'Shapes',
3532        #                                     style=wx.RB_GROUP)
3533        # self.shape_indep_rbutton = wx.RadioButton(self, wx.ID_ANY,
3534        #                                          "Shape-Independent")
3535        # self.struct_rbutton = wx.RadioButton(self, wx.ID_ANY,
3536        #                                     "Structure Factor ")
3537        # self.plugin_rbutton = wx.RadioButton(self, wx.ID_ANY,
3538        #                                     "Uncategorized")
3539
3540        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3541        #                   id=self.shape_rbutton.GetId())
3542        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3543        #                    id=self.shape_indep_rbutton.GetId())
3544        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3545        #                    id=self.struct_rbutton.GetId())
3546        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3547        #                    id=self.plugin_rbutton.GetId())
3548        # MAC needs SetValue
3549
3550        show_cat_button = wx.Button(self, wx.ID_ANY, "Modify")
3551        cat_tip = "Modify model categories \n"
3552        cat_tip += "(also accessible from the menu bar)."
3553        show_cat_button.SetToolTip(wx.ToolTip(cat_tip))
3554        show_cat_button.Bind(wx.EVT_BUTTON, self._on_modify_cat)
3555        sizer_cat_box.Add(self.categorybox, 1, wx.RIGHT, 3)
3556        sizer_cat_box.Add((10, 10))
3557        sizer_cat_box.Add(show_cat_button)
3558        # self.shape_rbutton.SetValue(True)
3559
3560        sizer_radiobutton = wx.GridSizer(2, 2, 5, 5)
3561        # sizer_radiobutton.Add(self.shape_rbutton)
3562        # sizer_radiobutton.Add(self.shape_indep_rbutton)
3563        sizer_radiobutton.Add((5, 5))
3564        sizer_radiobutton.Add(self.model_view, 1, wx.RIGHT, 5)
3565        # sizer_radiobutton.Add(self.plugin_rbutton)
3566        # sizer_radiobutton.Add(self.struct_rbutton)
3567        # sizer_radiobutton.Add((5,5))
3568        sizer_radiobutton.Add(self.model_help, 1, wx.RIGHT | wx.LEFT, 5)
3569        # sizer_radiobutton.Add((5,5))
3570        sizer_radiobutton.Add(self.model_func, 1, wx.RIGHT, 5)
3571        sizer_cat.Add(sizer_cat_box, 1, wx.LEFT, 2.5)
3572        sizer_cat.Add(sizer_radiobutton)
3573        sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
3574        mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL)
3575
3576        self.text1 = wx.StaticText(self, wx.ID_ANY, "")
3577        self.text2 = wx.StaticText(self, wx.ID_ANY, "P(Q)*S(Q)")
3578        self.mutifactor_text = wx.StaticText(self, wx.ID_ANY, "No. of Shells: ")
3579        self.mutifactor_text1 = wx.StaticText(self, wx.ID_ANY, "")
3580        self.show_sld_button = wx.Button(self, wx.ID_ANY, "Show SLD Profile")
3581        self.show_sld_button.Bind(wx.EVT_BUTTON, self._on_show_sld)
3582
3583        self.formfactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3584        self.formfactorbox.SetToolTip(wx.ToolTip("Select a Model"))
3585        if self.model is not None:
3586            self.formfactorbox.SetValue(self.model.name)
3587        self.structurebox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3588        self.multifactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3589        self.initialize_combox()
3590        wx.EVT_COMBOBOX(self.formfactorbox, wx.ID_ANY, self._on_select_model)
3591
3592        wx.EVT_COMBOBOX(self.structurebox, wx.ID_ANY, self._on_select_model)
3593        wx.EVT_COMBOBOX(self.multifactorbox, wx.ID_ANY, self._on_select_model)
3594        # check model type to show sizer
3595        if self.model is not None:
3596            print "_set_model_sizer_selection: disabled."
3597            # self._set_model_sizer_selection(self.model)
3598
3599        sizer_selection.Add(self.text1)
3600        sizer_selection.Add((10, 5))
3601        sizer_selection.Add(self.formfactorbox)
3602        sizer_selection.Add((5, 5))
3603        sizer_selection.Add(self.text2)
3604        sizer_selection.Add((5, 5))
3605        sizer_selection.Add(self.structurebox)
3606
3607        mutifactor_selection.Add((13, 5))
3608        mutifactor_selection.Add(self.mutifactor_text)
3609        mutifactor_selection.Add(self.multifactorbox)
3610        mutifactor_selection.Add((5, 5))
3611        mutifactor_selection.Add(self.mutifactor_text1)
3612        mutifactor_selection.Add((10, 5))
3613        mutifactor_selection.Add(self.show_sld_button)
3614
3615        boxsizer1.Add(sizer_cat)
3616        boxsizer1.Add((10, 10))
3617        boxsizer1.Add(sizer_selection)
3618        boxsizer1.Add((10, 10))
3619        boxsizer1.Add(mutifactor_selection)
3620
3621        self._set_multfactor_combobox()
3622        self.multifactorbox.SetSelection(1)
3623        self.show_sld_button.Hide()
3624        sizer.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
3625        sizer.Layout()
3626
3627    def on_smear_helper(self, update=False):
3628        """
3629        Help for onSmear if implemented
3630
3631        :param update: force or not to update
3632        """
3633    def reset_page(self, state, first=False):
3634        """
3635        reset the state  if implemented
3636        """
3637    def onSmear(self, event):
3638        """
3639        Create a smear object if implemented
3640        """
3641    def onPinholeSmear(self, event):
3642        """
3643        Create a custom pinhole smear object if implemented
3644        """
3645    def onSlitSmear(self, event):
3646        """
3647        Create a custom slit smear object if implemented
3648        """
3649    def update_slit_smear(self):
3650        """
3651        called by kill_focus on pinhole TextCntrl
3652        to update the changes if implemented
3653        """
3654    def select_param(self, event):
3655        """
3656        Select TextCtrl  checked if implemented
3657        """
3658    def set_data(self, data=None):
3659        """
3660        Sets data if implemented
3661        """
3662    def _is_2D(self):
3663        """
3664        Check if data_name is Data2D if implemented
3665        """
3666    def _on_select_model(self, event=None):
3667        """
3668        call back for model selection if implemented
3669        """
3670    def get_weight_flag(self):
3671        """
3672        Get flag corresponding to a given weighting dI data if implemented
3673        """
3674    def _set_sizer_dispersion(self):
3675        """
3676        draw sizer for dispersity if implemented
3677        """
3678    def get_all_checked_params(self):
3679        """
3680        Found all parameters current check and add them to list of parameters
3681        to fit if implemented
3682        """
3683    def show_npts2fit(self):
3684        """
3685        setValue Npts for fitting if implemented
3686        """
3687    def _onModel2D(self, event):
3688        """
3689        toggle view of model from 1D to 2D  or 2D from 1D if implemented
3690        """
3691
3692
3693class ModelTextCtrl(wx.TextCtrl):
3694    """
3695    Text control for model and fit parameters.
3696    Binds the appropriate events for user interactions.
3697    Default callback methods can be overwritten on initialization
3698
3699    :param kill_focus_callback: callback method for EVT_KILL_FOCUS event
3700    :param set_focus_callback:  callback method for EVT_SET_FOCUS event
3701    :param mouse_up_callback:   callback method for EVT_LEFT_UP event
3702    :param text_enter_callback: callback method for EVT_TEXT_ENTER event
3703
3704    """
3705    # Set to True when the mouse is clicked while whole string is selected
3706    full_selection = False
3707    # Call back for EVT_SET_FOCUS events
3708    _on_set_focus_callback = None
3709
3710    def __init__(self, parent, id=-1,
3711                 value=wx.EmptyString,
3712                 pos=wx.DefaultPosition,
3713                 size=wx.DefaultSize,
3714                 style=0,
3715                 validator=wx.DefaultValidator,
3716                 name=wx.TextCtrlNameStr,
3717                 kill_focus_callback=None,
3718                 set_focus_callback=None,
3719                 mouse_up_callback=None,
3720                 text_enter_callback=None):
3721
3722        wx.TextCtrl.__init__(self, parent, id, value, pos,
3723                             size, style, validator, name)
3724
3725        # Bind appropriate events
3726        self._on_set_focus_callback = parent.onSetFocus \
3727            if set_focus_callback is None else set_focus_callback
3728        self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
3729        self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus
3730        if kill_focus_callback is None else kill_focus_callback)
3731        self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter
3732        if text_enter_callback is None else text_enter_callback)
3733        if not ON_MAC:
3734            self.Bind(wx.EVT_LEFT_UP, self._highlight_text
3735            if mouse_up_callback is None else mouse_up_callback)
3736
3737    def _on_set_focus(self, event):
3738        """
3739        Catch when the text control is set in focus to highlight the whole
3740        text if necessary
3741
3742        :param event: mouse event
3743
3744        """
3745        event.Skip()
3746        self.full_selection = True
3747        return self._on_set_focus_callback(event)
3748
3749    def _highlight_text(self, event):
3750        """
3751        Highlight text of a TextCtrl only of no text has be selected
3752
3753        :param event: mouse event
3754
3755        """
3756        # Make sure the mouse event is available to other listeners
3757        event.Skip()
3758        control = event.GetEventObject()
3759        if self.full_selection:
3760            self.full_selection = False
3761            # Check that we have a TextCtrl
3762            if issubclass(control.__class__, wx.TextCtrl):
3763                # Check whether text has been selected,
3764                # if not, select the whole string
3765                (start, end) = control.GetSelection()
3766                if start == end:
3767                    control.SetSelection(-1, -1)
3768
3769    def _silent_kill_focus(self, event):
3770        """
3771        Save the state of the page
3772        """
3773
3774        event.Skip()
3775        # pass
Note: See TracBrowser for help on using the repository browser.