source: sasview/src/sas/perspectives/calculator/gen_scatter_panel.py @ d5419f7f

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 d5419f7f was d5419f7f, checked in by butler, 5 years ago
  • Fixed problem with mac vs pc positioning of tool panels for now -

opened ticket to completely rethink panels in mac vs pc

  • Added close button/activated close method for tool panels that did not

have it. Tool panels are now much more consistant.

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