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

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since af1187a was af1187a, checked in by Tim Snow <tim.snow@…>, 7 years ago

Remove print statements

Removal of debugging print statements

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