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

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 20522e1 was 20522e1, checked in by jhbakker, 7 years ago

Fixes based on Jeff's comments (20170119). Tested with 1D SESANS data on
Windows 10 machine. Needs to be tested with 1D and 2D SANS data.

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