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

magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249unittest-saveload
Last change on this file since c192960 was c192960, checked in by krzywon, 4 years ago

refs #1081 - Stop early exit of model parameter updates when dispersity params are modified.

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