source: sasview/src/sans/perspectives/calculator/gen_scatter_panel.py @ a855fec

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since a855fec was a855fec, checked in by Mathieu Doucet <doucetm@…>, 10 years ago

Update perspective imports for latest move

  • Property mode set to 100644
File size: 76.7 KB
Line 
1"""
2Generic Scattering panel.
3This module relies on guiframe manager.
4"""
5
6import wx
7import sys
8import os
9import numpy
10#import math
11import wx.aui as aui
12#import wx.lib.agw.aui as aui
13import logging
14import time
15
16import matplotlib
17matplotlib.interactive(False)
18#Use the WxAgg back end. The Wx one takes too long to render
19matplotlib.use('WXAgg')
20
21#from sans.guiframe.gui_manager import MDIFrame
22from sans.data_util.calcthread import CalcThread
23from sans.guiframe.local_perspectives.plotting.SimplePlot import PlotFrame
24from sans.guiframe.dataFitting import Data2D
25from sans.guiframe.dataFitting import Data1D
26from sans.dataloader.data_info import Detector
27from sans.dataloader.data_info import Source
28from sans.guiframe.panel_base import PanelBase
29from sans.guiframe.utils import format_number
30from sans.guiframe.events import StatusEvent 
31from sans.calculator import sans_gen
32from sans.perspectives.calculator.calculator_widgets import OutputTextCtrl
33from sans.perspectives.calculator.calculator_widgets import InputTextCtrl
34from wx.lib.scrolledpanel import ScrolledPanel
35from sans.perspectives.calculator.load_thread import GenReader
36from sans.plottools.arrow3d import Arrow3D
37from sans.perspectives.calculator import calculator_widgets as widget
38from sans.guiframe.events import NewPlotEvent   
39
40_BOX_WIDTH = 76
41#Slit length panel size
42if sys.platform.count("win32") > 0:
43    PANEL_WIDTH = 570
44    PANEL_HEIGHT = 370
45    FONT_VARIANT = 0
46else:
47    PANEL_WIDTH = 620
48    PANEL_HEIGHT = 370
49    FONT_VARIANT = 1
50_QMAX_DEFAULT = 0.3
51_NPTS_DEFAULT = 50 
52_Q1D_MIN = 0.001
53
54def add_icon(parent, frame):
55    """
56    Add icon in the frame
57    """
58    if parent != None:
59        if hasattr(frame, "IsIconized"):
60            if not frame.IsIconized():
61                try:
62                    icon = parent.GetIcon()
63                    frame.SetIcon(icon)
64                except:
65                    pass 
66
67def _set_error(panel, item, show_msg=False):
68    """
69    Set_error dialog
70    """
71    if item != None:
72        item.SetBackgroundColour("pink")
73        item.Refresh()
74    if show_msg:
75        msg = "Error: wrong (or out of range) value entered."
76        if panel.parent.parent != None:
77            wx.PostEvent(panel.parent.parent, 
78                     StatusEvent(status=msg, info='Error' )) 
79            panel.SetFocus()
80    return False
81
82class CalcGen(CalcThread):
83    """
84    Computation
85    """
86    def __init__(self,
87                 id=-1,
88                 input = None,
89                 completefn = None,
90                 updatefn   = None,
91                 #elapsed = 0,
92                 yieldtime  = 0.01,
93                 worktime   = 0.01):
94        """
95        """
96        CalcThread.__init__(self, completefn,
97                 updatefn,
98                 yieldtime,
99                 worktime)
100        self.starttime = 0
101        self.id = id 
102        self.input = input 
103        self.update_fn = updatefn
104       
105    def compute(self):
106        """
107        excuting computation
108        """
109        #elapsed = time.time() - self.starttime
110        self.starttime = time.time()
111        self.complete(input=self.input, update=self.update_fn)
112           
113class SasGenPanel(ScrolledPanel, PanelBase):
114    """
115        Provides the sas gen calculator GUI.
116    """
117    ## Internal nickname for the window, used by the AUI manager
118    window_name = "Generic SANS Calculator"
119    ## Name to appear on the window title bar
120    window_caption = "Generic SANS "
121    ## Flag to tell the AUI manager to put this panel in the center pane
122    CENTER_PANE = True
123   
124    def __init__(self, parent, *args, **kwds):
125        ScrolledPanel.__init__(self, parent, style=wx.RAISED_BORDER, 
126                               *args, **kwds)
127        #kwds['style'] = wx.SUNKEN_BORDER
128        PanelBase.__init__(self)
129        #Font size
130        self.SetWindowVariant(variant=FONT_VARIANT)
131        self.SetupScrolling()
132        #thread to read data
133        self.reader = None
134        self.ext = None
135        self.id = 'GenSANS'
136        self.file_name = ''
137        self.time_text = None
138        self.orient_combo = None
139        self.omfreader = sans_gen.OMFReader()
140        self.sldreader = sans_gen.SLDReader()
141        self.pdbreader = sans_gen.PDBReader()
142        self.model = sans_gen.GenSAS()
143        self.param_dic = self.model.params
144        self.parameters = []
145        self.data = None
146        self.scale2d = None
147        self.is_avg = False
148        self.plot_frame = None
149        self.qmax_x = _QMAX_DEFAULT
150        self.npts_x = _NPTS_DEFAULT
151        self.sld_data = None
152        self.graph_num = 1
153        self.default_shape = 'rectangular'
154        # Object that receive status event
155        self.parent = parent
156        self._do_layout()
157        self._create_default_sld_data()
158        self._create_default_2d_data()
159        wx.CallAfter(self._set_sld_data_helper)
160       
161    def _define_structure(self):
162        """
163            Define the main sizers building to build this application.
164        """
165        self.main_sizer = wx.BoxSizer(wx.VERTICAL)
166        self.box_source = wx.StaticBox(self, -1, str("SLD Data File"))
167        self.box_parameters = wx.StaticBox(self, -1, str("Input Parameters"))
168        self.box_qrange = wx.StaticBox(self, -1, str("Q Range"))
169        self.boxsizer_source = wx.StaticBoxSizer(self.box_source,
170                                                    wx.VERTICAL)
171        self.boxsizer_parameters = wx.StaticBoxSizer(self.box_parameters,
172                                                    wx.VERTICAL)
173        self.boxsizer_qrange = wx.StaticBoxSizer(self.box_qrange,
174                                                    wx.VERTICAL)
175        self.data_name_sizer = wx.BoxSizer(wx.HORIZONTAL)
176        self.param_sizer = wx.BoxSizer(wx.HORIZONTAL)
177        self.shape_sizer = wx.BoxSizer(wx.HORIZONTAL)
178        self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)
179        self.qrange_sizer = wx.BoxSizer(wx.HORIZONTAL)
180        self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
181       
182    def _layout_data_name(self):
183        """
184            Fill the sizer containing data's name
185        """
186        data_name_txt = wx.StaticText(self, -1, 'Data: ')
187        self.data_name_tcl = OutputTextCtrl(self, -1, 
188                                            size=(_BOX_WIDTH * 4, -1))
189        data_hint = "Loaded data"
190        self.data_name_tcl.SetToolTipString(data_hint)
191        #control that triggers importing data
192        id = wx.NewId()
193        self.browse_button = wx.Button(self, id, "Load")
194        hint_on_browse = "Click on this button to load a data in this panel."
195        #self.browse_button.SetToolTipString(hint_on_browse)
196        self.Bind(wx.EVT_BUTTON, self.on_load_data, id=id)
197        self.data_name_sizer.AddMany([(data_name_txt, 0, wx.LEFT, 15),
198                                      (self.data_name_tcl, 0, wx.LEFT, 10),
199                                      (self.browse_button, 0, wx.LEFT, 10)])
200    def _layout_param_size(self):
201        """
202            Fill the sizer containing slit size information
203        """
204        self.parameters = []
205        sizer = wx.GridBagSizer(3, 6)
206        model = self.model
207        details = self.model.details
208        params = self.model.params
209        ix = 0
210        iy = 0
211        param_title = wx.StaticText(self, -1, 'Parameter')
212        sizer.Add(param_title, (iy, ix), (1, 1), \
213                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
214        ix += 1
215        value_title = wx.StaticText(self, -1, 'Value')
216        sizer.Add(value_title, (iy, ix), (1, 1), \
217                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
218        ix += 1
219        unit_title = wx.StaticText(self, -1, 'Unit')
220        sizer.Add(unit_title, (iy, ix), (1, 1), \
221                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
222        key_list = params.keys()
223        key_list.sort()
224        for param in key_list:
225            iy += 1
226            ix = 0
227            p_name = wx.StaticText(self, -1, param)
228            sizer.Add(p_name, (iy, ix), (1, 1), \
229                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
230            ## add parameter value
231            ix += 1
232            value = model.getParam(param)
233            ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 2, 20),
234                                style=wx.TE_PROCESS_ENTER)
235            #ctl.SetToolTipString(\
236            #            "Hit 'Enter' after typing to update the plot.")
237            ctl.SetValue(format_number(value, True))
238            sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
239            ## add unit
240            ix += 1
241            unit = wx.StaticText(self, -1, details[param][0])
242            sizer.Add(unit, (iy, ix), (1, 1), \
243                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
244            self.parameters.append([p_name, ctl, unit])
245                                 
246        self.param_sizer.Add(sizer, 0, wx.LEFT, 10)
247   
248    def _layout_hint(self):
249        """
250            Fill the sizer containing hint
251        """
252        hint_msg = "We support omf, sld or pdb data files only."
253        hint_msg +=  "         "
254        if FONT_VARIANT < 1:
255            hint_msg +=  "Very "
256        hint_msg += "SLOW drawing -->"
257        hint_txt = wx.StaticText(self, -1, hint_msg)
258       
259        id = wx.NewId()
260        self.draw_button = wx.Button(self, id, "Arrow Draw")
261        hint_on_draw = "Draw with arrows. Caution: it is a very slow drawing."
262        self.draw_button.SetToolTipString(hint_on_draw)
263        self.draw_button.Bind(wx.EVT_BUTTON, self.sld_draw, id=id)
264       
265        self.draw_button.Enable(False)
266        self.hint_sizer.AddMany([(hint_txt, 0, wx.LEFT, 15),
267                                 (self.draw_button, 0, wx.LEFT, 7)])
268   
269    def _layout_shape(self):
270        """
271        Fill the shape sizer
272        """
273        label_txt = wx.StaticText(self, -1, "Shape:")
274        self.shape_combo = self._fill_shape_combo()
275        self.shape_sizer.AddMany([(label_txt, 0, wx.LEFT, 15),
276                                (self.shape_combo, 0, wx.LEFT, 5)])
277   
278    def _fill_shape_combo(self):
279        """
280        Fill up the shape combo box
281        """
282        shape_combo = wx.ComboBox(self, -1, size=(150, -1), 
283                                      style=wx.CB_READONLY) 
284        shape_combo.Append('Rectangular')
285        shape_combo.Append('Ellipsoid')
286        shape_combo.Bind(wx.EVT_COMBOBOX, self._on_shape_select)
287        shape_combo.SetSelection(0)
288        return shape_combo
289   
290    def _on_shape_select(self, event):
291        """
292        On selecting a shape
293        """
294        event.Skip()
295        label = event.GetEventObject().GetValue().lower() 
296        self.default_shape = label
297        self.parent.set_omfpanel_default_shap(self.default_shape)
298        self.parent.set_omfpanel_npts()
299       
300    def _fill_orient_combo(self):
301        """
302        Fill up the orientation combo box: used only for atomic structure
303        """
304        orient_combo = wx.ComboBox(self, -1, size=(150, -1), 
305                                      style=wx.CB_READONLY) 
306        orient_combo.Append('Fixed orientation')
307        orient_combo.Append('Debye full avg.')
308        #orient_combo.Append('Debye sph. sym.')
309       
310        orient_combo.Bind(wx.EVT_COMBOBOX, self._on_orient_select)
311        orient_combo.SetSelection(0)
312        return orient_combo
313   
314    def _on_orient_select(self, event):
315        """
316        On selecting a orientation
317        """
318        event.Skip()
319        cb = event.GetEventObject()
320        if cb.GetCurrentSelection() == 2:
321            self.is_avg = None
322        else:
323            is_avg = cb.GetCurrentSelection() == 1
324            self.is_avg = is_avg
325        self.model.set_is_avg(self.is_avg)
326        self.set_est_time()   
327           
328    def _layout_qrange(self):
329        """
330        Fill the sizer containing qrange
331        """
332        sizer = wx.GridBagSizer(2, 3)
333        ix = 0
334        iy = 0
335        #key_list.sort()
336        name = wx.StaticText(self, -1, 'No. of Qx (Qy) bins: ')
337        sizer.Add(name, (iy, ix), (1, 1), \
338                        wx.EXPAND | wx.ADJUST_MINSIZE, 0)
339        ## add parameter value
340        ix += 1
341        self.npt_ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 1.5, 20),
342                            style=wx.TE_PROCESS_ENTER)
343        self.npt_ctl.Bind(wx.EVT_TEXT, self._onparamEnter)
344        self.npt_ctl.SetValue(format_number(self.npts_x, True))
345        sizer.Add(self.npt_ctl, (iy, ix), (1, 1), wx.EXPAND)
346        ## add unit
347        ix += 1
348        unit = wx.StaticText(self, -1, '')
349        sizer.Add(unit, (iy, ix), (1, 1), \
350                        wx.EXPAND | wx.ADJUST_MINSIZE, 0)
351        iy += 1
352        ix = 0
353        name = wx.StaticText(self, -1, 'Qx (Qy) Max: ')
354        sizer.Add(name, (iy, ix), (1, 1), \
355                        wx.EXPAND | wx.ADJUST_MINSIZE, 0)
356        ## add parameter value
357        ix += 1
358        self.qmax_ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH * 1.5, 20),
359                            style=wx.TE_PROCESS_ENTER)
360        self.qmax_ctl.Bind(wx.EVT_TEXT, self._onparamEnter )
361        self.qmax_ctl.SetValue(format_number(self.qmax_x, True))
362        sizer.Add(self.qmax_ctl, (iy, ix), (1, 1), wx.EXPAND)
363        ## add unit
364        ix += 1
365        unit = wx.StaticText(self, -1, '[1/A]')
366        sizer.Add(unit, (iy, ix), (1, 1), \
367                        wx.EXPAND | wx.ADJUST_MINSIZE, 0)
368        self.qrange_sizer.Add(sizer, 0, wx.LEFT, 10)
369   
370    def _layout_button(self): 
371        """
372            Do the layout for the button widgets
373        """ 
374        self.est_time = '*Estimated Computation time :\n  %s'
375        self.time_text = wx.StaticText(self, -1, self.est_time% str('2 sec') )
376        self.orient_combo = self._fill_orient_combo()
377        self.orient_combo.Show(False)
378        self.bt_compute = wx.Button(self, wx.NewId(),'Compute')
379        self.bt_compute.Bind(wx.EVT_BUTTON, self.on_compute)
380        self.bt_compute.SetToolTipString("Compute 2D Scattering Pattern.")
381        self.button_sizer.AddMany([(self.time_text , 0, wx.LEFT, 20),
382                                   (self.orient_combo , 0, wx.LEFT, 40),
383                                   (self.bt_compute, 0, wx.LEFT, 20)])
384       
385    def estimate_ctime(self):
386        """
387        Calculation time estimation
388        """
389        # magic equation: not very accurate
390        factor = 1
391        n_qbins = float(self.npt_ctl.GetValue())
392        n_qbins *= n_qbins
393        n_pixs = float(self.parent.get_npix())
394        if self.is_avg:
395            factor = 6
396            n_pixs *= (n_pixs / 200)
397        x_in = n_qbins * n_pixs / 100000
398        etime = factor + 0.085973 * x_in
399        return int(etime)
400       
401    def set_est_time(self):
402        """
403        Set text for est. computation time
404        """
405        unit = 'sec'
406        if self.time_text != None:
407            self.time_text.SetForegroundColour('black')
408            etime = self.estimate_ctime()
409            if etime > 60:
410                etime /= 60
411                unit = 'min'
412                self.time_text.SetForegroundColour('red')
413            time_str = str(etime) + ' ' + unit
414            self.time_text.SetLabel(self.est_time% time_str)
415       
416    def _do_layout(self):
417        """
418        Draw window content
419        """
420        self._define_structure()
421        self._layout_data_name()
422        self._layout_param_size()
423        self._layout_qrange()
424        self._layout_hint()
425        self._layout_shape()
426        self._layout_button()
427        self.boxsizer_source.AddMany([(self.data_name_sizer, 0,
428                                        wx.EXPAND|wx.TOP|wx.BOTTOM, 5),
429                                      (self.hint_sizer, 0,
430                                        wx.EXPAND|wx.TOP|wx.BOTTOM, 5),
431                                      (self.shape_sizer, 0, 
432                                        wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])
433        self.boxsizer_parameters.AddMany([(self.param_sizer, 0,
434                                     wx.EXPAND|wx.TOP|wx.BOTTOM, 5),])
435        self.boxsizer_qrange.AddMany([(self.qrange_sizer, 0,
436                                     wx.EXPAND|wx.TOP|wx.BOTTOM, 5),])
437        self.main_sizer.AddMany([(self.boxsizer_source, 0, 
438                                  wx.EXPAND|wx.ALL, 10),
439                                 (self.boxsizer_parameters, 0, 
440                                  wx.EXPAND|wx.ALL, 10),
441                                 (self.boxsizer_qrange, 0, 
442                                  wx.EXPAND|wx.ALL, 10),
443                                 (self.button_sizer, 0,
444                                  wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])
445        self.SetSizer(self.main_sizer)
446        self.SetAutoLayout(True)
447   
448    def _create_default_sld_data(self):
449        """
450        Making default sld-data
451        """
452        sld_n_default = 6.97e-06
453        omfdata = sans_gen.OMFData()
454        omf2sld = sans_gen.OMF2SLD()
455        omf2sld.set_data(omfdata, self.default_shape)
456        self.sld_data = omf2sld.output
457        self.sld_data.is_data = False
458        self.sld_data.filename = "Default SLD Profile"
459        self.sld_data.set_sldn(sld_n_default)
460        self.data_name_tcl.SetValue(self.sld_data.filename)       
461               
462    def choose_data_file(self, location=None):
463        """
464        Choosing a dtata file
465        """
466        path = None
467        filename = ''
468        if location == None:
469            location = os.getcwd()
470
471        exts = "*" + self.omfreader.ext[0]
472        exts += ", *" + self.sldreader.ext[0]
473        exts += ", *" + self.pdbreader.ext[0]
474        all_type = "All GEN files (%s, %s) | %s"% (exts.upper(), exts.lower(), 
475                                               exts.lower().replace(',', ';'))       
476        wildcard = [all_type]
477        omf_type = self.omfreader.type
478        sld_type = self.sldreader.type
479        pdb_type = self.pdbreader.type
480
481        for type in sld_type:
482            wildcard.append(type)
483        for type in omf_type:
484            wildcard.append(type)
485        for type in pdb_type:
486            wildcard.append(type)
487        wildcard = '|'.join(wildcard)
488        dlg = wx.FileDialog(self, "Choose a file", location,
489                            "", wildcard, wx.OPEN)
490        if dlg.ShowModal() == wx.ID_OK:
491            path = dlg.GetPath()
492            filename = os.path.basename(path)
493        dlg.Destroy() 
494        return path
495       
496    def on_load_data(self, event):
497        """
498        Open a file dialog to allow the user to select a given file.
499        The user is only allow to load file with extension .omf, .txt, .sld.
500        Display the slit size corresponding to the loaded data.
501        """
502        location = self.parent.get_path()
503        path = self.choose_data_file(location=location)
504        if path is None:
505            return 
506       
507        self.shape_sizer.ShowItems(False)
508        self.default_shape = 'rectangular'
509        self.parent.set_omfpanel_default_shap(self.default_shape)
510       
511        self.parent.set_file_location(os.path.dirname(path))
512        try:
513            #Load data
514            self.ext = os.path.splitext(path)[-1]
515            if self.ext in self.omfreader.ext:
516                loader = self.omfreader
517            elif self.ext in self.sldreader.ext:
518                loader = self.sldreader
519            elif self.ext in self.pdbreader.ext:
520                loader = self.pdbreader
521            else:
522                loader = None
523            if self.reader is not None and self.reader.isrunning():
524                self.reader.stop()
525            self.browse_button.Enable(False)
526            self.browse_button.SetLabel("Loading...")
527            if self.parent.parent is not None:
528                wx.PostEvent(self.parent.parent, 
529                                StatusEvent(status="Loading...",
530                                type="progress"))
531            self.reader = GenReader(path=path, loader=loader,
532                                    completefn=self.complete_loading,
533                                    updatefn=self.load_update)
534            self.reader.queue()
535            #self.load_update()
536        except:
537            self.ext = None
538            if self.parent.parent is None:
539                return 
540            msg = "Generic SANS Calculator: %s" % (sys.exc_value)
541            wx.PostEvent(self.parent.parent,
542                          StatusEvent(status=msg, type='stop'))
543            self.SetFocus()
544            return 
545       
546    def load_update(self):
547        """
548        print update on the status bar
549        """       
550        if self.parent.parent is None:
551                return 
552        if self.reader.isrunning():
553            type = "progress"
554        else:
555            type = "stop"
556        wx.PostEvent(self.parent.parent, StatusEvent(status="",
557                                                  type=type))
558           
559    def complete_loading(self, data=None, filename=''):
560        """
561        Complete the loading
562        """
563        #compute the slit size
564        self.browse_button.Enable(True)
565        self.browse_button.SetLabel('Load')
566        try:
567            is_pdbdata = False
568            filename = data.filename
569            self.data_name_tcl.SetValue(str(filename))
570            self.file_name = filename.split('.')[0]
571            self.orient_combo.SetSelection(0)
572            self.is_avg = False
573            if self.ext in self.omfreader.ext:
574                gen = sans_gen.OMF2SLD()
575                gen.set_data(data)
576                #omf_data = data
577                self.sld_data = gen.get_magsld()
578            elif self.ext in self.sldreader.ext:
579                self.sld_data = data
580            elif self.ext in self.pdbreader.ext:
581                self.sld_data = data
582                is_pdbdata = True
583                #omf_data = None
584            else:
585                raise
586            self.orient_combo.Show(is_pdbdata)
587            self.button_sizer.Layout()
588            self._set_sld_data_helper(True)
589        except:
590            if self.parent.parent is None:
591                raise
592            msg = "Loading Error: This file format is not supported "
593            msg += "for GenSANS." 
594            wx.PostEvent(self.parent.parent,
595                          StatusEvent(status=msg, type='stop', info='Error'))
596            self.SetFocus()
597            return 
598        if self.parent.parent is None:
599            return 
600       
601        msg = "Load Complete"
602        wx.PostEvent(self.parent.parent, StatusEvent(status=msg, type='stop'))
603        self.SetFocus()
604       
605    def _set_sld_data_helper(self, is_draw=False):
606        """
607        Set sld data helper
608        """
609        #is_avg = self.orient_combo.GetCurrentSelection() == 1
610        self.model.set_is_avg(self.is_avg)
611        self.model.set_sld_data(self.sld_data)
612       
613        self.draw_button.Enable(self.sld_data!=None)
614        wx.CallAfter(self.parent.set_sld_data, self.sld_data)
615        self._update_model_params()
616        if is_draw:
617            wx.CallAfter(self.sld_draw, None, False)
618   
619    def _update_model_params(self):
620        """
621        Update the model parameter values
622        """
623        for list in self.parameters:
624            param_name = list[0].GetLabelText()
625            val = str(self.model.params[param_name])
626            list[1].SetValue(val)
627   
628    def set_volume_ctl_val(self, val):
629        """
630        Set volume txtctrl value
631        """
632        for list in self.parameters:
633            param_name = list[0].GetLabelText()
634            if param_name.lower() == 'total_volume':
635                list[1].SetValue(val)
636                list[1].Refresh()
637                break
638                           
639    def _onparamEnter(self, event):
640        """
641        On param enter
642        """
643        try:
644            item = event.GetEventObject()
645            self._check_value()
646            item.Refresh()
647        except:
648            pass
649   
650    def sld_draw(self, event=None, has_arrow=True):
651        """
652        Draw 3D sld profile
653        """
654        flag = self.parent.check_omfpanel_inputs()
655        if not flag:
656            infor = 'Error'
657            msg = 'Error: Wrong inputs in the SLD info panel.'
658            # inform msg to wx
659            wx.PostEvent(self.parent.parent,
660                    StatusEvent(status=msg, info=infor))
661            self.SetFocus()
662            return
663
664        self.sld_data = self.parent.get_sld_from_omf()
665        output = self.sld_data 
666        #frame_size = wx.Size(470, 470)   
667        self.plot_frame = PlotFrame(self, -1, 'testView')
668        frame = self.plot_frame
669        frame.Show(False)
670        add_icon(self.parent, frame)
671        panel = frame.plotpanel   
672        try:
673            # mpl >= 1.0.0
674            ax = panel.figure.gca(projection='3d')
675        except:
676            # mpl < 1.0.0
677            try:
678                from mpl_toolkits.mplot3d import Axes3D
679                ax = Axes3D(panel.figure)
680            except:
681                logging.error("PlotPanel could not import Axes3D")
682                raise
683        panel.dimension = 3   
684        graph_title = self._sld_plot_helper(ax, output, has_arrow)
685        # Use y, z axes (in mpl 3d) as z, y axes
686        # that consistent with our SANS detector coords.
687        ax.set_xlabel('x ($\A%s$)'% output.pos_unit)
688        ax.set_ylabel('z ($\A%s$)'% output.pos_unit)
689        ax.set_zlabel('y ($\A%s$)'% output.pos_unit)
690        panel.subplot.figure.subplots_adjust(left=0.05, right=0.95, 
691                                             bottom=0.05, top=0.96)
692        if output.pix_type == 'atom':
693            ax.legend(loc='upper left', prop={'size':10})
694        num_graph = str(self.graph_num)
695        frame.SetTitle('Graph %s: %s'% (num_graph, graph_title))       
696        wx.CallAfter(frame.Show, True)
697        self.graph_num += 1
698
699    def _sld_plot_helper(self, ax, output, has_arrow=False):
700        """
701        Actual plot definition happens here
702        :Param ax: axis3d
703        :Param output: sld_data [MagSLD]
704        :Param has_arrow: whether or not draws M vector [bool]
705        """
706        # Set the locals
707        color_dic = {'H':'blue', 'D':'purple', 'N': 'orange', 
708                     'O':'red', 'C':'green', 'P':'cyan', 'Other':'k'}
709        marker = ','
710        m_size = 2
711        graph_title = self.file_name
712        graph_title += "   3D SLD Profile "
713        pos_x = output.pos_x
714        pos_y = output.pos_y
715        pos_z = output.pos_z
716        sld_mx = output.sld_mx
717        sld_my = output.sld_my
718        sld_mz = output.sld_mz
719        pix_symbol = output.pix_symbol
720        if output.pix_type == 'atom':
721            marker = 'o'
722            m_size = 3.5
723        sld_tot = (numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \
724                   numpy.fabs(sld_mz) + numpy.fabs(output.sld_n))
725        is_nonzero = sld_tot > 0.0 
726        is_zero = sld_tot == 0.0   
727        # I. Plot null points
728        if is_zero.any():
729            ax.plot(pos_x[is_zero], pos_z[is_zero], pos_y[is_zero], marker, 
730                    c="y", alpha=0.5, markeredgecolor='y', markersize=m_size) 
731            pos_x = pos_x[is_nonzero]
732            pos_y = pos_y[is_nonzero]
733            pos_z = pos_z[is_nonzero]
734            sld_mx = sld_mx[is_nonzero]
735            sld_my = sld_my[is_nonzero]
736            sld_mz = sld_mz[is_nonzero]
737            pix_symbol = output.pix_symbol[is_nonzero]
738        # II. Plot selective points in color
739        other_color = numpy.ones(len(pix_symbol), dtype='bool')
740        for key in color_dic.keys():
741            chosen_color = pix_symbol == key
742            if numpy.any(chosen_color):
743                other_color = other_color  & (chosen_color != True)
744                color = color_dic[key]
745                ax.plot(pos_x[chosen_color], pos_z[chosen_color], 
746                        pos_y[chosen_color], marker, c=color, alpha=0.5, 
747                        markeredgecolor=color, markersize=m_size, label=key) 
748        # III. Plot All others       
749        if numpy.any(other_color):
750            a_name = ''
751            if output.pix_type == 'atom':
752                # Get atom names not in the list
753                a_names = [symb  for symb in pix_symbol \
754                           if symb not in color_dic.keys()]
755                a_name = a_names[0]
756                for name in a_names:
757                    new_name = ", " + name
758                    if a_name.count(name) == 0:
759                        a_name += new_name
760            # plot in black
761            ax.plot(pos_x[other_color], pos_z[other_color], pos_y[other_color], 
762                    marker, c="k", alpha=0.5, markeredgecolor="k", 
763                    markersize=m_size, label=a_name) 
764        # IV. Draws atomic bond with grey lines if any
765        if output.has_conect:
766            for ind in range(len(output.line_x)):
767                ax.plot(output.line_x[ind], output.line_z[ind], 
768                        output.line_y[ind], '-', lw=0.6, c="grey", alpha=0.3) 
769        # V. Draws magnetic vectors
770        if has_arrow and len(pos_x) > 0:     
771            graph_title += " - Magnetic Vector as Arrow -" 
772            panel = self.plot_frame.plotpanel
773            def _draw_arrow(input=None, update=None):
774                """
775                draw magnetic vectors w/arrow
776                """
777                max_mx = max(numpy.fabs(sld_mx))
778                max_my = max(numpy.fabs(sld_my))
779                max_mz = max(numpy.fabs(sld_mz))
780                max_m = max(max_mx, max_my, max_mz)
781                try:
782                    max_step = max(output.xstepsize, output.ystepsize, 
783                                   output.zstepsize)
784                except:
785                    max_step = 0
786                if max_step <= 0:
787                    max_step = 5
788                try:
789                    if max_m != 0:
790                        unit_x2 = sld_mx / max_m
791                        unit_y2 = sld_my / max_m
792                        unit_z2 = sld_mz / max_m
793                        # 0.8 is for avoiding the color becomes white=(1,1,1))
794                        color_x = numpy.fabs(unit_x2 * 0.8)
795                        color_y = numpy.fabs(unit_y2 * 0.8)
796                        color_z = numpy.fabs(unit_z2 * 0.8)
797                        x2 = pos_x + unit_x2 * max_step
798                        y2 = pos_y + unit_y2 * max_step
799                        z2 = pos_z + unit_z2 * max_step
800                        x_arrow = numpy.column_stack((pos_x, x2))
801                        y_arrow = numpy.column_stack((pos_y, y2))
802                        z_arrow = numpy.column_stack((pos_z, z2))
803                        colors = numpy.column_stack((color_x, color_y, color_z))
804                        arrows = Arrow3D(panel, x_arrow, z_arrow, y_arrow, 
805                                        colors, mutation_scale=10, lw=1, 
806                                        arrowstyle="->", alpha = 0.5)
807                        ax.add_artist(arrows) 
808                except:
809                    pass 
810                msg = "Arrow Drawing completed.\n"
811                status_type = 'stop'
812                self._status_info(msg, status_type) 
813            msg = "Arrow Drawing is in progress..."
814            status_type = 'progress'
815            self._status_info(msg, status_type) 
816            draw_out = CalcGen(input=ax,
817                             completefn=_draw_arrow, updatefn=self._update)
818            draw_out.queue()
819        return graph_title
820 
821    def set_input_params(self):
822        """
823        Set model parameters
824        """
825        for list in self.parameters:
826            param_name = list[0].GetLabelText()
827            param_value = float(list[1].GetValue())
828            self.model.setParam(param_name, param_value)
829           
830    def on_compute(self, event):
831        """
832        Compute I(qx, qy)
833        """
834        flag = self.parent.check_omfpanel_inputs()
835        if not flag and self.parent.parent != None:
836            infor = 'Error'
837            msg = 'Error: Wrong inputs in the SLD info panel.'
838            # inform msg to wx
839            wx.PostEvent(self.parent.parent,
840                    StatusEvent(status=msg, info=infor))
841            self.SetFocus()
842            return
843        self.sld_data = self.parent.get_sld_from_omf()
844        if self.sld_data == None:
845            if self.parent.parent != None:
846                infor = 'Error'
847                msg = 'Error: No data has been selected.'
848                # inform msg to wx
849                wx.PostEvent(self.parent.parent,
850                        StatusEvent(status=msg, info=infor))
851                self.SetFocus()
852            return
853        flag = self._check_value()
854        if not flag:
855            _set_error(self, None, True)
856            return
857        try:
858            self.model.set_sld_data(self.sld_data)
859            self.set_input_params()
860            if self.is_avg or self.is_avg == None:
861                self._create_default_1d_data()
862                i_out = numpy.zeros(len(self.data.y))
863                inputs = [self.data.x, [], i_out]
864            else:
865                self._create_default_2d_data()
866                i_out = numpy.zeros(len(self.data.data))
867                inputs=[self.data.qx_data, self.data.qy_data, i_out]
868               
869            msg = "Computation is in progress..."
870            status_type = 'progress'
871            self._status_info(msg, status_type)
872            cal_out = CalcGen(input=inputs, 
873                              completefn=self.complete, 
874                              updatefn=self._update)
875            cal_out.queue()             
876           
877        except:
878            msg = "%s."% sys.exc_value
879            status_type = 'stop'
880            self._status_info(msg, status_type)
881            wx.PostEvent(self.parent.parent,
882                        StatusEvent(status=msg, info='Error'))
883            self.SetFocus()
884
885    def _check_value(self):
886        """
887        Check input values if float
888        """
889        flag = True
890        self.npt_ctl.SetBackgroundColour("white")
891        self.qmax_ctl.SetBackgroundColour("white")
892        try:
893            npt_val = float(self.npt_ctl.GetValue()) 
894            if npt_val < 2 or npt_val > 1000:
895                raise
896            self.npt_ctl.SetValue(str(int(npt_val)))
897            self.set_est_time()
898        except:
899            flag =  _set_error(self, self.npt_ctl)
900        try:
901            qmax_val = float(self.qmax_ctl.GetValue()) 
902            if qmax_val <= 0 or qmax_val > 1000:
903                raise
904        except:
905            flag = _set_error(self, self.qmax_ctl)       
906        for list in self.parameters:
907            list[1].SetBackgroundColour("white")
908            param_name = list[0].GetLabelText()
909            try: 
910                param_val = float(list[1].GetValue())
911                if param_name.count('frac') > 0:
912                    if param_val < 0 or param_val > 1:
913                       raise
914            except:
915                flag = _set_error(self, list[1])
916        return flag
917                   
918    def _status_info(self, msg = '', type = "update"):
919        """
920        Status msg
921        """
922        if type == "stop":
923            label = "Compute"
924            able = True
925        else:   
926            label = "Wait..."
927            able = False
928        self.bt_compute.Enable(able)
929        self.bt_compute.SetLabel(label)
930        self.bt_compute.SetToolTipString(label)
931        if self.parent.parent != None:
932            wx.PostEvent(self.parent.parent, 
933                             StatusEvent(status = msg, type = type )) 
934
935    def _update(self, time=None):
936        """
937        Update the progress bar
938        """
939        if self.parent.parent == None:
940            return
941        type = "progress"
942        msg = "Please wait. Computing... (Note: Window may look frozen.)"
943        wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
944                                                  type=type))
945                               
946    def complete(self, input, update=None):   
947        """
948        Gen compute complete function
949        :Param input: input list [qx_data, qy_data, i_out]
950        """
951        out = numpy.empty(0)
952        #s = time.time()
953        for ind in range(len(input[0])):
954            if self.is_avg:
955                if ind % 1 == 0 and update != None:
956                    update()
957                    time.sleep(0.1)
958                inputi = [input[0][ind:ind+1], [], input[2][ind:ind+1]]
959                outi = self.model.run(inputi)
960                out = numpy.append(out, outi)
961            else:
962                if ind % 50 == 0  and update != None:
963                    update()
964                    time.sleep(0.001)
965                inputi = [input[0][ind:ind+1], input[1][ind:ind+1], 
966                          input[2][ind:ind+1]]
967                outi = self.model.runXY(inputi)
968                out = numpy.append(out, outi)
969        #print time.time() - s
970        if self.is_avg or self.is_avg == None:
971            self._draw1D(out)
972        else:
973            #out = self.model.runXY(input)
974            self._draw2D(out)
975           
976        msg = "Gen computation completed.\n"
977        status_type = 'stop'
978        self._status_info(msg, status_type)
979               
980    def _create_default_2d_data(self):
981        """
982        Create 2D data by default
983        Only when the page is on theory mode.
984        :warning: This data is never plotted.
985        """
986        self.qmax_x = float(self.qmax_ctl.GetValue())
987        self.npts_x = int(float(self.npt_ctl.GetValue()))
988        self.data = Data2D()
989        qmax = self.qmax_x #/ numpy.sqrt(2)
990        self.data.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
991        self.data.yaxis('\\rm{Q_{y}}', '\AA^{-1}')
992        self.data.is_data = False
993        self.data.id = str(self.uid) + " GenData"
994        self.data.group_id = str(self.uid) + " Model2D"
995        ## Default values
996        self.data.detector.append(Detector())
997        index = len(self.data.detector) - 1
998        self.data.detector[index].distance = 8000   # mm
999        self.data.source.wavelength = 6             # A
1000        self.data.detector[index].pixel_size.x = 5  # mm
1001        self.data.detector[index].pixel_size.y = 5  # mm
1002        self.data.detector[index].beam_center.x = qmax
1003        self.data.detector[index].beam_center.y = qmax
1004        xmax = qmax
1005        xmin = -qmax
1006        ymax = qmax
1007        ymin = -qmax
1008        qstep = self.npts_x
1009
1010        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
1011        y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True)
1012        ## use data info instead
1013        new_x = numpy.tile(x, (len(y), 1))
1014        new_y = numpy.tile(y, (len(x), 1))
1015        new_y = new_y.swapaxes(0, 1)
1016        # all data reuire now in 1d array
1017        qx_data = new_x.flatten()
1018        qy_data = new_y.flatten()
1019        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data)
1020        # set all True (standing for unmasked) as default
1021        mask = numpy.ones(len(qx_data), dtype=bool)
1022        # store x and y bin centers in q space
1023        x_bins = x
1024        y_bins = y
1025        self.data.source = Source()
1026        self.data.data = numpy.ones(len(mask))
1027        self.data.err_data = numpy.ones(len(mask))
1028        self.data.qx_data = qx_data
1029        self.data.qy_data = qy_data
1030        self.data.q_data = q_data
1031        self.data.mask = mask
1032        self.data.x_bins = x_bins
1033        self.data.y_bins = y_bins
1034        # max and min taking account of the bin sizes
1035        self.data.xmin = xmin
1036        self.data.xmax = xmax
1037        self.data.ymin = ymin
1038        self.data.ymax = ymax
1039
1040    def _create_default_1d_data(self):
1041        """
1042        Create 2D data by default
1043        Only when the page is on theory mode.
1044        :warning: This data is never plotted.
1045                    residuals.x = data_copy.x[index]
1046            residuals.dy = numpy.ones(len(residuals.y))
1047            residuals.dx = None
1048            residuals.dxl = None
1049            residuals.dxw = None
1050        """
1051        self.qmax_x = float(self.qmax_ctl.GetValue())
1052        self.npts_x = int(float(self.npt_ctl.GetValue()))
1053        qmax = self.qmax_x #/ numpy.sqrt(2)
1054        ## Default values
1055        xmax = qmax
1056        xmin = qmax * _Q1D_MIN
1057        qstep = self.npts_x
1058        x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True)
1059        # store x and y bin centers in q space
1060        #self.data.source = Source()
1061        y = numpy.ones(len(x))
1062        dy = numpy.zeros(len(x))
1063        dx = numpy.zeros(len(x))
1064        self.data = Data1D(x=x, y=y)
1065        self.data.dx = dx
1066        self.data.dy = dy
1067
1068    def _draw1D(self, y_out):
1069        """
1070        Complete get the result of modelthread and create model 2D
1071        that can be plot.
1072        """
1073        page_id = self.id
1074        data = self.data
1075       
1076        model = self.model
1077        state = None
1078       
1079        new_plot = Data1D(x=data.x, y=y_out)
1080        new_plot.dx = data.dx
1081        new_plot.dy = data.dy
1082        new_plot.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
1083        new_plot.yaxis('\\rm{Intensity}', 'cm^{-1}')
1084        new_plot.is_data = False
1085        new_plot.id = str(self.uid) + " GenData1D"
1086        new_plot.group_id = str(self.uid) + " Model1D"
1087        new_plot.name = model.name + '1d'
1088        new_plot.title = "Generic model1D "
1089        new_plot.id = str(page_id) + ': ' + self.file_name \
1090                        + ' #%s'% str(self.graph_num) + "_1D"
1091        new_plot.group_id = str(page_id) + " Model1D"  +\
1092                             ' #%s'% str(self.graph_num) + "_1D"
1093        new_plot.is_data = False
1094
1095        title = new_plot.title
1096        _yaxis, _yunit = new_plot.get_yaxis()
1097        _xaxis, _xunit = new_plot.get_xaxis()
1098        new_plot.xaxis(str(_xaxis), str(_xunit))
1099        new_plot.yaxis(str(_yaxis), str(_yunit))
1100       
1101        if new_plot.is_data:
1102            data_name = str(new_plot.name)
1103        else:
1104            data_name = str(model.__class__.__name__) + '1d'
1105
1106        if len(title) > 1:
1107            new_plot.title = "Gen Theory for %s "% model.name + data_name
1108        new_plot.name = new_plot.id
1109        new_plot.label = new_plot.id
1110        #theory_data = deepcopy(new_plot)
1111        if self.parent.parent != None:
1112            self.parent.parent.update_theory(data_id=new_plot.id,
1113                                           theory=new_plot,
1114                                           state=state)
1115        title = new_plot.title
1116        num_graph = str(self.graph_num)
1117        wx.CallAfter(self.parent.draw_graph, new_plot, 
1118                     title="GEN Graph %s: "% num_graph + new_plot.id )
1119        self.graph_num += 1
1120               
1121    def _draw2D(self, image):
1122        """
1123        Complete get the result of modelthread and create model 2D
1124        that can be plot.
1125        """
1126        page_id = self.id
1127        data = self.data
1128       
1129        model = self.model
1130        qmin = 0.0
1131        state = None
1132       
1133        numpy.nan_to_num(image)
1134        new_plot = Data2D(image=image, err_image=data.err_data)
1135        new_plot.name = model.name + '2d'
1136        new_plot.title = "Generic model 2D "
1137        new_plot.id = str(page_id) + ': ' + self.file_name \
1138                        + ' #%s'% str(self.graph_num) + "_2D"
1139        new_plot.group_id = str(page_id) + " Model2D" \
1140                        + ' #%s'% str(self.graph_num) + "_2D"
1141        new_plot.detector = data.detector
1142        new_plot.source = data.source
1143        new_plot.is_data = False
1144        new_plot.qx_data = data.qx_data
1145        new_plot.qy_data = data.qy_data
1146        new_plot.q_data = data.q_data
1147        new_plot.mask = data.mask
1148        ## plot boundaries
1149        new_plot.ymin = data.ymin
1150        new_plot.ymax = data.ymax
1151        new_plot.xmin = data.xmin
1152        new_plot.xmax = data.xmax
1153        title = data.title
1154        _yaxis, _yunit = data.get_yaxis()
1155        _xaxis, _xunit = data.get_xaxis()
1156        new_plot.xaxis(str(_xaxis), str(_xunit))
1157        new_plot.yaxis(str(_yaxis), str(_yunit))
1158       
1159        new_plot.is_data = False
1160        if data.is_data:
1161            data_name = str(data.name)
1162        else:
1163            data_name = str(model.__class__.__name__) + '2d'
1164
1165        if len(title) > 1:
1166            new_plot.title = "Gen Theory for %s "% model.name + data_name
1167        new_plot.name = new_plot.id
1168        new_plot.label = new_plot.id
1169        #theory_data = deepcopy(new_plot)
1170        if self.parent.parent != None:
1171            self.parent.parent.update_theory(data_id=data.id,
1172                                           theory=new_plot,
1173                                           state=state)
1174        title = new_plot.title
1175        num_graph = str(self.graph_num)
1176        wx.CallAfter(self.parent.draw_graph, new_plot, 
1177                     title="GEN Graph %s: "% num_graph + new_plot.id )
1178        self.graph_num += 1
1179         
1180    def set_scale2d(self, scale):
1181        """
1182        Set SLD plot scale
1183        """
1184        self.scale2d = None
1185       
1186    def on_panel_close(self, event):
1187        """
1188        On Close SLD panel
1189        """
1190        #Not implemented   
1191                 
1192class OmfPanel(ScrolledPanel, PanelBase):
1193    """
1194        Provides the sas gen calculator GUI.
1195    """
1196    ## Internal nickname for the window, used by the AUI manager
1197    window_name = "SLD Pixel Info"
1198    ## Name to appear on the window title bar
1199    window_caption = "SLD Pixel Info "
1200    ## Flag to tell the AUI manager to put this panel in the center pane
1201    CENTER_PANE = False
1202   
1203    def __init__(self, parent, *args, **kwds):
1204        ScrolledPanel.__init__(self, parent, style=wx.RAISED_BORDER, 
1205                               *args, **kwds)
1206        PanelBase.__init__(self)
1207        #Font size
1208        self.SetWindowVariant(variant=FONT_VARIANT)
1209        self.SetupScrolling() 
1210        # Object that receive status event
1211        self.parent = parent
1212        self.sld_data = sans_gen.MagSLD([0], [0], [0]) 
1213        self.sld_ctl = None
1214        self.default_shape = 'rectangular'
1215        self._do_layout()
1216       
1217    def set_slddata(self, slddata):
1218        """
1219        Set sld data related items
1220        """
1221        self.sld_data = slddata
1222        self._set_slddata_ctr_val(slddata)
1223        # Make sure that self._set_slddata_ctr_val() is finished
1224        wx.CallAfter(self._set_omfdata_ctr, slddata)
1225   
1226    def get_sld_val(self):
1227        """
1228        Set sld_n of slddata on sld input
1229        """
1230        sld_sets = {}
1231        if not self.sld_data.is_data:
1232            self._get_other_val()
1233        for list in self.slds:
1234            if list[1].IsEnabled():
1235                list[1].SetBackgroundColour("white")
1236                list[1].Refresh()
1237                try:
1238                    val = float(list[1].GetValue())
1239                    sld_sets[list[0]] = val
1240                except:
1241                    flag = _set_error(self, list[1])
1242                    if not flag:
1243                        return self.sld_data
1244            else:
1245               sld_sets[list[0]] = None
1246        for key in sld_sets.keys():
1247            key_low = key.lower()
1248            if key_low.count('mx') > 0:
1249                if sld_sets[key] == None:
1250                    sld_sets[key] = self.sld_data.sld_mx
1251                mx = sld_sets[key]
1252            elif key_low.count('my') > 0:
1253                if sld_sets[key] == None:
1254                    sld_sets[key] = self.sld_data.sld_my
1255                my = sld_sets[key]
1256            elif key_low.count('mz') > 0:
1257                if sld_sets[key] == None:
1258                    sld_sets[key] = self.sld_data.sld_mz
1259                mz = sld_sets[key]
1260            else:
1261                if sld_sets[key] != None:
1262                    self.sld_data.set_sldn(sld_sets[key])
1263        self.sld_data.set_sldms(mx, my, mz)
1264        self._set_slddata_ctr_val(self.sld_data)
1265       
1266        return self.sld_data
1267   
1268    def get_pix_volumes(self):
1269        """
1270        Get the pixel volume
1271        """
1272        vol = self.sld_data.vol_pix
1273       
1274        return vol
1275               
1276    def _get_other_val(self): 
1277        """
1278        """
1279        omfdata = sans_gen.OMFData()
1280        sets = {}
1281        try:
1282            for lst in self.stepsize:
1283                if lst[1].IsEnabled():
1284                    val = float(lst[1].GetValue())
1285                    sets[lst[0]] = val
1286                else:
1287                    sets[lst[0]] = None
1288                    return
1289            for lst in self.nodes:
1290                if lst[1].IsEnabled():
1291                    val = float(lst[1].GetValue())
1292                    sets[lst[0]] = val
1293                else:
1294                    sets[lst[0]] = None
1295                    return
1296                   
1297            for key in sets.keys():
1298                exec "omfdata.%s = sets['%s']"% (key, key)           
1299
1300            omf2sld = sans_gen.OMF2SLD()
1301            omf2sld.set_data(omfdata, self.default_shape)
1302            self.sld_data = omf2sld.output
1303            self.sld_data.is_data = False
1304            self.sld_data.filename = "Default SLD Profile"
1305        except:
1306            msg = "OMF Panel: %s"% sys.exc_value
1307            infor = 'Error'
1308            #logging.error(msg)
1309            if self.parent.parent != None:
1310                # inform msg to wx
1311                wx.PostEvent(self.parent.parent,
1312                        StatusEvent(status=msg, info=infor))
1313                self.SetFocus()
1314               
1315    def _set_slddata_ctr_val(self, slddata):
1316        """
1317        Set slddata crl
1318        """
1319        try:
1320            val = str(len(slddata.sld_n))
1321        except:
1322            val = 'Unknown'
1323        self.npix_ctl.SetValue(val)
1324       
1325    def _set_omfdata_ctr(self, omfdata):   
1326        """
1327        Set the textctr box values
1328        """
1329       
1330        if omfdata == None:
1331            self._set_none_text()
1332            return
1333        nodes_list = self._get_nodes_key_list(omfdata)
1334        step_list = self._get_step_key_list(omfdata)
1335        for ctr_list in self.nodes:
1336            for key in nodes_list.keys():
1337                if ctr_list[0] == key:
1338                    ctr_list[1].SetValue(format_number(nodes_list[key], True))
1339                    ctr_list[1].Enable(not omfdata.is_data)
1340                    break
1341        for ctr_list in self.stepsize:
1342            for key in step_list.keys():
1343                if ctr_list[0] == key:
1344                    ctr_list[1].SetValue(format_number(step_list[key], True))
1345                    ctr_list[1].Enable(not omfdata.is_data)
1346                    break   
1347               
1348    def _set_none_text(self):
1349        """
1350        Set Unknown in textctrls
1351        """
1352        val = 'Unknown'
1353        for ctr_list in self.nodes:
1354            ctr_list[1].SetValue(val)
1355        for ctr_list in self.stepsize:
1356            ctr_list[1].SetValue(val)
1357               
1358    def _define_structure(self):
1359        """
1360        Define the main sizers building to build this application.
1361        """
1362        self.main_sizer = wx.BoxSizer(wx.VERTICAL)
1363       
1364        self.npixels_sizer = wx.BoxSizer(wx.HORIZONTAL)
1365        self.box_sld = wx.StaticBox(self, -1, 
1366                                    str("Mean SLD"))
1367        self.box_node = wx.StaticBox(self, -1, str("Nodes"))
1368        self.boxsizer_sld = wx.StaticBoxSizer(self.box_sld, wx.VERTICAL)
1369        self.box_stepsize = wx.StaticBox(self, -1, str("Step Size"))
1370        self.boxsizer_node = wx.StaticBoxSizer(self.box_node, wx.VERTICAL)
1371        self.boxsizer_stepsize = wx.StaticBoxSizer(self.box_stepsize,
1372                                                    wx.VERTICAL)
1373        self.sld_sizer = wx.BoxSizer(wx.HORIZONTAL)
1374        self.node_sizer = wx.BoxSizer(wx.HORIZONTAL)
1375        self.step_sizer = wx.BoxSizer(wx.HORIZONTAL)
1376        self.hint_sizer = wx.BoxSizer(wx.HORIZONTAL)
1377        self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1378               
1379    def _layout_npix(self):
1380        """
1381        Build No of pixels sizer
1382        """
1383        num_pix_text = wx.StaticText(self, -1, "No. of Pixels: ") 
1384        self.npix_ctl = OutputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1385                                style=wx.TE_PROCESS_ENTER)
1386        self._set_slddata_ctr_val(self.sld_data)
1387        self._set_omfdata_ctr(self.sld_data) 
1388        self.npixels_sizer.AddMany([(num_pix_text, 0,
1389                                          wx.EXPAND|wx.LEFT|wx.TOP, 5),
1390                                     (self.npix_ctl, 0,
1391                                     wx.EXPAND|wx.TOP, 5)])
1392
1393    def _layout_slds(self):
1394        """
1395        Build nuclear sld sizer
1396        """
1397        self.slds = []
1398        omfdata = self.sld_data
1399        if omfdata == None:
1400            raise
1401        sld_key_list = self._get_slds_key_list(omfdata)
1402        # Dic is not sorted
1403        key_list = [key for key in sld_key_list.keys()]
1404        # Sort here
1405        key_list.sort()
1406        is_data = self.sld_data.is_data
1407        sizer = wx.GridBagSizer(2, 3)
1408        ix = 0
1409        iy = -1
1410        for key in key_list:
1411            value = sld_key_list[key]
1412            iy += 1
1413            ix = 0
1414            name = wx.StaticText(self, -1, key)
1415            sizer.Add(name, (iy, ix), (1, 1), \
1416                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
1417            ## add parameter value
1418            ix += 1
1419            ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1420                                style=wx.TE_PROCESS_ENTER)
1421            ctl.SetValue(format_number(value, True))
1422            ctl.Enable(not is_data)
1423            sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
1424            ## add unit
1425            ix += 1
1426            s_unit = '[' + omfdata.sld_unit + ']'
1427            unit = wx.StaticText(self, -1, s_unit)
1428            sizer.Add(unit, (iy, ix), (1, 1), \
1429                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
1430            self.slds.append([key, ctl, unit])
1431        self.sld_sizer.Add(sizer, 0, wx.LEFT, 10) 
1432               
1433    def _layout_nodes(self):
1434        """
1435        Fill the sizer containing data's name
1436        """
1437        self.nodes = []
1438        omfdata = self.sld_data
1439        if omfdata == None:
1440            raise
1441        key_list = self._get_nodes_key_list(omfdata)
1442        is_data = self.sld_data.is_data
1443        sizer = wx.GridBagSizer(2, 3)
1444        ix = 0
1445        iy = -1
1446        for key, value in key_list.iteritems():
1447            iy += 1
1448            ix = 0
1449            name = wx.StaticText(self, -1, key)
1450            sizer.Add(name, (iy, ix), (1, 1), \
1451                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
1452            ## add parameter value
1453            ix += 1
1454            ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1455                                style=wx.TE_PROCESS_ENTER)
1456            ctl.Bind(wx.EVT_TEXT, self._onparamEnter )
1457            ctl.SetValue(format_number(value, True))
1458            ctl.Enable(not is_data)
1459            sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
1460            ## add unit
1461            ix += 1
1462            unit = wx.StaticText(self, -1, '')
1463            sizer.Add(unit, (iy, ix), (1, 1), \
1464                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
1465            self.nodes.append([key, ctl, unit])
1466        self.node_sizer.Add(sizer, 0, wx.LEFT, 10)
1467           
1468    def _layout_stepsize(self):
1469        """
1470        Fill the sizer containing slit size information
1471        """
1472        self.stepsize = []
1473        omfdata = self.sld_data
1474        if omfdata == None:
1475            raise
1476        key_list = self._get_step_key_list(omfdata)
1477        is_data = self.sld_data.is_data
1478        sizer = wx.GridBagSizer(2, 3)
1479        ix = 0
1480        iy = -1
1481        #key_list.sort()
1482        for key, value in key_list.iteritems():
1483            iy += 1
1484            ix = 0
1485            name = wx.StaticText(self, -1, key)
1486            sizer.Add(name, (iy, ix), (1, 1), \
1487                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
1488            ## add parameter value
1489            ix += 1
1490            ctl = InputTextCtrl(self, -1, size=(_BOX_WIDTH, 20),
1491                                style=wx.TE_PROCESS_ENTER)
1492            ctl.Bind(wx.EVT_TEXT, self._onstepsize )
1493            ctl.SetValue(format_number(value, True))
1494            ctl.Enable(not is_data)
1495            sizer.Add(ctl, (iy, ix), (1, 1), wx.EXPAND)
1496            ## add unit
1497            ix += 1
1498            p_unit = '[' + omfdata.pos_unit + ']'
1499            unit = wx.StaticText(self, -1, p_unit)
1500            sizer.Add(unit, (iy, ix), (1, 1), \
1501                            wx.EXPAND | wx.ADJUST_MINSIZE, 0)
1502            self.stepsize.append([key, ctl, unit])
1503        self.step_sizer.Add(sizer, 0, wx.LEFT, 10)
1504   
1505    def _layout_hint(self):
1506        """
1507        Fill the sizer containing hint
1508        """
1509        hint_msg = "Load an omf or 3d sld profile data file."
1510        self.hint_txt = wx.StaticText(self, -1, hint_msg)
1511        self.hint_sizer.AddMany([(self.hint_txt, 0, wx.LEFT, 15)])
1512   
1513    def _layout_button(self): 
1514        """
1515        Do the layout for the button widgets
1516        """ 
1517        self.bt_draw = wx.Button(self, wx.NewId(),'Draw Points')
1518        self.bt_draw.Bind(wx.EVT_BUTTON, self.on_sld_draw)
1519        self.bt_draw.SetToolTipString("Draw a scatter plot for sld profile.")
1520        self.bt_save = wx.Button(self, wx.NewId(),'Save SLD Data')
1521        self.bt_save.Bind(wx.EVT_BUTTON, self.on_save)
1522        self.bt_save.Enable(False)
1523        self.bt_save.SetToolTipString("Save SLD data.")
1524        self.button_sizer.AddMany([(self.bt_draw, 0, wx.LEFT, 10),
1525                                   (self.bt_save, 0, wx.LEFT, 10)])
1526       
1527    def _do_layout(self):
1528        """
1529        Draw window content
1530        """
1531        self._define_structure()
1532        self._layout_nodes()
1533        self._layout_stepsize()
1534        self._layout_npix()
1535        self._layout_slds()
1536        #self._layout_hint()
1537        self._layout_button()
1538        self.boxsizer_node.AddMany([(self.node_sizer, 0,
1539                                    wx.EXPAND|wx.TOP, 5),
1540                                     (self.hint_sizer, 0,
1541                                     wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])
1542        self.boxsizer_stepsize.AddMany([(self.step_sizer, 0,
1543                                     wx.EXPAND|wx.TOP|wx.BOTTOM, 5),])
1544        self.boxsizer_sld.AddMany([(self.sld_sizer, 0,
1545                                     wx.EXPAND|wx.BOTTOM, 5),])
1546        self.main_sizer.AddMany([(self.npixels_sizer, 0, wx.EXPAND|wx.ALL, 10),
1547                        (self.boxsizer_sld, 0, wx.EXPAND|wx.ALL, 10),
1548                        (self.boxsizer_node, 0, wx.EXPAND|wx.ALL, 10),
1549                        (self.boxsizer_stepsize, 0, wx.EXPAND|wx.ALL, 10),
1550                        (self.button_sizer, 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 5)])
1551        self.SetSizer(self.main_sizer)
1552        self.SetAutoLayout(True)
1553       
1554    def _get_nodes_key_list(self, data):
1555        """
1556        Return nodes key list
1557       
1558        :Param data: OMFData
1559        """
1560        key_list = {'xnodes' : data.xnodes, 
1561                    'ynodes' : data.ynodes,
1562                    'znodes' : data.znodes}
1563        return key_list
1564       
1565    def _get_slds_key_list(self, data):
1566        """
1567        Return nodes key list
1568       
1569        :Param data: OMFData
1570        """
1571        key_list = {'Nucl.' : data.sld_n, 
1572                    'Mx' : data.sld_mx,
1573                    'My' : data.sld_my,
1574                    'Mz' : data.sld_mz}
1575        return key_list
1576
1577    def _get_step_key_list(self, data):
1578        """
1579        Return step key list
1580       
1581        :Param data: OMFData
1582        """
1583        key_list = {'xstepsize' : data.xstepsize, 
1584                    'ystepsize' : data.ystepsize,
1585                    'zstepsize' : data.zstepsize}
1586        return key_list       
1587   
1588    def set_sld_ctr(self, sld_data):
1589        """
1590        Set sld textctrls
1591        """
1592        if sld_data == None:
1593            for ctr_list in self.slds:
1594                ctr_list[1].Enable(False)
1595                #break   
1596            return
1597       
1598        self.sld_data = sld_data
1599        sld_list = self._get_slds_key_list(sld_data)
1600        for ctr_list in self.slds:
1601            for key in sld_list.keys():
1602                if ctr_list[0] == key:
1603                    min_val = numpy.min(sld_list[key])
1604                    max_val = numpy.max(sld_list[key])
1605                    mean_val = numpy.mean(sld_list[key])
1606                    enable = (min_val == max_val) and \
1607                             sld_data.pix_type == 'pixel'
1608                    ctr_list[1].SetValue(format_number(mean_val, True))
1609                    ctr_list[1].Enable(enable)
1610                    #ctr_list[2].SetLabel("[" + sld_data.sld_unit + "]")
1611                    break   
1612
1613    def on_sld_draw(self, event):
1614        """
1615        Draw sld profile as scattered plot
1616        """
1617        self.parent.sld_draw()
1618         
1619    def on_save(self, event):
1620        """
1621        Close the window containing this panel
1622        """
1623        flag = True
1624        flag = self.check_inputs()
1625        if not flag:
1626            return
1627        self.sld_data = self.get_sld_val()
1628        self.parent.set_main_panel_sld_data(self.sld_data)
1629       
1630        reader = sans_gen.SLDReader() 
1631        extension = '*.sld'
1632        path = None
1633        data= None
1634        location = self.parent.get_path()
1635        dlg = wx.FileDialog(self, "Save sld file",
1636                            location, "sld_file",
1637                             extension, 
1638                             wx.SAVE)
1639        if dlg.ShowModal() == wx.ID_OK:
1640            path = dlg.GetPath()
1641            self.parent.set_file_location(os.path.dirname(path))
1642        else:
1643            return None
1644        dlg.Destroy()
1645        try:
1646            if path is None:
1647                return
1648           
1649            data = self.parent.get_sld_data()
1650            fName = os.path.splitext(path)[0] + '.' + extension.split('.')[-1]
1651            if data != None:
1652                try:
1653                    reader.write(fName, data)
1654                except:
1655                    raise
1656            else:
1657                msg = "%s cannot write %s\n" % ('Generic Scattering', str(path))
1658                infor = 'Error'
1659                #logging.error(msg)
1660                if self.parent.parent != None:
1661                    # inform msg to wx
1662                    wx.PostEvent(self.parent.parent,
1663                            StatusEvent(status=msg, info=infor))
1664                    self.SetFocus()
1665            return
1666        except:
1667            msg = "Error occurred while saving. "
1668            infor = 'Error'
1669            if self.parent.parent != None:
1670                # inform msg to wx
1671                wx.PostEvent(self.parent.parent,
1672                        StatusEvent(status=msg, info=infor)) 
1673                self.SetFocus()   
1674
1675    def _onparamEnter(self, event):
1676        """
1677        """
1678        flag = True
1679        if event != None:
1680            event.Skip()
1681            ctl = event.GetEventObject()
1682            ctl.SetBackgroundColour("white")
1683            #_set_error(self, ctl)
1684        try:
1685            float(ctl.GetValue())
1686        except:
1687            flag = _set_error(self, ctl)
1688        if flag:
1689            npts = 1
1690            for item in self.nodes:
1691                n_val = float(item[1].GetValue())
1692                if n_val <= 0:
1693                    item[1].SetBackgroundColour("pink")
1694                    npts = -1
1695                    break
1696                if numpy.isfinite(n_val):
1697                    npts *= int(n_val)
1698            if npts > 0:
1699                nop = self.set_npts_from_slddata()
1700                if nop == None:
1701                    nop = npts
1702                self.display_npts(nop)
1703               
1704        ctl.Refresh()
1705        return flag
1706   
1707    def _set_volume_ctr_val(self, npts):
1708        """
1709        Set total volume
1710        """
1711        total_volume = npts * self.sld_data.vol_pix[0]
1712        self.parent.set_volume_ctr_val(total_volume)
1713                   
1714    def _onstepsize(self, event):
1715        """
1716        On stepsize event
1717        """
1718        flag = True
1719        if event != None:
1720            event.Skip()
1721            ctl = event.GetEventObject()
1722            ctl.SetBackgroundColour("white")
1723
1724        if flag and not self.sld_data.is_data:#ctl.IsEnabled():
1725            s_size = 1.0
1726            try:
1727                for item in self.stepsize:
1728                    s_val = float(item[1].GetValue())
1729                    if s_val <= 0:
1730                        item[1].SetBackgroundColour("pink")
1731                        ctl.Refresh()
1732                        return
1733                    if numpy.isfinite(s_val):
1734                        s_size *= s_val
1735                self.sld_data.set_pixel_volumes(s_size)
1736                if ctl.IsEnabled():
1737                    total_volume = sum(self.sld_data.vol_pix)
1738                    self.parent.set_volume_ctr_val(total_volume)
1739            except:
1740                pass
1741        ctl.Refresh()
1742 
1743         
1744    def set_npts_from_slddata(self):
1745        """
1746        Set total n. of points form the sld data
1747        """
1748        try:
1749            sld_data = self.parent.get_sld_from_omf()
1750            #nop = (nop * numpy.pi) / 6
1751            nop = len(sld_data.sld_n)
1752        except:
1753            nop = None
1754        return nop
1755   
1756    def display_npts(self, nop):
1757        """
1758        Displays Npts ctrl
1759        """
1760        try:
1761            self.npix_ctl.SetValue(str(nop))
1762            self.npix_ctl.Refresh()
1763            self.parent.set_etime()
1764            wx.CallAfter(self._set_volume_ctr_val, nop)
1765        except:
1766            # On Init
1767            pass
1768   
1769    def check_inputs(self):
1770        """
1771        check if the inputs are valid
1772        """
1773        flag = self._check_input_helper(self.slds)
1774        if flag:
1775            flag = self._check_input_helper(self.nodes)
1776        if flag:
1777            flag = self._check_input_helper(self.stepsize)
1778        return flag
1779   
1780    def _check_input_helper(self, list):
1781        """
1782        Check list values
1783        """
1784        flag = True
1785        for item in list:
1786            item[1].SetBackgroundColour("white")
1787            item[1].Refresh()
1788            try:
1789                float(item[1].GetValue())
1790            except:
1791                flag = _set_error(self, item[1])
1792                break
1793        return flag
1794
1795class SasGenWindow(widget.CHILD_FRAME):
1796    """
1797    GEN SAS main window
1798    """
1799    def __init__(self, parent=None, manager= None, title="Generic Scattering Calculator",
1800                size=(PANEL_WIDTH * 1.3, PANEL_HEIGHT * 1.65), *args, **kwds):
1801        """
1802        Init
1803        """
1804        kwds['size'] = size
1805        kwds['title'] = title
1806        widget.CHILD_FRAME.__init__(self, parent, *args, **kwds)
1807        self.parent = parent
1808        self.base = manager
1809        self.omfpanel = OmfPanel(parent=self)
1810        self.panel = SasGenPanel(parent=self)
1811        self.data = None
1812        self.omfdata = sans_gen.OMFData()
1813        self.sld_data = None
1814        self._default_save_location = os.getcwd() 
1815       
1816        self._mgr = aui.AuiManager(self)
1817        self._mgr.SetDockSizeConstraint(0.5, 0.5)
1818        self._plot_title = ''
1819        self.scale2d = 'log_{10}'
1820        self.Bind(wx.EVT_CLOSE, self.on_close)
1821       
1822        self._build_toolbar()
1823       
1824        self.build_panels()
1825        self.SetPosition((25, 150))
1826        self.Show(True)
1827   
1828    def _build_toolbar(self):
1829        """
1830        Build toolbar
1831        """
1832        tsize = (20, 20)
1833        tb = self.CreateToolBar(wx.TB_HORIZONTAL | wx.TB_FLAT)
1834        open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, 
1835                                            tsize)
1836        save_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE_AS, wx.ART_TOOLBAR,
1837                                            tsize)
1838        close_bmp = wx.ArtProvider.GetBitmap(wx.ART_QUIT, wx.ART_TOOLBAR, 
1839                                            tsize)
1840        help_bmp = wx.ArtProvider.GetBitmap(wx.ART_HELP, wx.ART_TOOLBAR, 
1841                                           (17, 20))
1842       
1843        id = wx.NewId()
1844        tb.AddLabelTool(id, "Open", open_bmp, shortHelp="Open", 
1845                        longHelp="Open sld/omf file")
1846        self.Bind(wx.EVT_TOOL, self.on_open_file, id=id)
1847
1848        id = wx.NewId()
1849        tb.AddSimpleTool(id, save_bmp, "Save", "Save as sld file")
1850        self.Bind(wx.EVT_TOOL, self.on_save_file, id=id)
1851       
1852        tb.AddSeparator()
1853        id = wx.NewId()
1854        tb.AddSimpleTool(id, close_bmp, "Quit", "Quit")
1855        self.Bind(wx.EVT_TOOL, self.on_close, id=id)
1856       
1857        tb.AddSeparator()
1858        id = wx.NewId()
1859        tb.AddSimpleTool(id, help_bmp, "Help", "Help")
1860        self.Bind(wx.EVT_TOOL, self.on_help, id=id)
1861
1862        tb.Realize()
1863       
1864    def _build_menubar(self):
1865        """
1866        Build menubar
1867        """
1868        tsize = (13, 13)
1869        open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, 
1870                                            tsize)
1871        save_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE_AS, wx.ART_TOOLBAR,
1872                                            tsize)
1873        quit_bmp = wx.ArtProvider.GetBitmap(wx.ART_QUIT, wx.ART_TOOLBAR, 
1874                                           tsize)
1875        help_bmp = wx.ArtProvider.GetBitmap(wx.ART_HELP, wx.ART_TOOLBAR, 
1876                                           (13, 15))
1877       
1878        menu_bar = wx.MenuBar()
1879       
1880        menu = wx.Menu()
1881        id = wx.NewId()
1882        item = wx.MenuItem(menu, id, "&Open sld/omf file")
1883        item.SetBitmap(open_bmp)
1884        menu.AppendItem(item)
1885        wx.EVT_MENU(self, id, self.on_open_file)
1886       
1887        id = wx.NewId()
1888        item = wx.MenuItem(menu, id, "&Save as sld file")
1889        item.SetBitmap(save_bmp)
1890        menu.AppendItem(item)
1891        wx.EVT_MENU(self, id, self.on_save_file)
1892       
1893        menu.AppendSeparator()
1894        id = wx.NewId()
1895        item = wx.MenuItem(menu, id, "&Quit")
1896        item.SetBitmap(quit_bmp)
1897        menu.AppendItem(item)
1898
1899        menu_bar.Append(menu, "&File")
1900        wx.EVT_MENU(self, id, self.on_close)
1901       
1902        menu_help = wx.Menu()
1903        id = wx.NewId()
1904        item = wx.MenuItem(menu_help, id, "&Theory and GUI")
1905        item.SetBitmap(help_bmp)
1906        menu_help.AppendItem(item)
1907        wx.EVT_MENU(self, id, self.on_help)
1908       
1909        menu_bar.Append(menu_help, "&Help")
1910       
1911        self.SetMenuBar(menu_bar)
1912       
1913    def build_panels(self):
1914        """
1915        """
1916       
1917        self.set_sld_data(self.sld_data)
1918       
1919        self._mgr.AddPane(self.panel, aui.AuiPaneInfo().
1920                              Name(self.panel.window_name).
1921                              CenterPane().
1922                              # This is where we set the size of
1923                              # the application window
1924                              BestSize(wx.Size(PANEL_WIDTH, 
1925                                               PANEL_HEIGHT)).
1926                              Show()) 
1927        self._mgr.AddPane(self.omfpanel, aui.AuiPaneInfo().
1928                              Name(self.omfpanel.window_name).
1929                              Caption(self.omfpanel.window_caption).
1930                              CloseButton(False).
1931                              Right().
1932                              Floatable(False).
1933                              BestSize(wx.Size(PANEL_WIDTH/2.5, PANEL_HEIGHT)).
1934                              Show()) 
1935        self._mgr.Update()
1936
1937    def get_sld_data(self):
1938        """
1939        Return slddata
1940        """
1941        return self.sld_data
1942   
1943    def get_sld_from_omf(self):
1944        """
1945        """
1946        self.sld_data = self.omfpanel.get_sld_val()
1947        return self.sld_data
1948   
1949    def set_sld_n(self, sld):
1950        """
1951        """
1952        self.panel.sld_data = sld
1953        self.panel.model.set_sld_data(sld)
1954       
1955    def set_sld_data(self, data):
1956        """
1957        Set omfdata
1958        """
1959        if data == None:
1960            return
1961        self.sld_data = data
1962        enable = (not data==None)
1963        self._set_omfpanel_sld_data(self.sld_data)
1964        self.omfpanel.bt_save.Enable(enable)
1965        self.set_etime()
1966   
1967    def set_omfpanel_npts(self):
1968        """
1969        Set Npts in omf panel
1970        """
1971        nop = self.omfpanel.set_npts_from_slddata()
1972        self.omfpanel.display_npts(nop)
1973       
1974    def _set_omfpanel_sld_data(self, data):
1975        """
1976        Set sld_data in omf panel
1977        """
1978        self.omfpanel.set_slddata(data) 
1979        self.omfpanel.set_sld_ctr(data)
1980   
1981    def check_omfpanel_inputs(self):
1982        """
1983        Check OMF panel inputs
1984        """
1985        return self.omfpanel.check_inputs() 
1986       
1987    def set_main_panel_sld_data(self, sld_data):
1988        """
1989        """
1990        self.sld_data = sld_data
1991       
1992    def set_file_location(self, path):
1993        """
1994        File location
1995        """
1996        self._default_save_location = path
1997   
1998    def get_path(self):
1999        """
2000        File location
2001        """
2002        return self._default_save_location
2003   
2004    def draw_graph(self, plot, title=''):
2005        """
2006        """
2007        try: 
2008            wx.PostEvent(self.parent, NewPlotEvent(plot=plot, title=title))
2009        except:
2010            # standalone
2011            frame = PlotFrame(self, -1, 'testView', self.scale2d)
2012            #add_icon(self.parent, frame)
2013            frame.add_plot(plot)
2014            frame.SetTitle(title)
2015            frame.Show(True)
2016            frame.SetFocus()
2017
2018    def set_schedule_full_draw(self, panel=None, func='del'): 
2019        """
2020        Send full draw to gui frame
2021        """
2022        if self.parent != None:
2023            self.parent.set_schedule_full_draw(panel, func)
2024       
2025    def get_npix(self):
2026        """
2027        Get no. of pixels from omf panel
2028        """
2029        n_pix = self.omfpanel.npix_ctl.GetValue()
2030        return n_pix
2031   
2032    def get_pix_volumes(self):
2033        """
2034        Get a pixel volume
2035        """
2036        vol = self.omfpanel.get_pix_volumes()
2037        return vol
2038   
2039    def set_volume_ctr_val(self, val):
2040        """
2041        Set volume txtctl value
2042        """
2043        try:
2044            self.panel.set_volume_ctl_val(str(val))
2045        except:
2046            print "self.panel is not initialized yet"
2047           
2048    def set_omfpanel_default_shap(self, shape):
2049        """
2050        Set default_shape in omfpanel
2051        """
2052        self.omfpanel.default_shape = shape
2053   
2054    def set_etime(self):
2055        """
2056        Sets est. computation time on panel
2057        """
2058        self.panel.set_est_time()
2059   
2060    def get_sld_data_from_omf(self):
2061        """
2062        """
2063        data = self.omfpanel.get_sld_val() 
2064        return data
2065       
2066    def set_scale2d(self, scale):
2067        """
2068        """
2069        self.scale2d = scale
2070           
2071    def on_panel_close(self, event):
2072        """
2073        """
2074        #Not implemented
2075         
2076    def on_open_file(self, event):
2077        """
2078        On Open
2079        """
2080        self.panel.on_load_data(event)
2081   
2082    def sld_draw(self):
2083        """
2084        sld draw
2085        """
2086        self.panel.sld_draw(event=None, has_arrow=False)
2087       
2088    def on_save_file(self, event):
2089        """
2090        On Close
2091        """
2092        self.omfpanel.on_save(event)
2093       
2094    def on_close(self, event):
2095        """
2096        Close
2097        """
2098        if self.base != None:
2099            self.base.gen_frame = None
2100        self.Destroy()
2101       
2102    def on_help(self, event):   
2103        """
2104        Gen scatter angle help panel
2105        """
2106        from sans.perspectives.calculator.help_panel import  HelpWindow
2107        # Get models help model_function path
2108        import sans.perspectives.calculator as calmedia
2109
2110        media = calmedia.get_data_path(media='media')
2111        path = os.path.join(media,"gen_sans_help.html") 
2112        name = "Generic Scattering Calculator"
2113        frame = HelpWindow(self, -1, 
2114                           title=' Help: GenSANS', 
2115                           pageToOpen=path, size=(865, 450))   
2116        try: 
2117            frame.splitter.DetachWindow(frame.lpanel)
2118            # Display only the right side one
2119            frame.lpanel.Hide() 
2120            frame.Show(True)
2121            add_icon(self.parent, frame)
2122        except:
2123            frame.Destroy() 
2124            msg = 'Display Error\n'
2125            info = "Info"
2126            wx.MessageBox(msg, info)
2127           
2128if __name__ == "__main__": 
2129    app = wx.PySimpleApp()
2130    widget.CHILD_FRAME = wx.Frame
2131    SGframe = SasGenWindow()   
2132    SGframe.Show(True)
2133    app.MainLoop()     
Note: See TracBrowser for help on using the repository browser.