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

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 a6fccd7 was a6fccd7, checked in by krzywon, 8 years ago

Merge branch 'master' into ticket-795

  • Property mode set to 100644
File size: 143.0 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            formfactor = state.formfactorcombobox.split(":")
1108            if isinstance(formfactor, list):
1109                formfactor = formfactor[0]
1110            for list_item in value:
1111                if formfactor in list_item:
1112                    return self.categorybox.Items.index(key)
1113        return 0
1114
1115    def reset_page_helper(self, state):
1116        """
1117        Use page_state and change the state of existing page
1118
1119        :precondition: the page is already drawn or created
1120
1121        :postcondition: the state of the underlying data change as well as the
1122            state of the graphic interface
1123        """
1124        if state is None:
1125            return
1126        # set data, etc. from the state
1127        # reset page between theory and fitting from bookmarking
1128        data = state.data
1129
1130        if data is None:
1131            data_min = state.qmin
1132            data_max = state.qmax
1133            self.qmin_x = data_min
1134            self.qmax_x = data_max
1135            self.qmin.SetValue(str(data_min))
1136            self.qmax.SetValue(str(data_max))
1137
1138            self.state.data = data
1139            self.state.qmin = self.qmin_x
1140            self.state.qmax = self.qmax_x
1141        else:
1142            self.set_data(data)
1143
1144        self.enable2D = state.enable2D
1145        try:
1146            self.magnetic_on = state.magnetic_on
1147        except:
1148            # Backward compatibility (for older state files)
1149            self.magnetic_on = False
1150
1151        self.disp_cb_dict = state.disp_cb_dict
1152        self.disp_list = state.disp_list
1153
1154        # fill model combobox
1155        self._show_combox_helper()
1156        # select the current model
1157        state._convert_to_sasmodels()
1158        state.categorycombobox = unicode(state.categorycombobox)
1159        if state.categorycombobox in self.categorybox.Items:
1160            category_pos = self.categorybox.Items.index(
1161                state.categorycombobox)
1162        else:
1163            # Look in master list for model name (model.lower)
1164            category_pos = self.get_cat_combo_box_pos(state)
1165
1166        self.categorybox.Select(category_pos)
1167        self._show_combox(None)
1168        from models import PLUGIN_NAME_BASE
1169        if self.categorybox.GetValue() == 'Customized Models' \
1170                and PLUGIN_NAME_BASE not in state.formfactorcombobox:
1171            state.formfactorcombobox = \
1172                PLUGIN_NAME_BASE + state.formfactorcombobox
1173        formfactor_pos = 0
1174        for ind_form in range(self.formfactorbox.GetCount()):
1175            if self.formfactorbox.GetString(ind_form) == \
1176                                                (state.formfactorcombobox):
1177                formfactor_pos = int(ind_form)
1178                break
1179
1180        self.formfactorbox.Select(formfactor_pos)
1181
1182        structfactor_pos = 0
1183        if state.structurecombobox is not None:
1184            state.structurecombobox = unicode(state.structurecombobox)
1185            for ind_struct in range(self.structurebox.GetCount()):
1186                if self.structurebox.GetString(ind_struct) == \
1187                                                (state.structurecombobox):
1188                    structfactor_pos = int(ind_struct)
1189                    break
1190
1191        self.structurebox.SetSelection(structfactor_pos)
1192
1193        if state.multi_factor is not None:
1194            self.multifactorbox.SetSelection(state.multi_factor)
1195
1196        # draw the panel according to the new model parameter
1197        self._on_select_model(event=None)
1198
1199        # take care of 2D button
1200        if data is None and self.model_view.IsEnabled():
1201            if self.enable2D:
1202                self.model_view.SetLabel("2D Mode")
1203            else:
1204                self.model_view.SetLabel("1D Mode")
1205
1206        # reset state of checkbox,textcrtl  and  regular parameters value
1207        self._reset_parameters_state(self.orientation_params_disp,
1208                                     state.orientation_params_disp)
1209        self._reset_parameters_state(self.orientation_params,
1210                                     state.orientation_params)
1211        self._reset_parameters_state(self.str_parameters,
1212                                     state.str_parameters)
1213        self._reset_parameters_state(self.parameters, state.parameters)
1214        # display dispersion info layer
1215        self.enable_disp.SetValue(state.enable_disp)
1216        self.disable_disp.SetValue(state.disable_disp)
1217        # If the polydispersion is ON
1218        if state.enable_disp:
1219            # reset dispersion according the state
1220            self._set_dipers_Param(event=None)
1221            self._reset_page_disp_helper(state)
1222        # plotting range restore
1223        self._reset_plotting_range(state)
1224        # smearing info  restore
1225        if hasattr(self, "enable_smearer"):
1226            # set smearing value whether or not the data
1227            # contain the smearing info
1228            self.enable_smearer.SetValue(state.enable_smearer)
1229            self.disable_smearer.SetValue(state.disable_smearer)
1230            self.onSmear(event=None)
1231        self.pinhole_smearer.SetValue(state.pinhole_smearer)
1232        self.slit_smearer.SetValue(state.slit_smearer)
1233        try:
1234            self.dI_noweight.SetValue(state.dI_noweight)
1235            self.dI_didata.SetValue(state.dI_didata)
1236            self.dI_sqrdata.SetValue(state.dI_sqrdata)
1237            self.dI_idata.SetValue(state.dI_idata)
1238        except:
1239            # to support older state file formats
1240            self.dI_noweight.SetValue(False)
1241            self.dI_didata.SetValue(True)
1242            self.dI_sqrdata.SetValue(False)
1243            self.dI_idata.SetValue(False)
1244
1245        # we have two more options for smearing
1246        if self.pinhole_smearer.GetValue():
1247            self.dx_min = state.dx_min
1248            self.dx_max = state.dx_max
1249            if self.dx_min is not None:
1250                self.smear_pinhole_min.SetValue(str(self.dx_min))
1251            if self.dx_max is not None:
1252                self.smear_pinhole_max.SetValue(str(self.dx_max))
1253            self.onPinholeSmear(event=None)
1254        elif self.slit_smearer.GetValue():
1255            self.dxl = state.dxl
1256            self.dxw = state.dxw
1257            if self.dxl is not None:
1258                self.smear_slit_height.SetValue(str(self.dxl))
1259            if self.dxw is not None:
1260                self.smear_slit_width.SetValue(str(self.dxw))
1261            else:
1262                self.smear_slit_width.SetValue('')
1263            self.onSlitSmear(event=None)
1264
1265        # reset state of checkbox,textcrtl  and dispersity parameters value
1266        self._reset_parameters_state(self.fittable_param, state.fittable_param)
1267        self._reset_parameters_state(self.fixed_param, state.fixed_param)
1268
1269        # draw the model with previous parameters value
1270        self._onparamEnter_helper()
1271        # reset the value of chisqr when not consistent with the value computed
1272        self.tcChi.SetValue(str(self.state.tcChi))
1273        # reset context menu items
1274        self._reset_context_menu()
1275
1276        # set the value of the current state to the state given as parameter
1277        self.state = state.clone()
1278        self.state.m_name = self.m_name
1279
1280    def _reset_page_disp_helper(self, state):
1281        """
1282        Help to rest page for dispersions
1283        """
1284        keys = self.model.getParamList()
1285        for item in keys:
1286            if item in self.disp_list and \
1287                            item not in self.model.details:
1288                self.model.details[item] = ["", None, None]
1289        # for k,v in self.state.disp_cb_dict.iteritems():
1290        self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1291        self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)
1292        self.values = copy.deepcopy(state.values)
1293        self.weights = copy.deepcopy(state.weights)
1294
1295        for key, disp_type in state._disp_obj_dict.iteritems():
1296            # disp_model = disp
1297            disp_model = POLYDISPERSITY_MODELS[disp_type]()
1298            self._disp_obj_dict[key] = disp_model
1299            param_name = key.split('.')[0]
1300            # Try to set dispersion only when available
1301            # for eg., pass the orient. angles for 1D Cal
1302            try:
1303                self.model.set_dispersion(param_name, disp_model)
1304                self.model._persistency_dict[key] = \
1305                    [state.values, state.weights]
1306            except Exception:
1307                logging.error(traceback.format_exc())
1308            selection = self._find_polyfunc_selection(disp_model)
1309            for list in self.fittable_param:
1310                if list[1] == key and list[7] is not None:
1311                    list[7].SetSelection(selection)
1312                    # For the array disp_model, set the values and weights
1313                    if selection == 1:
1314                        disp_model.set_weights(self.values[key],
1315                                               self.weights[key])
1316                        try:
1317                            # Diables all fittable params for array
1318                            list[0].SetValue(False)
1319                            list[0].Disable()
1320                            list[2].Disable()
1321                            list[5].Disable()
1322                            list[6].Disable()
1323                        except Exception:
1324                            logging.error(traceback.format_exc())
1325            # For array, disable all fixed params
1326            if selection == 1:
1327                for item in self.fixed_param:
1328                    if item[1].split(".")[0] == key.split(".")[0]:
1329                        # try it and pass it for the orientation for 1D
1330                        try:
1331                            item[2].Disable()
1332                        except Exception:
1333                            logging.error(traceback.format_exc())
1334
1335    def _selectDlg(self):
1336        """
1337        open a dialog file to selected the customized dispersity
1338        """
1339        if self.parent is not None:
1340            self._default_save_location = \
1341                        self._manager.parent.get_save_location()
1342        dlg = wx.FileDialog(self, "Choose a weight file",
1343                            self._default_save_location, "",
1344                            "*.*", wx.OPEN)
1345        path = None
1346        if dlg.ShowModal() == wx.ID_OK:
1347            path = dlg.GetPath()
1348        dlg.Destroy()
1349        return path
1350
1351    def _reset_context_menu(self):
1352        """
1353        reset the context menu
1354        """
1355        ids = iter(self._id_pool)  # Reusing ids for context menu
1356        for name, _ in self.state.saved_states.iteritems():
1357            self.number_saved_state += 1
1358            # Add item in the context menu
1359            wx_id = ids.next()
1360            msg = 'Save model and state %g' % self.number_saved_state
1361            self.popUpMenu.Append(wx_id, name, msg)
1362            wx.EVT_MENU(self, wx_id, self.onResetModel)
1363
1364    def _reset_plotting_range(self, state):
1365        """
1366        Reset the plotting range to a given state
1367        """
1368        self.qmin.SetValue(str(state.qmin))
1369        self.qmax.SetValue(str(state.qmax))
1370
1371    def _save_typeOfmodel(self):
1372        """
1373        save radiobutton containing the type model that can be selected
1374        """
1375        # self.state.shape_rbutton = self.shape_rbutton.GetValue()
1376        # self.state.shape_indep_rbutton = self.shape_indep_rbutton.GetValue()
1377        # self.state.struct_rbutton = self.struct_rbutton.GetValue()
1378        # self.state.plugin_rbutton = self.plugin_rbutton.GetValue()
1379        self.state.structurecombobox = self.structurebox.GetValue()
1380        self.state.formfactorcombobox = self.formfactorbox.GetValue()
1381        self.state.categorycombobox = self.categorybox.GetValue()
1382
1383        # post state to fit panel
1384        event = PageInfoEvent(page=self)
1385        wx.PostEvent(self.parent, event)
1386
1387    def _save_plotting_range(self):
1388        """
1389        save the state of plotting range
1390        """
1391        self.state.qmin = self.qmin_x
1392        self.state.qmax = self.qmax_x
1393        self.state.npts = self.npts_x
1394
1395    def _onparamEnter_helper(self, is_modified=False):
1396        """
1397        check if values entered by the user are changed and valid to replot
1398        model
1399        """
1400        # Flag to register when a parameter has changed.
1401        # is_modified = False
1402        self.fitrange = True
1403        is_2Ddata = False
1404        # self._undo.Enable(True)
1405        # check if 2d data
1406        if self.data.__class__.__name__ == "Data2D":
1407            is_2Ddata = True
1408        if self.model is not None:
1409            # Either we get a is_modified = True passed in because
1410            # _update_paramv_on_fit() has been called already or
1411            # we need to check here ourselves.
1412            if not is_modified:
1413                is_modified = (self._check_value_enter(self.fittable_param)
1414                               or self._check_value_enter(self.fixed_param)
1415                               or self._check_value_enter(self.parameters))
1416
1417            # Here we should check whether the boundaries have been modified.
1418            # If qmin and qmax have been modified, update qmin and qmax and
1419            # set the is_modified flag to True
1420            if self._validate_qrange(self.qmin, self.qmax):
1421                tempmin = float(self.qmin.GetValue())
1422                if tempmin != self.qmin_x:
1423                    self.qmin_x = tempmin
1424                    is_modified = True
1425                tempmax = float(self.qmax.GetValue())
1426                if tempmax != self.qmax_x:
1427                    self.qmax_x = tempmax
1428                    is_modified = True
1429                if is_2Ddata:
1430                    is_modified = self._validate_Npts()
1431                else:
1432                    is_modified = self._validate_Npts_1D()
1433            else:
1434                self.fitrange = False
1435
1436            # if any value is modify draw model with new value
1437            if not self.fitrange:
1438                # self.btFit.Disable()
1439                if is_2Ddata:
1440                    self.btEditMask.Disable()
1441            else:
1442                if is_2Ddata and self.data.is_data and not self.batch_on:
1443                    self.btEditMask.Enable(True)
1444            if is_modified and self.fitrange:
1445                # Theory case: need to get npts value to draw
1446                self.npts_x = float(self.Npts_total.GetValue())
1447                self.Npts_fit.SetValue(str(self.Npts_total.GetValue()))
1448                self._save_plotting_range()
1449                self.create_default_data()
1450                self.state_change = True
1451                self._draw_model()
1452                # Time delay has been introduced to prevent _handle error
1453                # on Windows
1454                # This part of code is executed when model is selected and
1455                # it's parameters are changed (with respect to previously
1456                # selected model). There are two Iq evaluations occuring one
1457                # after another and therefore there may be compilation error
1458                # if model is calculated for the first time.
1459                # This seems to be Windows only issue - haven't tested on Linux
1460                # though.The proper solution (other than time delay) requires
1461                # more fundemental code refatoring
1462                # Wojtek P. Nov 7, 2016
1463                if not ON_MAC:
1464                    time.sleep(0.1)
1465                self.Refresh()
1466
1467        # logging.info("is_modified flag set to %g",is_modified)
1468        return is_modified
1469
1470    def _update_paramv_on_fit(self):
1471        """
1472        make sure that update param values just before the fitting
1473        """
1474        # flag for qmin qmax check values
1475        flag = True
1476        self.fitrange = True
1477        is_modified = False
1478
1479        # wx.PostEvent(self._manager.parent, StatusEvent(status=" \
1480        # updating ... ",type="update"))
1481
1482        # So make sure that update param values on_Fit.
1483        # self._undo.Enable(True)
1484        if self.model is not None:
1485            if self.Npts_total.GetValue() != self.Npts_fit.GetValue():
1486                if not self.data.is_data:
1487                    self._manager.page_finder[self.uid].set_fit_data(
1488                        data=[self.data])
1489            # Check the values
1490            is_modified = (self._check_value_enter(self.fittable_param)
1491                           or self._check_value_enter(self.fixed_param)
1492                           or self._check_value_enter(self.parameters))
1493
1494            # If qmin and qmax have been modified, update qmin and qmax and
1495            # Here we should check whether the boundaries have been modified.
1496            # If qmin and qmax have been modified, update qmin and qmax and
1497            # set the is_modified flag to True
1498            self.fitrange = self._validate_qrange(self.qmin, self.qmax)
1499            if self.fitrange:
1500                tempmin = float(self.qmin.GetValue())
1501                if tempmin != self.qmin_x:
1502                    self.qmin_x = tempmin
1503                tempmax = float(self.qmax.GetValue())
1504                if tempmax != self.qmax_x:
1505                    self.qmax_x = tempmax
1506                if tempmax == tempmin:
1507                    flag = False
1508                temp_smearer = None
1509                if not self.disable_smearer.GetValue():
1510                    temp_smearer = self.current_smearer
1511                    if self.slit_smearer.GetValue():
1512                        flag = self.update_slit_smear()
1513                    elif self.pinhole_smearer.GetValue():
1514                        flag = self.update_pinhole_smear()
1515                    else:
1516                        enable_smearer = not self.disable_smearer.GetValue()
1517                        self._manager.set_smearer(smearer=temp_smearer,
1518                                                  uid=self.uid,
1519                                                  fid=self.data.id,
1520                                                  qmin=float(self.qmin_x),
1521                                                  qmax=float(self.qmax_x),
1522                                                  enable_smearer=enable_smearer,
1523                                                  draw=False)
1524                elif not self._is_2D():
1525                    enable_smearer = not self.disable_smearer.GetValue()
1526                    self._manager.set_smearer(smearer=temp_smearer,
1527                                              qmin=float(self.qmin_x),
1528                                              uid=self.uid,
1529                                              fid=self.data.id,
1530                                              qmax=float(self.qmax_x),
1531                                              enable_smearer=enable_smearer,
1532                                              draw=False)
1533                    if self.data is not None:
1534                        index_data = ((self.qmin_x <= self.data.x) &
1535                                      (self.data.x <= self.qmax_x))
1536                        val = str(len(self.data.x[index_data]))
1537                        self.Npts_fit.SetValue(val)
1538                    else:
1539                        # No data in the panel
1540                        try:
1541                            self.npts_x = float(self.Npts_total.GetValue())
1542                        except:
1543                            flag = False
1544                            return flag
1545                    flag = True
1546                if self._is_2D():
1547                    # only 2D case set mask
1548                    flag = self._validate_Npts()
1549                    if not flag:
1550                        return flag
1551            else:
1552                flag = False
1553        else:
1554            flag = False
1555
1556        # For invalid q range, disable the mask editor and fit button, vs.
1557        if not self.fitrange:
1558            if self._is_2D():
1559                self.btEditMask.Disable()
1560        else:
1561            if self._is_2D() and self.data.is_data and not self.batch_on:
1562                self.btEditMask.Enable(True)
1563
1564        if not flag:
1565            msg = "Cannot Plot or Fit :Must select a "
1566            msg += " model or Fitting range is not valid!!!  "
1567            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1568
1569        try:
1570            self.save_current_state()
1571        except Exception:
1572            logging.error(traceback.format_exc())
1573
1574        return flag, is_modified
1575
1576    def _reset_parameters_state(self, listtorestore, statelist):
1577        """
1578        Reset the parameters at the given state
1579        """
1580        if len(statelist) == 0 or len(listtorestore) == 0:
1581            return
1582
1583        for j in range(len(listtorestore)):
1584            for param in statelist:
1585                if param[1] == listtorestore[j][1]:
1586                    item_page = listtorestore[j]
1587                    item_page_info = param
1588                    if (item_page_info[1] == "theta" or item_page_info[1] ==
1589                            "phi") and not self._is_2D():
1590                        break
1591                    # change the state of the check box for simple parameters
1592                    if item_page[0] is not None:
1593                        item_page[0].SetValue(item_page_info[0])
1594                    if item_page[2] is not None:
1595                        item_page[2].SetValue(item_page_info[2])
1596                        if item_page[2].__class__.__name__ == "ComboBox":
1597                            if item_page_info[2] in self.model.fun_list:
1598                                fun_val = self.model.fun_list[item_page_info[2]]
1599                                self.model.setParam(item_page_info[1], fun_val)
1600                    if item_page[3] is not None:
1601                        # show or hide text +/-
1602                        if item_page_info[2]:
1603                            item_page[3].Show(True)
1604                        else:
1605                            item_page[3].Hide()
1606                    if item_page[4] is not None:
1607                        # show of hide the text crtl for fitting error
1608                        if item_page_info[4][0]:
1609                            item_page[4].Show(True)
1610                            item_page[4].SetValue(str(item_page_info[4][1]))
1611                        else:
1612                            item_page[3].Hide()
1613                    if item_page[5] is not None:
1614                        # show of hide the text crtl for fitting error
1615                        item_page[5].Show(True)
1616                        item_page[5].SetValue(str(item_page_info[5][1]))
1617                    if item_page[6] is not None:
1618                        # show of hide the text crtl for fitting error
1619                        item_page[6].Show(True)
1620                        item_page[6].SetValue(str(item_page_info[6][1]))
1621                    break
1622
1623    def _reset_strparam_state(self, listtorestore, statelist):
1624        """
1625        Reset the string parameters at the given state
1626        """
1627        if len(statelist) == 0:
1628            return
1629
1630        listtorestore = copy.deepcopy(statelist)
1631
1632        for j in range(len(listtorestore)):
1633            item_page = listtorestore[j]
1634            item_page_info = statelist[j]
1635            # change the state of the check box for simple parameters
1636
1637            if item_page[0] is not None:
1638                item_page[0].SetValue(format_number(item_page_info[0], True))
1639
1640            if item_page[2] is not None:
1641                param_name = item_page_info[1]
1642                value = item_page_info[2]
1643                selection = value
1644                if value in self.model.fun_list:
1645                    selection = self.model.fun_list[value]
1646                item_page[2].SetValue(selection)
1647                self.model.setParam(param_name, selection)
1648
1649    def _copy_parameters_state(self, listtocopy, statelist):
1650        """
1651        copy the state of button
1652
1653        :param listtocopy: the list of check button to copy
1654        :param statelist: list of state object to store the current state
1655
1656        """
1657        if len(listtocopy) == 0:
1658            return
1659
1660        for item in listtocopy:
1661
1662            checkbox_state = None
1663            if item[0] is not None:
1664                checkbox_state = item[0].GetValue()
1665            parameter_name = item[1]
1666            parameter_value = None
1667            if item[2] is not None:
1668                parameter_value = item[2].GetValue()
1669            static_text = None
1670            if item[3] is not None:
1671                static_text = item[3].IsShown()
1672            error_value = None
1673            error_state = None
1674            if item[4] is not None:
1675                error_value = item[4].GetValue()
1676                error_state = item[4].IsShown()
1677
1678            min_value = None
1679            min_state = None
1680            if item[5] is not None:
1681                min_value = item[5].GetValue()
1682                min_state = item[5].IsShown()
1683
1684            max_value = None
1685            max_state = None
1686            if item[6] is not None:
1687                max_value = item[6].GetValue()
1688                max_state = item[6].IsShown()
1689            unit = None
1690            if item[7] is not None:
1691                unit = item[7].GetLabel()
1692
1693            statelist.append([checkbox_state, parameter_name, parameter_value,
1694                              static_text, [error_state, error_value],
1695                              [min_state, min_value],
1696                              [max_state, max_value], unit])
1697
1698    def _draw_model(self, update_chisqr=True, source='model'):
1699        """
1700        Method to draw or refresh a plotted model.
1701        The method will use the data member from the model page
1702        to build a call to the fitting perspective manager.
1703
1704        :param chisqr: update chisqr value [bool]
1705        """
1706        wx.CallAfter(self._draw_model_after, update_chisqr, source)
1707
1708    def _draw_model_after(self, update_chisqr=True, source='model'):
1709        """
1710        Method to draw or refresh a plotted model.
1711        The method will use the data member from the model page
1712        to build a call to the fitting perspective manager.
1713
1714        :param chisqr: update chisqr value [bool]
1715        """
1716        # if self.check_invalid_panel():
1717        #    return
1718        if self.model is not None:
1719            temp_smear = None
1720            if hasattr(self, "enable_smearer"):
1721                if not self.disable_smearer.GetValue():
1722                    temp_smear = self.current_smearer
1723            # compute weight for the current data
1724            from sas.sasgui.perspectives.fitting.utils import get_weight
1725            flag = self.get_weight_flag()
1726            weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
1727            toggle_mode_on = self.model_view.IsEnabled()
1728            is_2d = self._is_2D()
1729            self._manager.draw_model(self.model,
1730                                     data=self.data,
1731                                     smearer=temp_smear,
1732                                     qmin=float(self.qmin_x),
1733                                     qmax=float(self.qmax_x),
1734                                     page_id=self.uid,
1735                                     toggle_mode_on=toggle_mode_on,
1736                                     state=self.state,
1737                                     enable2D=is_2d,
1738                                     update_chisqr=update_chisqr,
1739                                     source='model',
1740                                     weight=weight)
1741
1742    def _on_show_sld(self, event=None):
1743        """
1744        Plot SLD profile
1745        """
1746        # get profile data
1747        x, y = self.model.getProfile()
1748
1749        from sas.sasgui.plottools import Data1D as pf_data1d
1750        # from sas.sasgui.perspectives.theory.profile_dialog import SLDPanel
1751        from sas.sasgui.guiframe.local_perspectives.plotting.profile_dialog \
1752            import SLDPanel
1753        sld_data = pf_data1d(x, y)
1754        sld_data.name = 'SLD'
1755        sld_data.axes = self.sld_axes
1756        self.panel = SLDPanel(self, data=sld_data, axes=self.sld_axes,
1757                              id=wx.ID_ANY)
1758        self.panel.ShowModal()
1759
1760    def _set_multfactor_combobox(self, multiplicity=10):
1761        """
1762        Set comboBox for muitfactor of CoreMultiShellModel
1763        :param multiplicit: no. of multi-functionality
1764        """
1765        # build content of the combobox
1766        for idx in range(0, multiplicity):
1767            self.multifactorbox.Append(str(idx), int(idx))
1768        self._hide_multfactor_combobox()
1769
1770    def _show_multfactor_combobox(self):
1771        """
1772        Show the comboBox of muitfactor of CoreMultiShellModel
1773        """
1774        if not self.mutifactor_text.IsShown():
1775            self.mutifactor_text.Show(True)
1776            self.mutifactor_text1.Show(True)
1777        if not self.multifactorbox.IsShown():
1778            self.multifactorbox.Show(True)
1779
1780    def _hide_multfactor_combobox(self):
1781        """
1782        Hide the comboBox of muitfactor of CoreMultiShellModel
1783        """
1784        if self.mutifactor_text.IsShown():
1785            self.mutifactor_text.Hide()
1786            self.mutifactor_text1.Hide()
1787        if self.multifactorbox.IsShown():
1788            self.multifactorbox.Hide()
1789
1790    def formfactor_combo_init(self):
1791        """
1792        First time calls _show_combox_helper
1793        """
1794        self._show_combox(None)
1795
1796    def _show_combox_helper(self):
1797        """
1798        Fill panel's combo box according to the type of model selected
1799        """
1800        custom_model = 'Customized Models'
1801        mod_cat = self.categorybox.GetStringSelection()
1802        self.structurebox.SetSelection(0)
1803        self.structurebox.Disable()
1804        self.formfactorbox.Clear()
1805        if mod_cat is None:
1806            return
1807        m_list = []
1808        try:
1809            if mod_cat == custom_model:
1810                for model in self.model_list_box[mod_cat]:
1811                    m_list.append(self.model_dict[model.name])
1812            else:
1813                cat_dic = self.master_category_dict[mod_cat]
1814                for (model, enabled) in cat_dic:
1815                    if enabled:
1816                        m_list.append(self.model_dict[model])
1817        except Exception:
1818            msg = traceback.format_exc()
1819            wx.PostEvent(self._manager.parent,
1820                         StatusEvent(status=msg, info="error"))
1821        self._populate_box(self.formfactorbox, m_list)
1822
1823    def _on_modify_cat(self, event=None):
1824        """
1825        Called when category manager is opened
1826        """
1827        self._manager.parent.on_category_panel(event)
1828
1829    def _show_combox(self, event=None):
1830        """
1831        Show combox box associate with type of model selected
1832        """
1833        self.Show(False)
1834        self._show_combox_helper()
1835        self._on_select_model(event=None)
1836        self.Show(True)
1837        self._save_typeOfmodel()
1838        self.sizer4_4.Layout()
1839        self.sizer4.Layout()
1840        self.Layout()
1841        self.Refresh()
1842
1843    def _populate_box(self, combobox, list):
1844        """
1845        fill combox box with dict item
1846
1847        :param list: contains item to fill the combox
1848            item must model class
1849        """
1850        mlist = []
1851        for models in list:
1852            if models.name != "NoStructure":
1853                mlist.append((models.name, models))
1854
1855        # Sort the models
1856        mlist_sorted = sorted(mlist)
1857        for item in mlist_sorted:
1858            combobox.Append(item[0], item[1])
1859        return 0
1860
1861    def _onQrangeEnter(self, event):
1862        """
1863        Check validity of value enter in the Q range field
1864
1865        """
1866        tcrtl = event.GetEventObject()
1867        # Clear msg if previously shown.
1868        msg = ""
1869        wx.PostEvent(self.parent, StatusEvent(status=msg))
1870        # Flag to register when a parameter has changed.
1871        if tcrtl.GetValue().lstrip().rstrip() != "":
1872            try:
1873                float(tcrtl.GetValue())
1874                tcrtl.SetBackgroundColour(wx.WHITE)
1875                # If qmin and qmax have been modified, update qmin and qmax
1876                if self._validate_qrange(self.qmin, self.qmax):
1877                    tempmin = float(self.qmin.GetValue())
1878                    if tempmin != self.qmin_x:
1879                        self.qmin_x = tempmin
1880                    tempmax = float(self.qmax.GetValue())
1881                    if tempmax != self.qmax_x:
1882                        self.qmax_x = tempmax
1883                else:
1884                    tcrtl.SetBackgroundColour("pink")
1885                    msg = "Model Error: wrong value entered: %s" % \
1886                          sys.exc_info()[1]
1887                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1888                    return
1889            except:
1890                tcrtl.SetBackgroundColour("pink")
1891                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1892                wx.PostEvent(self.parent, StatusEvent(status=msg))
1893                return
1894            # Check if # of points for theory model are valid(>0).
1895            if self.npts is not None:
1896                if check_float(self.npts):
1897                    temp_npts = float(self.npts.GetValue())
1898                    if temp_npts != self.num_points:
1899                        self.num_points = temp_npts
1900                else:
1901                    msg = "Cannot plot: No points in Q range!!!  "
1902                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1903        else:
1904            tcrtl.SetBackgroundColour("pink")
1905            msg = "Model Error: wrong value entered!!!"
1906            wx.PostEvent(self.parent, StatusEvent(status=msg))
1907        self.save_current_state()
1908        event = PageInfoEvent(page=self)
1909        wx.PostEvent(self.parent, event)
1910        self.state_change = False
1911        # Draw the model for a different range
1912        if not self.data.is_data:
1913            self.create_default_data()
1914        self._draw_model()
1915
1916    def _theory_qrange_enter(self, event):
1917        """
1918        Check validity of value enter in the Q range field
1919        """
1920
1921        tcrtl = event.GetEventObject()
1922        # Clear msg if previously shown.
1923        msg = ""
1924        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1925        # Flag to register when a parameter has changed.
1926        is_modified = False
1927        if tcrtl.GetValue().lstrip().rstrip() != "":
1928            try:
1929                value = float(tcrtl.GetValue())
1930                tcrtl.SetBackgroundColour(wx.WHITE)
1931
1932                # If qmin and qmax have been modified, update qmin and qmax
1933                if self._validate_qrange(self.theory_qmin, self.theory_qmax):
1934                    tempmin = float(self.theory_qmin.GetValue())
1935                    if tempmin != self.theory_qmin_x:
1936                        self.theory_qmin_x = tempmin
1937                    tempmax = float(self.theory_qmax.GetValue())
1938                    if tempmax != self.qmax_x:
1939                        self.theory_qmax_x = tempmax
1940                else:
1941                    tcrtl.SetBackgroundColour("pink")
1942                    msg = "Model Error: wrong value entered: %s" % \
1943                          sys.exc_info()[1]
1944                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1945                    return
1946            except:
1947                tcrtl.SetBackgroundColour("pink")
1948                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
1949                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1950                return
1951            # Check if # of points for theory model are valid(>0).
1952            if self.Npts_total.IsEditable():
1953                if check_float(self.Npts_total):
1954                    temp_npts = float(self.Npts_total.GetValue())
1955                    if temp_npts != self.num_points:
1956                        self.num_points = temp_npts
1957                        is_modified = True
1958                else:
1959                    msg = "Cannot Plot: No points in Q range!!!  "
1960                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1961        else:
1962            tcrtl.SetBackgroundColour("pink")
1963            msg = "Model Error: wrong value entered!!!"
1964            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
1965        self.save_current_state()
1966        event = PageInfoEvent(page=self)
1967        wx.PostEvent(self.parent, event)
1968        self.state_change = False
1969        # Draw the model for a different range
1970        self.create_default_data()
1971        self._draw_model()
1972
1973    def _on_select_model_helper(self):
1974        """
1975        call back for model selection
1976        """
1977        # reset dictionary containing reference to dispersion
1978        self._disp_obj_dict = {}
1979        self.disp_cb_dict = {}
1980        self.temp_multi_functional = False
1981        f_id = self.formfactorbox.GetCurrentSelection()
1982        # For MAC
1983        form_factor = None
1984        if f_id >= 0:
1985            form_factor = self.formfactorbox.GetClientData(f_id)
1986
1987        if form_factor is None or \
1988            not hasattr(form_factor, 'is_form_factor') or \
1989                not form_factor.is_form_factor:
1990            self.structurebox.Hide()
1991            self.text2.Hide()
1992            self.structurebox.Disable()
1993            self.structurebox.SetSelection(0)
1994            self.text2.Disable()
1995        else:
1996            self.structurebox.Show()
1997            self.text2.Show()
1998            self.structurebox.Enable()
1999            self.text2.Enable()
2000
2001        if form_factor is not None:
2002            # set multifactor for Mutifunctional models
2003            if form_factor.is_multiplicity_model:
2004                m_id = self.multifactorbox.GetCurrentSelection()
2005                multiplicity = form_factor.multiplicity_info[0]
2006                self.multifactorbox.Clear()
2007                self._set_multfactor_combobox(multiplicity)
2008                self._show_multfactor_combobox()
2009                # ToDo: this info should be called directly from the model
2010                text = form_factor.multiplicity_info[1]  # 'No. of Shells: '
2011
2012                self.mutifactor_text.SetLabel(text)
2013                if m_id > multiplicity - 1:
2014                    # default value
2015                    m_id = 1
2016
2017                self.multi_factor = self.multifactorbox.GetClientData(m_id)
2018                if self.multi_factor is None:
2019                    self.multi_factor = 0
2020                self.multifactorbox.SetSelection(m_id)
2021                # Check len of the text1 and max_multiplicity
2022                text = ''
2023                if form_factor.multiplicity_info[0] == \
2024                        len(form_factor.multiplicity_info[2]):
2025                    text = form_factor.multiplicity_info[2][self.multi_factor]
2026                self.mutifactor_text1.SetLabel(text)
2027                # Check if model has  get sld profile.
2028                if len(form_factor.multiplicity_info[3]) > 0:
2029                    self.sld_axes = form_factor.multiplicity_info[3]
2030                    self.show_sld_button.Show(True)
2031                else:
2032                    self.sld_axes = ""
2033            else:
2034                self._hide_multfactor_combobox()
2035                self.show_sld_button.Hide()
2036                self.multi_factor = None
2037        else:
2038            self._hide_multfactor_combobox()
2039            self.show_sld_button.Hide()
2040            self.multi_factor = None
2041
2042        s_id = self.structurebox.GetCurrentSelection()
2043        struct_factor = self.structurebox.GetClientData(s_id)
2044
2045        if struct_factor is not None:
2046            from sasmodels.sasview_model import MultiplicationModel
2047            self.model = MultiplicationModel(form_factor(self.multi_factor),
2048                                             struct_factor())
2049            # multifunctional form factor
2050            if len(form_factor.non_fittable) > 0:
2051                self.temp_multi_functional = True
2052        elif form_factor is not None:
2053            if self.multi_factor is not None:
2054                self.model = form_factor(self.multi_factor)
2055            else:
2056                # old style plugin models do not accept a multiplicity argument
2057                self.model = form_factor()
2058        else:
2059            self.model = None
2060            return
2061
2062        # check if model has magnetic parameters
2063        if len(self.model.magnetic_params) > 0:
2064            self._has_magnetic = True
2065        else:
2066            self._has_magnetic = False
2067        # post state to fit panel
2068        self.state.parameters = []
2069        self.state.model = self.model
2070        self.state.qmin = self.qmin_x
2071        self.state.multi_factor = self.multi_factor
2072        self.disp_list = self.model.getDispParamList()
2073        self.state.disp_list = self.disp_list
2074        self.on_set_focus(None)
2075        self.Layout()
2076
2077    def _validate_qrange(self, qmin_ctrl, qmax_ctrl):
2078        """
2079        Verify that the Q range controls have valid values
2080        and that Qmin < Qmax.
2081
2082        :param qmin_ctrl: text control for Qmin
2083        :param qmax_ctrl: text control for Qmax
2084
2085        :return: True is the Q range is value, False otherwise
2086
2087        """
2088        qmin_validity = check_float(qmin_ctrl)
2089        qmax_validity = check_float(qmax_ctrl)
2090        if not (qmin_validity and qmax_validity):
2091            return False
2092        else:
2093            qmin = float(qmin_ctrl.GetValue())
2094            qmax = float(qmax_ctrl.GetValue())
2095            if qmin < qmax:
2096                # Make sure to set both colours white.
2097                qmin_ctrl.SetBackgroundColour(wx.WHITE)
2098                qmin_ctrl.Refresh()
2099                qmax_ctrl.SetBackgroundColour(wx.WHITE)
2100                qmax_ctrl.Refresh()
2101            else:
2102                qmin_ctrl.SetBackgroundColour("pink")
2103                qmin_ctrl.Refresh()
2104                qmax_ctrl.SetBackgroundColour("pink")
2105                qmax_ctrl.Refresh()
2106                msg = "Invalid Q range: Q min must be smaller than Q max"
2107                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2108                return False
2109        return True
2110
2111    def _validate_Npts(self):
2112        """
2113        Validate the number of points for fitting is more than 10 points.
2114        If valid, setvalues Npts_fit otherwise post msg.
2115        """
2116        # default flag
2117        flag = True
2118        # Theory
2119        if self.data is None and self.enable2D:
2120            return flag
2121        for data in self.data_list:
2122            # q value from qx and qy
2123            radius = numpy.sqrt(data.qx_data * data.qx_data +
2124                                data.qy_data * data.qy_data)
2125            # get unmasked index
2126            index_data = (float(self.qmin.GetValue()) <= radius) & \
2127                         (radius <= float(self.qmax.GetValue()))
2128            index_data = (index_data) & (data.mask)
2129            index_data = (index_data) & (numpy.isfinite(data.data))
2130
2131            if len(index_data[index_data]) < 10:
2132                # change the color pink.
2133                self.qmin.SetBackgroundColour("pink")
2134                self.qmin.Refresh()
2135                self.qmax.SetBackgroundColour("pink")
2136                self.qmax.Refresh()
2137                msg = "Data Error: "
2138                msg += "Too few points in %s." % data.name
2139                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2140                self.fitrange = False
2141                flag = False
2142            else:
2143                self.Npts_fit.SetValue(str(len(index_data[index_data])))
2144                self.fitrange = True
2145
2146        return flag
2147
2148    def _validate_Npts_1D(self):
2149        """
2150        Validate the number of points for fitting is more than 5 points.
2151        If valid, setvalues Npts_fit otherwise post msg.
2152        """
2153        # default flag
2154        flag = True
2155        # Theory
2156        if self.data is None:
2157            return flag
2158        for data in self.data_list:
2159            # q value from qx and qy
2160            radius = data.x
2161            # get unmasked index
2162            index_data = (float(self.qmin.GetValue()) <= radius) & \
2163                         (radius <= float(self.qmax.GetValue()))
2164            index_data = (index_data) & (numpy.isfinite(data.y))
2165
2166            if len(index_data[index_data]) < 5:
2167                # change the color pink.
2168                self.qmin.SetBackgroundColour("pink")
2169                self.qmin.Refresh()
2170                self.qmax.SetBackgroundColour("pink")
2171                self.qmax.Refresh()
2172                msg = "Data Error: "
2173                msg += "Too few points in %s." % data.name
2174                wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2175                self.fitrange = False
2176                flag = False
2177            else:
2178                self.Npts_fit.SetValue(str(len(index_data[index_data])))
2179                self.fitrange = True
2180
2181        return flag
2182
2183    def _check_value_enter(self, list):
2184        """
2185        :param list: model parameter and panel info
2186        :Note: each item of the list should be as follow:
2187            item=[check button state, parameter's name,
2188                paramater's value, string="+/-",
2189                parameter's error of fit,
2190                parameter's minimum value,
2191                parameter's maximum value ,
2192                parameter's units]
2193
2194        Returns True if the model parameters have changed.
2195        """
2196        is_modified = False
2197        for item in list:
2198            # skip angle parameters for 1D
2199            if not self.enable2D and item in self.orientation_params:
2200                continue
2201
2202            value_ctrl = item[2]
2203            if not value_ctrl.IsEnabled():
2204                # ArrayDispersion disables PD, Min, Max, Npts, Nsigs
2205                continue
2206
2207            name = item[1]
2208            value_str = value_ctrl.GetValue().strip()
2209            if name.endswith(".npts"):
2210                validity = check_int(value_ctrl)
2211                if not validity:
2212                    continue
2213                value = int(value_str)
2214
2215            elif name.endswith(".nsigmas"):
2216                validity = check_float(value_ctrl)
2217                if not validity:
2218                    continue
2219                value = float(value_str)
2220
2221            else:  # value or polydispersity
2222
2223                # Check that min, max and value are floats
2224                min_ctrl, max_ctrl = item[5], item[6]
2225                min_str = min_ctrl.GetValue().strip()
2226                max_str = max_ctrl.GetValue().strip()
2227                validity = check_float(value_ctrl)
2228                if min_str != "":
2229                    validity = validity and check_float(min_ctrl)
2230                if max_str != "":
2231                    validity = validity and check_float(max_ctrl)
2232                if not validity:
2233                    continue
2234
2235                # Check that min is less than max
2236                low = -numpy.inf if min_str == "" else float(min_str)
2237                high = numpy.inf if max_str == "" else float(max_str)
2238                if high < low:
2239                    min_ctrl.SetBackgroundColour("pink")
2240                    min_ctrl.Refresh()
2241                    max_ctrl.SetBackgroundColour("pink")
2242                    max_ctrl.Refresh()
2243                    # msg = "Invalid fit range for %s: min must be smaller
2244                    # than max"%name
2245                    # wx.PostEvent(self._manager.parent,
2246                    # StatusEvent(status=msg))
2247                    continue
2248
2249                # Force value between min and max
2250                value = float(value_str)
2251                if value < low:
2252                    value = low
2253                    value_ctrl.SetValue(format_number(value))
2254                elif value > high:
2255                    value = high
2256                    value_ctrl.SetValue(format_number(value))
2257
2258                if name not in self.model.details.keys():
2259                    self.model.details[name] = ["", None, None]
2260                old_low, old_high = self.model.details[name][1:3]
2261                if old_low != low or old_high != high:
2262                    # The configuration has changed but it won't change the
2263                    # computed curve so no need to set is_modified to True
2264                    # is_modified = True
2265                    self.model.details[name][1:3] = low, high
2266
2267            # Update value in model if it has changed
2268            if value != self.model.getParam(name):
2269                self.model.setParam(name, value)
2270                is_modified = True
2271
2272        return is_modified
2273
2274    def _set_dipers_Param(self, event):
2275        """
2276        respond to self.enable_disp and self.disable_disp radio box.
2277        The dispersity object is reset inside the model into Gaussian.
2278        When the user select yes , this method display a combo box for
2279        more selection when the user selects No,the combo box disappears.
2280        Redraw the model with the default dispersity (Gaussian)
2281        """
2282        # On selction if no model exists.
2283        if self.model is None:
2284            self.disable_disp.SetValue(True)
2285            msg = "Please select a Model first..."
2286            wx.MessageBox(msg, 'Info')
2287            wx.PostEvent(self._manager.parent,
2288                         StatusEvent(status="Polydispersion: %s" % msg))
2289            return
2290
2291        self._reset_dispersity()
2292
2293        if self.model is None:
2294            self.model_disp.Hide()
2295            self.sizer4_4.Clear(True)
2296            return
2297
2298        if self.enable_disp.GetValue():
2299            # layout for model containing no dispersity parameters
2300
2301            self.disp_list = self.model.getDispParamList()
2302
2303            if len(self.disp_list) == 0 and len(self.disp_cb_dict) == 0:
2304                self._layout_sizer_noDipers()
2305            else:
2306                # set gaussian sizer
2307                self._on_select_Disp(event=None)
2308        else:
2309            self.sizer4_4.Clear(True)
2310
2311        # post state to fit panel
2312        self.save_current_state()
2313        if event is not None:
2314            event = PageInfoEvent(page=self)
2315            wx.PostEvent(self.parent, event)
2316        # draw the model with the current dispersity
2317
2318        # Wojtek P, Oct 8, 2016: Calling draw_model seems to be unessecary.
2319        # By comenting it we save an extra Iq calculation
2320        # self._draw_model()
2321
2322        # Need to use FitInside again here to replace the next four lines.
2323        # Otherwised polydispersity off does not resize the scrollwindow.
2324        # PDB Nov 28, 2015
2325        self.FitInside()
2326#        self.sizer4_4.Layout()
2327#        self.sizer5.Layout()
2328#        self.Layout()
2329#        self.Refresh()
2330
2331    def _layout_sizer_noDipers(self):
2332        """
2333        Draw a sizer with no dispersity info
2334        """
2335        ix = 0
2336        iy = 1
2337        self.fittable_param = []
2338        self.fixed_param = []
2339        self.orientation_params_disp = []
2340
2341        self.sizer4_4.Clear(True)
2342        text = "No polydispersity available for this model"
2343        model_disp = wx.StaticText(self, wx.ID_ANY, text)
2344        self.sizer4_4.Add(model_disp, (iy, ix), (1, 1),
2345                          wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 10)
2346        self.sizer4_4.Layout()
2347        self.sizer4.Layout()
2348
2349    def _reset_dispersity(self):
2350        """
2351        put gaussian dispersity into current model
2352        """
2353        if len(self.param_toFit) > 0:
2354            for item in self.fittable_param:
2355                if item in self.param_toFit:
2356                    self.param_toFit.remove(item)
2357
2358            for item in self.orientation_params_disp:
2359                if item in self.param_toFit:
2360                    self.param_toFit.remove(item)
2361
2362        self.fittable_param = []
2363        self.fixed_param = []
2364        self.orientation_params_disp = []
2365        self.values = {}
2366        self.weights = {}
2367
2368        # from sas.models.dispersion_models import GaussianDispersion
2369        from sasmodels.weights import GaussianDispersion
2370        if len(self.disp_cb_dict) == 0:
2371            self.save_current_state()
2372            self.sizer4_4.Clear(True)
2373            self.Layout()
2374            return
2375        if (len(self.disp_cb_dict) > 0):
2376            for p in self.disp_cb_dict:
2377                # The parameter was un-selected.
2378                # Go back to Gaussian model (with 0 pts)
2379                disp_model = GaussianDispersion()
2380
2381                self._disp_obj_dict[p] = disp_model
2382                # Set the new model as the dispersion object
2383                # for the selected parameter
2384                try:
2385                    self.model.set_dispersion(p, disp_model)
2386                except Exception:
2387                    logging.error(traceback.format_exc())
2388
2389        # save state into
2390        self.save_current_state()
2391        self.Layout()
2392        self.Refresh()
2393
2394    def _on_select_Disp(self, event):
2395        """
2396        allow selecting different dispersion
2397        self.disp_list should change type later .now only gaussian
2398        """
2399        self._set_sizer_dispersion()
2400
2401        # Redraw the model
2402        #  Wojtek P. Nov 7, 2016: Redrawing seems to be unnecessary here
2403        # self._draw_model()
2404        # self._undo.Enable(True)
2405        event = PageInfoEvent(page=self)
2406        wx.PostEvent(self.parent, event)
2407
2408        self.sizer4_4.Layout()
2409        self.sizer4.Layout()
2410        self.SetupScrolling()
2411
2412    def _on_disp_func(self, event=None):
2413        """
2414        Select a distribution function for the polydispersion
2415
2416        :Param event: ComboBox event
2417        """
2418        # get ready for new event
2419        if event is not None:
2420            event.Skip()
2421        # Get event object
2422        disp_box = event.GetEventObject()
2423
2424        # Try to select a Distr. function
2425        try:
2426            disp_box.SetBackgroundColour("white")
2427            selection = disp_box.GetCurrentSelection()
2428            param_name = disp_box.Name.split('.')[0]
2429            disp_name = disp_box.GetValue()
2430            dispersity = disp_box.GetClientData(selection)
2431
2432            # disp_model =  GaussianDispersion()
2433            disp_model = dispersity()
2434            # Get param names to reset the values of the param
2435            name1 = param_name + ".width"
2436            name2 = param_name + ".npts"
2437            name3 = param_name + ".nsigmas"
2438            # Check Disp. function whether or not it is 'array'
2439            if disp_name.lower() == "array":
2440                value2 = ""
2441                value3 = ""
2442                value1 = self._set_array_disp(name=name1, disp=disp_model)
2443            else:
2444                self._del_array_values(name1)
2445                # self._reset_array_disp(param_name)
2446                self._disp_obj_dict[name1] = disp_model
2447                self.model.set_dispersion(param_name, disp_model)
2448                self.state._disp_obj_dict[name1] = disp_model.type
2449
2450                value1 = str(format_number(self.model.getParam(name1), True))
2451                value2 = str(format_number(self.model.getParam(name2)))
2452                value3 = str(format_number(self.model.getParam(name3)))
2453            # Reset fittable polydispersin parameter value
2454            for item in self.fittable_param:
2455                if item[1] == name1:
2456                    item[2].SetValue(value1)
2457                    item[5].SetValue("")
2458                    item[6].SetValue("")
2459                    # Disable for array
2460                    if disp_name.lower() == "array":
2461                        item[0].SetValue(False)
2462                        item[0].Disable()
2463                        item[2].Disable()
2464                        item[3].Show(False)
2465                        item[4].Show(False)
2466                        item[5].Disable()
2467                        item[6].Disable()
2468                    else:
2469                        item[0].Enable()
2470                        item[2].Enable()
2471                        item[3].Show(True)
2472                        item[4].Show(True)
2473                        item[5].Enable()
2474                        item[6].Enable()
2475                    break
2476            # Reset fixed polydispersion params
2477            for item in self.fixed_param:
2478                if item[1] == name2:
2479                    item[2].SetValue(value2)
2480                    # Disable Npts for array
2481                    if disp_name.lower() == "array":
2482                        item[2].Disable()
2483                    else:
2484                        item[2].Enable()
2485                if item[1] == name3:
2486                    item[2].SetValue(value3)
2487                    # Disable Nsigs for array
2488                    if disp_name.lower() == "array":
2489                        item[2].Disable()
2490                    else:
2491                        item[2].Enable()
2492
2493            # Make sure the check box updated
2494            self.get_all_checked_params()
2495
2496            # update params
2497            self._update_paramv_on_fit()
2498            # draw
2499            self._draw_model()
2500            self.Refresh()
2501        except Exception:
2502            logging.error(traceback.format_exc())
2503            # Error msg
2504            msg = "Error occurred:"
2505            msg += " Could not select the distribution function..."
2506            msg += " Please select another distribution function."
2507            disp_box.SetBackgroundColour("pink")
2508            # Focus on Fit button so that users can see the pinky box
2509            self.btFit.SetFocus()
2510            wx.PostEvent(self._manager.parent,
2511                         StatusEvent(status=msg, info="error"))
2512
2513    def _set_array_disp(self, name=None, disp=None):
2514        """
2515        Set array dispersion
2516
2517        :param name: name of the parameter for the dispersion to be set
2518        :param disp: the polydisperion object
2519        """
2520        # The user wants this parameter to be averaged.
2521        # Pop up the file selection dialog.
2522        path = self._selectDlg()
2523        # Array data
2524        values = []
2525        weights = []
2526        # If nothing was selected, just return
2527        if path is None:
2528            self.disp_cb_dict[name].SetValue(False)
2529            # self.noDisper_rbox.SetValue(True)
2530            return
2531        self._default_save_location = os.path.dirname(path)
2532        if self._manager is not None:
2533            self._manager.parent._default_save_location = \
2534                             self._default_save_location
2535
2536        basename = os.path.basename(path)
2537        values, weights = self.read_file(path)
2538
2539        # If any of the two arrays is empty, notify the user that we won't
2540        # proceed
2541        if len(self.param_toFit) > 0:
2542            if name in self.param_toFit:
2543                self.param_toFit.remove(name)
2544
2545        # Tell the user that we are about to apply the distribution
2546        msg = "Applying loaded %s distribution: %s" % (name, path)
2547        wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2548        self._set_array_disp_model(name=name, disp=disp,
2549                                   values=values, weights=weights)
2550        return basename
2551
2552    def _set_array_disp_model(self, name=None, disp=None,
2553                              values=[], weights=[]):
2554        """
2555        Set array dispersion model
2556
2557        :param name: name of the parameter for the dispersion to be set
2558        :param disp: the polydisperion object
2559        """
2560        disp.set_weights(values, weights)
2561        self._disp_obj_dict[name] = disp
2562        self.model.set_dispersion(name.split('.')[0], disp)
2563        self.state._disp_obj_dict[name] = disp.type
2564        self.values[name] = values
2565        self.weights[name] = weights
2566        # Store the object to make it persist outside the
2567        # scope of this method
2568        # TODO: refactor model to clean this up?
2569        self.state.values = {}
2570        self.state.weights = {}
2571        self.state.values = copy.deepcopy(self.values)
2572        self.state.weights = copy.deepcopy(self.weights)
2573
2574        # Set the new model as the dispersion object for the
2575        # selected parameter
2576        # self.model.set_dispersion(p, disp_model)
2577        # Store a reference to the weights in the model object
2578        # so that
2579        # it's not lost when we use the model within another thread.
2580        self.state.model = self.model.clone()
2581        self.model._persistency_dict[name.split('.')[0]] = \
2582            [values, weights]
2583        self.state.model._persistency_dict[name.split('.')[0]] = \
2584            [values, weights]
2585
2586    def _del_array_values(self, name=None):
2587        """
2588        Reset array dispersion
2589
2590        :param name: name of the parameter for the dispersion to be set
2591        """
2592        # Try to delete values and weight of the names array dic if exists
2593        try:
2594            if name in self.values:
2595                del self.values[name]
2596                del self.weights[name]
2597                # delete all other dic
2598                del self.state.values[name]
2599                del self.state.weights[name]
2600                del self.model._persistency_dict[name.split('.')[0]]
2601                del self.state.model._persistency_dict[name.split('.')[0]]
2602        except Exception:
2603            logging.error(traceback.format_exc())
2604
2605    def _lay_out(self):
2606        """
2607        returns self.Layout
2608
2609        :Note: Mac seems to like this better when self.
2610            Layout is called after fitting.
2611        """
2612        self._sleep4sec()
2613        self.Layout()
2614        return
2615
2616    def _sleep4sec(self):
2617        """
2618            sleep for 1 sec only applied on Mac
2619            Note: This 1sec helps for Mac not to crash on self.
2620            Layout after self._draw_model
2621        """
2622        if ON_MAC:
2623            time.sleep(1)
2624
2625    def _find_polyfunc_selection(self, disp_func=None):
2626        """
2627        FInd Comboox selection from disp_func
2628
2629        :param disp_function: dispersion distr. function
2630        """
2631        # Find the selection
2632        if disp_func is not None:
2633            try:
2634                return POLYDISPERSITY_MODELS.values().index(disp_func.__class__)
2635            except ValueError:
2636                pass  # Fall through to default class
2637        return POLYDISPERSITY_MODELS.keys().index('gaussian')
2638
2639    def on_reset_clicked(self, event):
2640        """
2641        On 'Reset' button  for Q range clicked
2642        """
2643        flag = True
2644        # For 3 different cases: Data2D, Data1D, and theory
2645        if self.model is None:
2646            msg = "Please select a model first..."
2647            wx.MessageBox(msg, 'Info')
2648            flag = False
2649            return
2650
2651        elif self.data.__class__.__name__ == "Data2D":
2652            data_min = 0
2653            x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
2654            y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
2655            self.qmin_x = data_min
2656            self.qmax_x = math.sqrt(x * x + y * y)
2657            # self.data.mask = numpy.ones(len(self.data.data),dtype=bool)
2658            # check smearing
2659            if not self.disable_smearer.GetValue():
2660                # set smearing value whether or
2661                # not the data contain the smearing info
2662                if self.pinhole_smearer.GetValue():
2663                    flag = self.update_pinhole_smear()
2664                else:
2665                    flag = True
2666
2667        elif self.data is None:
2668            self.qmin_x = _QMIN_DEFAULT
2669            self.qmax_x = _QMAX_DEFAULT
2670            self.num_points = _NPTS_DEFAULT
2671            self.state.npts = self.num_points
2672
2673        elif self.data.__class__.__name__ != "Data2D":
2674            self.qmin_x = min(self.data.x)
2675            self.qmax_x = max(self.data.x)
2676            # check smearing
2677            if not self.disable_smearer.GetValue():
2678                # set smearing value whether or
2679                # not the data contain the smearing info
2680                if self.slit_smearer.GetValue():
2681                    flag = self.update_slit_smear()
2682                elif self.pinhole_smearer.GetValue():
2683                    flag = self.update_pinhole_smear()
2684                else:
2685                    flag = True
2686        else:
2687            flag = False
2688
2689        if flag is False:
2690            msg = "Cannot Plot :Must enter a number!!!  "
2691            wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
2692        else:
2693            # set relative text ctrs.
2694            self.qmin.SetValue(str(self.qmin_x))
2695            self.qmax.SetValue(str(self.qmax_x))
2696            self.show_npts2fit()
2697            # At this point, some button and variables satatus (disabled?)
2698            # should be checked such as color that should be reset to
2699            # white in case that it was pink.
2700            self._onparamEnter_helper()
2701
2702        self.save_current_state()
2703        self.state.qmin = self.qmin_x
2704        self.state.qmax = self.qmax_x
2705
2706        # reset the q range values
2707        self._reset_plotting_range(self.state)
2708        self._draw_model()
2709
2710    def select_log(self, event):
2711        """
2712        Log checked to generate log spaced points for theory model
2713        """
2714
2715    def get_images(self):
2716        """
2717        Get the images of the plots corresponding this panel for report
2718
2719        : return graphs: list of figures
2720        : Need Move to guiframe
2721        """
2722        # set list of graphs
2723        graphs = []
2724        canvases = []
2725        res_item = None
2726        # call gui_manager
2727        gui_manager = self._manager.parent
2728        # loops through the panels [dic]
2729        for _, item2 in gui_manager.plot_panels.iteritems():
2730            data_title = self.data.group_id
2731            # try to get all plots belonging to this control panel
2732            try:
2733                g_id = item2.group_id
2734                if g_id == data_title or \
2735                        str(g_id).count("res" + str(self.graph_id)) or \
2736                        str(g_id).count(str(self.uid)) > 0:
2737                    if str(g_id).count("res" + str(self.graph_id)) > 0:
2738                        res_item = [item2.figure, item2.canvas]
2739                    else:
2740                        # append to the list
2741                        graphs.append(item2.figure)
2742                        canvases.append(item2.canvas)
2743            except Exception:
2744                # Not for control panels
2745                logging.error(traceback.format_exc())
2746        # Make sure the resduals plot goes to the last
2747        if res_item is not None:
2748            graphs.append(res_item[0])
2749            canvases.append(res_item[1])
2750        # return the list of graphs
2751        return graphs, canvases
2752
2753    def on_function_help_clicked(self, event):
2754        """
2755        Function called when 'Help' button is pressed next to model
2756        of interest.  This calls DocumentationWindow from
2757        documentation_window.py. It will load the top level of the model
2758        help documenation sphinx generated html if no model is presented.
2759        If a model IS present then if documention for that model exists
2760        it will load to that  point otherwise again it will go to the top.
2761        For Wx2.8 and below is used (i.e. non-released through installer)
2762        a browser is loaded and the top of the model documentation only is
2763        accessible because webbrowser module does not pass anything after
2764        the # to the browser.
2765
2766        :param event: on Help Button pressed event
2767        """
2768
2769        if self.model is not None:
2770            name = self.formfactorbox.GetValue()
2771            _TreeLocation = 'user/models/' + name.lower()+'.html'
2772            _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2773                                              "", name + " Help")
2774        else:
2775            _TreeLocation = 'user/index.html'
2776            _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2777                                              "", "General Model Help")
2778
2779    def on_model_help_clicked(self, event):
2780        """
2781        Function called when 'Description' button is pressed next to model
2782        of interest.  This calls the Description embedded in the model. This
2783        should work with either Wx2.8 and lower or higher. If no model is
2784        selected it will give the message that a model must be chosen first
2785        in the box that would normally contain the description.  If a badly
2786        behaved model is encountered which has no description then it will
2787        give the message that none is available.
2788
2789        :param event: on Description Button pressed event
2790        """
2791
2792        if self.model is None:
2793            name = 'index.html'
2794        else:
2795            name = self.formfactorbox.GetValue()
2796
2797        msg = 'Model description:\n'
2798        info = "Info"
2799        if self.model is not None:
2800            # frame.Destroy()
2801            if str(self.model.description).rstrip().lstrip() == '':
2802                msg += "Sorry, no information is available for this model."
2803            else:
2804                msg += self.model.description + '\n'
2805            wx.MessageBox(msg, info)
2806        else:
2807            msg += "You must select a model to get information on this"
2808            wx.MessageBox(msg, info)
2809
2810    def _on_mag_angle_help(self, event):
2811        """
2812        Bring up Magnetic Angle definition bmp image whenever the ? button
2813        is clicked. Calls DocumentationWindow with the path of the location
2814        within the documentation tree (after /doc/ ....". When using old
2815        versions of Wx (i.e. before 2.9 and therefore not part of release
2816        versions distributed via installer) it brings up an image viewer
2817        box which allows the user to click through the rest of the images in
2818        the directory.  Not ideal but probably better than alternative which
2819        would bring up the entire discussion of how magnetic models work?
2820        Specially since it is not likely to be accessed.  The normal release
2821        versions bring up the normal image box.
2822
2823        :param evt: Triggers on clicking ? in Magnetic Angles? box
2824        """
2825
2826        _TreeLocation = "_images/M_angles_pic.bmp"
2827        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2828                                          "Magnetic Angle Defintions")
2829
2830    def _on_mag_help(self, event):
2831        """
2832        Bring up Magnetic Angle definition bmp image whenever the ? button
2833        is clicked. Calls DocumentationWindow with the path of the location
2834        within the documentation tree (after /doc/ ....". When using old
2835        versions of Wx (i.e. before 2.9 and therefore not part of release
2836        versions distributed via installer) it brings up an image viewer
2837        box which allows the user to click through the rest of the images in
2838        the directory.  Not ideal but probably better than alternative which
2839        would bring up the entire discussion of how magnetic models work?
2840        Specially since it is not likely to be accessed.  The normal release
2841        versions bring up the normal image box.
2842
2843        :param evt: Triggers on clicking ? in Magnetic Angles? box
2844        """
2845
2846        _TreeLocation = "user/magnetism.html"
2847        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation, "",
2848                                          "Polarized Beam/Magnetc Help")
2849
2850    def _on_mag_on(self, event):
2851        """
2852        Magnetic Parameters ON/OFF
2853        """
2854        button = event.GetEventObject()
2855
2856        if button.GetLabel().count('ON') > 0:
2857            self.magnetic_on = True
2858            button.SetLabel("Magnetic OFF")
2859            m_value = 1.0e-06
2860            for key in self.model.magnetic_params:
2861                if key.count('M0') > 0:
2862                    self.model.setParam(key, m_value)
2863                    m_value += 0.5e-06
2864        else:
2865            self.magnetic_on = False
2866            button.SetLabel("Magnetic ON")
2867            for key in self.model.magnetic_params:
2868                if key.count('M0') > 0:
2869                    # reset mag value to zero fo safety
2870                    self.model.setParam(key, 0.0)
2871
2872        self.Show(False)
2873        self.set_model_param_sizer(self.model)
2874        # self._set_sizer_dispersion()
2875        self.state.magnetic_on = self.magnetic_on
2876        self.SetupScrolling()
2877        self.Show(True)
2878
2879    def on_pd_help_clicked(self, event):
2880        """
2881        Bring up Polydispersity Documentation whenever the ? button is clicked.
2882        Calls DocumentationWindow with the path of the location within the
2883        documentation tree (after /doc/ ....".  Note that when using old
2884        versions of Wx (before 2.9) and thus not the release version of
2885        istallers, the help comes up at the top level of the file as
2886        webbrowser does not pass anything past the # to the browser when it is
2887        running "file:///...."
2888
2889        :param event: Triggers on clicking ? in polydispersity box
2890        """
2891
2892        _TreeLocation = "user/sasgui/perspectives/fitting/pd_help.html"
2893        _PageAnchor = ""
2894        _doc_viewer = DocumentationWindow(self, wx.ID_ANY, _TreeLocation,
2895                                          _PageAnchor, "Polydispersity Help")
2896
2897    def on_left_down(self, event):
2898        """
2899        Get key stroke event
2900        """
2901        # Figuring out key combo: Cmd for copy, Alt for paste
2902        if event.CmdDown() and event.ShiftDown():
2903            self.get_paste()
2904        elif event.CmdDown():
2905            self.get_copy()
2906        else:
2907            event.Skip()
2908            return
2909        # make event free
2910        event.Skip()
2911
2912    def get_copy(self):
2913        """
2914        Get copy params to clipboard
2915        """
2916        content = self.get_copy_params()
2917        flag = self.set_clipboard(content)
2918        self._copy_info(flag)
2919        return flag
2920
2921    def get_copy_params(self):
2922        """
2923        Get the string copies of the param names and values in the tap
2924        """
2925        content = 'sasview_parameter_values:'
2926        # Do it if params exist
2927        if self.parameters:
2928
2929            # go through the parameters
2930            strings = self._get_copy_helper(self.parameters,
2931                                           self.orientation_params)
2932            content += strings
2933
2934            # go through the fittables
2935            strings = self._get_copy_helper(self.fittable_param,
2936                                           self.orientation_params_disp)
2937            content += strings
2938
2939            # go through the fixed params
2940            strings = self._get_copy_helper(self.fixed_param,
2941                                           self.orientation_params_disp)
2942            content += strings
2943
2944            # go through the str params
2945            strings = self._get_copy_helper(self.str_parameters,
2946                                           self.orientation_params)
2947            content += strings
2948            return content
2949        else:
2950            return False
2951
2952    def get_copy_excel(self):
2953        """
2954        Get copy params to clipboard
2955        """
2956        content = self.get_copy_params_excel()
2957        flag = self.set_clipboard(content)
2958        self._copy_info(flag)
2959        return flag
2960
2961    def get_copy_params_excel(self):
2962        """
2963        Get the string copies of the param names and values in the tap
2964        """
2965        content = ''
2966
2967        crlf = chr(13) + chr(10)
2968        tab = chr(9)
2969
2970        # Do it if params exist
2971        if self.parameters:
2972
2973            for param in self.parameters:
2974                content += param[1]  # parameter name
2975                content += tab
2976                content += param[1] + "_err"
2977                content += tab
2978
2979            content += crlf
2980
2981            # row of values and errors...
2982            for param in self.parameters:
2983                content += param[2].GetValue()  # value
2984                content += tab
2985                content += param[4].GetValue()  # error
2986                content += tab
2987
2988            return content
2989        else:
2990            return False
2991
2992    def get_copy_latex(self):
2993        """
2994        Get copy params to clipboard
2995        """
2996        content = self.get_copy_params_latex()
2997        flag = self.set_clipboard(content)
2998        self._copy_info(flag)
2999        return flag
3000
3001    def get_copy_params_latex(self):
3002        """
3003        Get the string copies of the param names and values in the tap
3004        """
3005        content = '\\begin{table}'
3006        content += '\\begin{tabular}[h]'
3007
3008        crlf = chr(13) + chr(10)
3009        tab = chr(9)
3010
3011        # Do it if params exist
3012        if self.parameters:
3013
3014            content += '{|'
3015            for param in self.parameters:
3016                content += 'l|l|'
3017            content += '}\hline'
3018            content += crlf
3019
3020            for index, param in enumerate(self.parameters):
3021                content += param[1].replace('_', '\_')  # parameter name
3022                content += ' & '
3023                content += param[1].replace('_', '\_') + "\_err"
3024                if index < len(self.parameters) - 1:
3025                    content += ' & '
3026            content += '\\\\ \\hline'
3027            content += crlf
3028
3029            # row of values and errors...
3030            for index, param in enumerate(self.parameters):
3031                content += param[2].GetValue()  # parameter value
3032                content += ' & '
3033                content += param[4].GetValue()  # parameter error
3034                if index < len(self.parameters) - 1:
3035                    content += ' & '
3036            content += '\\\\ \\hline'
3037            content += crlf
3038
3039            content += '\\end{tabular}'
3040            content += '\\end{table}'
3041            return content
3042        else:
3043            return False
3044
3045    def set_clipboard(self, content=None):
3046        """
3047        Put the string to the clipboard
3048        """
3049        if not content:
3050            return False
3051        if wx.TheClipboard.Open():
3052            wx.TheClipboard.SetData(wx.TextDataObject(str(content)))
3053            wx.TheClipboard.Close()
3054            return True
3055        return None
3056
3057    def _get_copy_helper(self, param, orient_param):
3058        """
3059        Helping get value and name of the params
3060
3061        : param param:  parameters
3062        : param orient_param = oritational params
3063        : return content: strings [list] [name,value:....]
3064        """
3065        content = ''
3066        bound_hi = ''
3067        bound_lo = ''
3068        # go through the str params
3069        for item in param:
3070            # copy only the params shown
3071            if not item[2].IsShown():
3072                continue
3073            disfunc = ''
3074            try:
3075                if item[7].__class__.__name__ == 'ComboBox':
3076                    disfunc = str(item[7].GetValue())
3077            except Exception:
3078                logging.error(traceback.format_exc())
3079
3080            # 2D
3081            if self.data.__class__.__name__ == "Data2D":
3082                try:
3083                    check = item[0].GetValue()
3084                except Exception:
3085                    check = None
3086                name = item[1]
3087                value = item[2].GetValue()
3088            # 1D
3089            else:
3090                # for 1D all parameters except orientation
3091                if not item[1] in orient_param:
3092                    try:
3093                        check = item[0].GetValue()
3094                    except:
3095                        check = None
3096                    name = item[1]
3097                    value = item[2].GetValue()
3098
3099            # Bounds
3100            try:
3101                bound_lo = item[5].GetValue()
3102                bound_hi = item[6].GetValue()
3103            except Exception:
3104                # harmless - need to just pass
3105                pass
3106
3107            # add to the content
3108            if disfunc != '':
3109
3110                disfunc = ',' + disfunc
3111            # Need to support array func for copy/paste
3112            try:
3113                if disfunc.count('array') > 0:
3114                    disfunc += ','
3115                    for val in self.values[name]:
3116                        disfunc += ' ' + str(val)
3117                    disfunc += ','
3118                    for weight in self.weights[name]:
3119                        disfunc += ' ' + str(weight)
3120            except Exception:
3121                logging.error(traceback.format_exc())
3122            content += name + ',' + str(check) + ',' + value + disfunc + ',' + \
3123                       bound_lo + ',' + bound_hi + ':'
3124
3125        return content
3126
3127    def get_clipboard(self):
3128        """
3129        Get strings in the clipboard
3130        """
3131        text = ""
3132        # Get text from the clip board
3133        if wx.TheClipboard.Open():
3134            if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
3135                data = wx.TextDataObject()
3136                # get wx dataobject
3137                success = wx.TheClipboard.GetData(data)
3138                # get text
3139                if success:
3140                    text = data.GetText()
3141                else:
3142                    text = ''
3143            # close clipboard
3144            wx.TheClipboard.Close()
3145        return text
3146
3147    def get_paste(self):
3148        """
3149        Paste params from the clipboard
3150        """
3151        text = self.get_clipboard()
3152        flag = self.get_paste_params(text)
3153        self._copy_info(flag)
3154        return flag
3155
3156    def get_paste_params(self, text=''):
3157        """
3158        Get the string copies of the param names and values in the tap
3159        """
3160        context = {}
3161        # put the text into dictionary
3162        lines = text.split(':')
3163        if lines[0] != 'sasview_parameter_values':
3164            self._copy_info(False)
3165            return False
3166        for line in lines[1:-1]:
3167            if len(line) != 0:
3168                item = line.split(',')
3169                check = item[1]
3170                name = item[0]
3171                value = item[2]
3172                # Transfer the text to content[dictionary]
3173                context[name] = [check, value]
3174
3175                # limits
3176                limit_lo = item[3]
3177                context[name].append(limit_lo)
3178                limit_hi = item[4]
3179                context[name].append(limit_hi)
3180
3181            # ToDo: PlugIn this poly disp function for pasting
3182            try:
3183                poly_func = item[5]
3184                context[name].append(poly_func)
3185                try:
3186                    # take the vals and weights for  array
3187                    array_values = item[6].split(' ')
3188                    array_weights = item[7].split(' ')
3189                    val = [float(a_val) for a_val in array_values[1:]]
3190                    weit = [float(a_weit) for a_weit in array_weights[1:]]
3191
3192                    context[name].append(val)
3193                    context[name].append(weit)
3194                except:
3195                    raise
3196            except:
3197                poly_func = ''
3198                context[name].append(poly_func)
3199
3200        # Do it if params exist
3201        if self.parameters:
3202            # go through the parameters
3203            self._get_paste_helper(self.parameters,
3204                                   self.orientation_params, context)
3205
3206            # go through the fittables
3207            self._get_paste_helper(self.fittable_param,
3208                                   self.orientation_params_disp,
3209                                   context)
3210
3211            # go through the fixed params
3212            self._get_paste_helper(self.fixed_param,
3213                                   self.orientation_params_disp, context)
3214
3215            # go through the str params
3216            self._get_paste_helper(self.str_parameters,
3217                                   self.orientation_params, context)
3218
3219            return True
3220        return None
3221
3222    def _get_paste_helper(self, param, orient_param, content):
3223        """
3224        Helping set values of the params
3225
3226        : param param:  parameters
3227        : param orient_param: oritational params
3228        : param content: dictionary [ name, value: name1.value1,...]
3229        """
3230        # go through the str params
3231        for item in param:
3232            # 2D
3233            if self.data.__class__.__name__ == "Data2D":
3234                name = item[1]
3235                if name in content.keys():
3236                    values = content[name]
3237                    check = values[0]
3238                    pd = values[1]
3239
3240                    if name.count('.') > 0:
3241                        # If this is parameter.width, then pd may be a floating
3242                        # point value or it may be an array distribution.
3243                        # Nothing to do for parameter.npts or parameter.nsigmas.
3244                        try:
3245                            float(pd)
3246                            if name.endswith('.npts'):
3247                                pd = int(pd)
3248                        except Exception:
3249                            # continue
3250                            if not pd and pd != '':
3251                                continue
3252                    item[2].SetValue(str(pd))
3253                    if item in self.fixed_param and pd == '':
3254                        # Only array func has pd == '' case.
3255                        item[2].Enable(False)
3256                    else:
3257                        item[2].Enable(True)
3258                    if item[2].__class__.__name__ == "ComboBox":
3259                        if content[name][1] in self.model.fun_list:
3260                            fun_val = self.model.fun_list[content[name][1]]
3261                            self.model.setParam(name, fun_val)
3262                    try:
3263                        item[5].SetValue(str(values[-3]))
3264                        item[6].SetValue(str(values[-2]))
3265                    except Exception:
3266                        # passing as harmless non-update
3267                        pass
3268
3269                    value = content[name][1:]
3270                    self._paste_poly_help(item, value)
3271                    if check == 'True':
3272                        is_true = True
3273                    elif check == 'False':
3274                        is_true = False
3275                    else:
3276                        is_true = None
3277                    if is_true is not None:
3278                        item[0].SetValue(is_true)
3279            # 1D
3280            else:
3281                # for 1D all parameters except orientation
3282                if not item[1] in orient_param:
3283                    name = item[1]
3284                    if name in content.keys():
3285                        check = content[name][0]
3286                        # Avoid changing combox content
3287                        value = content[name][1:]
3288                        pd = value[0]
3289                        if name.count('.') > 0:
3290                            # If this is parameter.width, then pd may be a
3291                            # floating point value or it may be an array
3292                            # distribution. Nothing to do for parameter.npts or
3293                            # parameter.nsigmas.
3294                            try:
3295                                pd = float(pd)
3296                                if name.endswith('.npts'):
3297                                    pd = int(pd)
3298                            except:
3299                                # continue
3300                                if not pd and pd != '':
3301                                    continue
3302                        item[2].SetValue(str(pd))
3303                        if item in self.fixed_param and pd == '':
3304                            # Only array func has pd == '' case.
3305                            item[2].Enable(False)
3306                        else:
3307                            item[2].Enable(True)
3308                        if item[2].__class__.__name__ == "ComboBox":
3309                            if value[0] in self.model.fun_list:
3310                                fun_val = self.model.fun_list[value[0]]
3311                                self.model.setParam(name, fun_val)
3312                                # save state
3313                        try:
3314                            item[5].SetValue(str(value[-3]))
3315                            item[6].SetValue(str(value[-2]))
3316                        except Exception:
3317                            # passing as harmless non-update
3318                            pass
3319
3320                        self._paste_poly_help(item, value)
3321                        if check == 'True':
3322                            is_true = True
3323                        elif check == 'False':
3324                            is_true = False
3325                        else:
3326                            is_true = None
3327                        if is_true is not None:
3328                            item[0].SetValue(is_true)
3329
3330        self.select_param(event=None)
3331        self.Refresh()
3332
3333    def _paste_poly_help(self, item, value):
3334        """
3335        Helps get paste for poly function
3336
3337        *item* is the parameter name
3338
3339        *value* depends on which parameter is being processed, and whether it
3340        has array polydispersity.
3341
3342        For parameters without array polydispersity:
3343
3344            parameter => ['FLOAT', '']
3345            parameter.width => ['FLOAT', 'DISTRIBUTION', '']
3346            parameter.npts => ['FLOAT', '']
3347            parameter.nsigmas => ['FLOAT', '']
3348
3349        For parameters with array polydispersity:
3350
3351            parameter => ['FLOAT', '']
3352            parameter.width => ['FILENAME', 'array', [x1, ...], [w1, ...]]
3353            parameter.npts => ['FLOAT', '']
3354            parameter.nsigmas => ['FLOAT', '']
3355        """
3356        # Do nothing if not setting polydispersity
3357        if len(value[3]) == 0:
3358            return
3359
3360        try:
3361            name = item[7].Name
3362            param_name = name.split('.')[0]
3363            item[7].SetValue(value[1])
3364            selection = item[7].GetCurrentSelection()
3365            dispersity = item[7].GetClientData(selection)
3366            disp_model = dispersity()
3367
3368            if value[1] == 'array':
3369                pd_vals = numpy.array(value[2])
3370                pd_weights = numpy.array(value[3])
3371                if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights):
3372                    msg = ("bad array distribution parameters for %s"
3373                           % param_name)
3374                    raise ValueError(msg)
3375                self._set_disp_cb(True, item=item)
3376                self._set_array_disp_model(name=name,
3377                                           disp=disp_model,
3378                                           values=pd_vals,
3379                                           weights=pd_weights)
3380            else:
3381                self._set_disp_cb(False, item=item)
3382                self._disp_obj_dict[name] = disp_model
3383                self.model.set_dispersion(param_name, disp_model)
3384                self.state._disp_obj_dict[name] = disp_model.type
3385                # TODO: It's not an array, why update values and weights?
3386                self.model._persistency_dict[param_name] = \
3387                    [self.values, self.weights]
3388                self.state.values = self.values
3389                self.state.weights = self.weights
3390
3391        except Exception:
3392            logging.error(traceback.format_exc())
3393            print "Error in BasePage._paste_poly_help: %s" % \
3394                  sys.exc_info()[1]
3395
3396    def _set_disp_cb(self, isarray, item):
3397        """
3398        Set cb for array disp
3399        """
3400        if isarray:
3401            item[0].SetValue(False)
3402            item[0].Enable(False)
3403            item[2].Enable(False)
3404            item[3].Show(False)
3405            item[4].Show(False)
3406            item[5].SetValue('')
3407            item[5].Enable(False)
3408            item[6].SetValue('')
3409            item[6].Enable(False)
3410        else:
3411            item[0].Enable()
3412            item[2].Enable()
3413            item[3].Show(True)
3414            item[4].Show(True)
3415            item[5].Enable()
3416            item[6].Enable()
3417
3418    def update_pinhole_smear(self):
3419        """
3420            Method to be called by sub-classes
3421            Moveit; This method doesn't belong here
3422        """
3423        print "BasicPage.update_pinhole_smear was called: skipping"
3424        return
3425
3426    def _read_category_info(self):
3427        """
3428        Reads the categories in from file
3429        """
3430        # # ILL mod starts here - July 2012 kieranrcampbell@gmail.com
3431        self.master_category_dict = defaultdict(list)
3432        self.by_model_dict = defaultdict(list)
3433        self.model_enabled_dict = defaultdict(bool)
3434        categorization_file = CategoryInstaller.get_user_file()
3435        with open(categorization_file, 'rb') as f:
3436            self.master_category_dict = json.load(f)
3437        self._regenerate_model_dict()
3438
3439    def _regenerate_model_dict(self):
3440        """
3441        regenerates self.by_model_dict which has each model name as the
3442        key and the list of categories belonging to that model
3443        along with the enabled mapping
3444        """
3445        self.by_model_dict = defaultdict(list)
3446        for category in self.master_category_dict:
3447            for (model, enabled) in self.master_category_dict[category]:
3448                self.by_model_dict[model].append(category)
3449                self.model_enabled_dict[model] = enabled
3450
3451    def _populate_listbox(self):
3452        """
3453        fills out the category list box
3454        """
3455        uncat_str = 'Customized Models'
3456        self._read_category_info()
3457
3458        self.categorybox.Clear()
3459        cat_list = sorted(self.master_category_dict.keys())
3460        if uncat_str not in cat_list:
3461            cat_list.append(uncat_str)
3462
3463        for category in cat_list:
3464            if category != '':
3465                self.categorybox.Append(category)
3466
3467        if self.categorybox.GetSelection() == wx.NOT_FOUND:
3468            self.categorybox.SetSelection(0)
3469        else:
3470            self.categorybox.SetSelection(
3471                self.categorybox.GetSelection())
3472        # self._on_change_cat(None)
3473
3474    def _on_change_cat(self, event):
3475        """
3476        Callback for category change action
3477        """
3478        self.model_name = None
3479        category = self.categorybox.GetStringSelection()
3480        if category is None:
3481            return
3482        self.model_box.Clear()
3483
3484        if category == 'Customized Models':
3485            for model in self.model_list_box[category]:
3486                str_m = str(model).split(".")[0]
3487                self.model_box.Append(str_m)
3488
3489        else:
3490            for (model, enabled) in sorted(self.master_category_dict[category],
3491                                           key=lambda name: name[0]):
3492                if(enabled):
3493                    self.model_box.Append(model)
3494
3495    def _fill_model_sizer(self, sizer):
3496        """
3497        fill sizer containing model info
3498        """
3499        # This should only be called once per fit tab
3500        # print "==== Entering _fill_model_sizer"
3501        # Add model function Details button in fitpanel.
3502        # The following 3 lines are for Mac. Let JHC know before modifying...
3503        title = "Model"
3504        self.formfactorbox = None
3505        self.multifactorbox = None
3506        self.mbox_description = wx.StaticBox(self, wx.ID_ANY, str(title))
3507        boxsizer1 = wx.StaticBoxSizer(self.mbox_description, wx.VERTICAL)
3508        sizer_cat = wx.BoxSizer(wx.HORIZONTAL)
3509        self.mbox_description.SetForegroundColour(wx.RED)
3510        wx_id = self._ids.next()
3511        self.model_func = wx.Button(self, wx_id, 'Help', size=(80, 23))
3512        self.model_func.Bind(wx.EVT_BUTTON, self.on_function_help_clicked,
3513                             id=wx_id)
3514        self.model_func.SetToolTipString("Full Model Function Help")
3515        wx_id = self._ids.next()
3516        self.model_help = wx.Button(self, wx_id, 'Description', size=(80, 23))
3517        self.model_help.Bind(wx.EVT_BUTTON, self.on_model_help_clicked,
3518                             id=wx_id)
3519        self.model_help.SetToolTipString("Short Model Function Description")
3520        wx_id = self._ids.next()
3521        self.model_view = wx.Button(self, wx_id, "Show 2D", size=(80, 23))
3522        self.model_view.Bind(wx.EVT_BUTTON, self._onModel2D, id=wx_id)
3523        hint = "toggle view of model from 1D to 2D  or 2D to 1D"
3524        self.model_view.SetToolTipString(hint)
3525
3526        cat_set_box = wx.StaticBox(self, wx.ID_ANY, 'Category')
3527        sizer_cat_box = wx.StaticBoxSizer(cat_set_box, wx.HORIZONTAL)
3528        sizer_cat_box.SetMinSize((200, 50))
3529        self.categorybox = wx.ComboBox(self, wx.ID_ANY,
3530                                       style=wx.CB_READONLY)
3531        self.categorybox.SetToolTip(wx.ToolTip("Select a Category/Type"))
3532        self._populate_listbox()
3533        wx.EVT_COMBOBOX(self.categorybox, wx.ID_ANY, self._show_combox)
3534        # self.shape_rbutton = wx.RadioButton(self, wx.ID_ANY, 'Shapes',
3535        #                                     style=wx.RB_GROUP)
3536        # self.shape_indep_rbutton = wx.RadioButton(self, wx.ID_ANY,
3537        #                                          "Shape-Independent")
3538        # self.struct_rbutton = wx.RadioButton(self, wx.ID_ANY,
3539        #                                     "Structure Factor ")
3540        # self.plugin_rbutton = wx.RadioButton(self, wx.ID_ANY,
3541        #                                     "Uncategorized")
3542
3543        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3544        #                   id=self.shape_rbutton.GetId())
3545        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3546        #                    id=self.shape_indep_rbutton.GetId())
3547        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3548        #                    id=self.struct_rbutton.GetId())
3549        # self.Bind(wx.EVT_RADIOBUTTON, self._show_combox,
3550        #                    id=self.plugin_rbutton.GetId())
3551        # MAC needs SetValue
3552
3553        show_cat_button = wx.Button(self, wx.ID_ANY, "Modify")
3554        cat_tip = "Modify model categories \n"
3555        cat_tip += "(also accessible from the menu bar)."
3556        show_cat_button.SetToolTip(wx.ToolTip(cat_tip))
3557        show_cat_button.Bind(wx.EVT_BUTTON, self._on_modify_cat)
3558        sizer_cat_box.Add(self.categorybox, 1, wx.RIGHT, 3)
3559        sizer_cat_box.Add((10, 10))
3560        sizer_cat_box.Add(show_cat_button)
3561        # self.shape_rbutton.SetValue(True)
3562
3563        sizer_radiobutton = wx.GridSizer(2, 2, 5, 5)
3564        # sizer_radiobutton.Add(self.shape_rbutton)
3565        # sizer_radiobutton.Add(self.shape_indep_rbutton)
3566        sizer_radiobutton.Add((5, 5))
3567        sizer_radiobutton.Add(self.model_view, 1, wx.RIGHT, 5)
3568        # sizer_radiobutton.Add(self.plugin_rbutton)
3569        # sizer_radiobutton.Add(self.struct_rbutton)
3570        # sizer_radiobutton.Add((5,5))
3571        sizer_radiobutton.Add(self.model_help, 1, wx.RIGHT | wx.LEFT, 5)
3572        # sizer_radiobutton.Add((5,5))
3573        sizer_radiobutton.Add(self.model_func, 1, wx.RIGHT, 5)
3574        sizer_cat.Add(sizer_cat_box, 1, wx.LEFT, 2.5)
3575        sizer_cat.Add(sizer_radiobutton)
3576        sizer_selection = wx.BoxSizer(wx.HORIZONTAL)
3577        mutifactor_selection = wx.BoxSizer(wx.HORIZONTAL)
3578
3579        self.text1 = wx.StaticText(self, wx.ID_ANY, "")
3580        self.text2 = wx.StaticText(self, wx.ID_ANY, "P(Q)*S(Q)")
3581        self.mutifactor_text = wx.StaticText(self, wx.ID_ANY, "No. of Shells: ")
3582        self.mutifactor_text1 = wx.StaticText(self, wx.ID_ANY, "")
3583        self.show_sld_button = wx.Button(self, wx.ID_ANY, "Show SLD Profile")
3584        self.show_sld_button.Bind(wx.EVT_BUTTON, self._on_show_sld)
3585
3586        self.formfactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3587        self.formfactorbox.SetToolTip(wx.ToolTip("Select a Model"))
3588        if self.model is not None:
3589            self.formfactorbox.SetValue(self.model.name)
3590        self.structurebox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3591        self.multifactorbox = wx.ComboBox(self, wx.ID_ANY, style=wx.CB_READONLY)
3592        self.initialize_combox()
3593        wx.EVT_COMBOBOX(self.formfactorbox, wx.ID_ANY, self._on_select_model)
3594
3595        wx.EVT_COMBOBOX(self.structurebox, wx.ID_ANY, self._on_select_model)
3596        wx.EVT_COMBOBOX(self.multifactorbox, wx.ID_ANY, self._on_select_model)
3597        # check model type to show sizer
3598        if self.model is not None:
3599            print "_set_model_sizer_selection: disabled."
3600            # self._set_model_sizer_selection(self.model)
3601
3602        sizer_selection.Add(self.text1)
3603        sizer_selection.Add((10, 5))
3604        sizer_selection.Add(self.formfactorbox)
3605        sizer_selection.Add((5, 5))
3606        sizer_selection.Add(self.text2)
3607        sizer_selection.Add((5, 5))
3608        sizer_selection.Add(self.structurebox)
3609
3610        mutifactor_selection.Add((13, 5))
3611        mutifactor_selection.Add(self.mutifactor_text)
3612        mutifactor_selection.Add(self.multifactorbox)
3613        mutifactor_selection.Add((5, 5))
3614        mutifactor_selection.Add(self.mutifactor_text1)
3615        mutifactor_selection.Add((10, 5))
3616        mutifactor_selection.Add(self.show_sld_button)
3617
3618        boxsizer1.Add(sizer_cat)
3619        boxsizer1.Add((10, 10))
3620        boxsizer1.Add(sizer_selection)
3621        boxsizer1.Add((10, 10))
3622        boxsizer1.Add(mutifactor_selection)
3623
3624        self._set_multfactor_combobox()
3625        self.multifactorbox.SetSelection(1)
3626        self.show_sld_button.Hide()
3627        sizer.Add(boxsizer1, 0, wx.EXPAND | wx.ALL, 10)
3628        sizer.Layout()
3629
3630    def on_smear_helper(self, update=False):
3631        """
3632        Help for onSmear if implemented
3633
3634        :param update: force or not to update
3635        """
3636    def reset_page(self, state, first=False):
3637        """
3638        reset the state  if implemented
3639        """
3640    def onSmear(self, event):
3641        """
3642        Create a smear object if implemented
3643        """
3644    def onPinholeSmear(self, event):
3645        """
3646        Create a custom pinhole smear object if implemented
3647        """
3648    def onSlitSmear(self, event):
3649        """
3650        Create a custom slit smear object if implemented
3651        """
3652    def update_slit_smear(self):
3653        """
3654        called by kill_focus on pinhole TextCntrl
3655        to update the changes if implemented
3656        """
3657    def select_param(self, event):
3658        """
3659        Select TextCtrl  checked if implemented
3660        """
3661    def set_data(self, data=None):
3662        """
3663        Sets data if implemented
3664        """
3665    def _is_2D(self):
3666        """
3667        Check if data_name is Data2D if implemented
3668        """
3669    def _on_select_model(self, event=None):
3670        """
3671        call back for model selection if implemented
3672        """
3673    def get_weight_flag(self):
3674        """
3675        Get flag corresponding to a given weighting dI data if implemented
3676        """
3677    def _set_sizer_dispersion(self):
3678        """
3679        draw sizer for dispersity if implemented
3680        """
3681    def get_all_checked_params(self):
3682        """
3683        Found all parameters current check and add them to list of parameters
3684        to fit if implemented
3685        """
3686    def show_npts2fit(self):
3687        """
3688        setValue Npts for fitting if implemented
3689        """
3690    def _onModel2D(self, event):
3691        """
3692        toggle view of model from 1D to 2D  or 2D from 1D if implemented
3693        """
3694
3695
3696class ModelTextCtrl(wx.TextCtrl):
3697    """
3698    Text control for model and fit parameters.
3699    Binds the appropriate events for user interactions.
3700    Default callback methods can be overwritten on initialization
3701
3702    :param kill_focus_callback: callback method for EVT_KILL_FOCUS event
3703    :param set_focus_callback:  callback method for EVT_SET_FOCUS event
3704    :param mouse_up_callback:   callback method for EVT_LEFT_UP event
3705    :param text_enter_callback: callback method for EVT_TEXT_ENTER event
3706
3707    """
3708    # Set to True when the mouse is clicked while whole string is selected
3709    full_selection = False
3710    # Call back for EVT_SET_FOCUS events
3711    _on_set_focus_callback = None
3712
3713    def __init__(self, parent, id=-1,
3714                 value=wx.EmptyString,
3715                 pos=wx.DefaultPosition,
3716                 size=wx.DefaultSize,
3717                 style=0,
3718                 validator=wx.DefaultValidator,
3719                 name=wx.TextCtrlNameStr,
3720                 kill_focus_callback=None,
3721                 set_focus_callback=None,
3722                 mouse_up_callback=None,
3723                 text_enter_callback=None):
3724
3725        wx.TextCtrl.__init__(self, parent, id, value, pos,
3726                             size, style, validator, name)
3727
3728        # Bind appropriate events
3729        self._on_set_focus_callback = parent.onSetFocus \
3730            if set_focus_callback is None else set_focus_callback
3731        self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
3732        self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus
3733        if kill_focus_callback is None else kill_focus_callback)
3734        self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter
3735        if text_enter_callback is None else text_enter_callback)
3736        if not ON_MAC:
3737            self.Bind(wx.EVT_LEFT_UP, self._highlight_text
3738            if mouse_up_callback is None else mouse_up_callback)
3739
3740    def _on_set_focus(self, event):
3741        """
3742        Catch when the text control is set in focus to highlight the whole
3743        text if necessary
3744
3745        :param event: mouse event
3746
3747        """
3748        event.Skip()
3749        self.full_selection = True
3750        return self._on_set_focus_callback(event)
3751
3752    def _highlight_text(self, event):
3753        """
3754        Highlight text of a TextCtrl only of no text has be selected
3755
3756        :param event: mouse event
3757
3758        """
3759        # Make sure the mouse event is available to other listeners
3760        event.Skip()
3761        control = event.GetEventObject()
3762        if self.full_selection:
3763            self.full_selection = False
3764            # Check that we have a TextCtrl
3765            if issubclass(control.__class__, wx.TextCtrl):
3766                # Check whether text has been selected,
3767                # if not, select the whole string
3768                (start, end) = control.GetSelection()
3769                if start == end:
3770                    control.SetSelection(-1, -1)
3771
3772    def _silent_kill_focus(self, event):
3773        """
3774        Save the state of the page
3775        """
3776
3777        event.Skip()
3778        # pass
Note: See TracBrowser for help on using the repository browser.