source: sasview/invariantview/src/sans/perspectives/invariant/invariant.py @ 68c4e1f

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 68c4e1f was a60b8b6, checked in by Jae Cho <jhjcho@…>, 13 years ago

updated dataloader calls
  • Property mode set to 100644
File size: 12.6 KB
Line 
1
2
3
4################################################################################
5#This software was developed by the University of Tennessee as part of the
6#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
7#project funded by the US National Science Foundation.
8#
9#See the license text in license.txt
10#
11#copyright 2009, University of Tennessee
12################################################################################
13
14
15import sys
16import wx
17import copy
18import logging
19
20from sans.guiframe.dataFitting import Data1D
21from sans.guiframe.events import NewPlotEvent
22from sans.guiframe.gui_style import GUIFRAME_ID
23from .invariant_state import Reader as reader
24from sans.dataloader.loader import Loader
25from .invariant_panel import InvariantPanel
26from sans.guiframe.plugin_base import PluginBase
27
28class Plugin(PluginBase):
29    """
30    This class defines the interface for invariant Plugin class
31    that can be used by the gui_manager.       
32    """
33   
34    def __init__(self, standalone=False):
35        PluginBase.__init__(self, name="Invariant", standalone=standalone)
36       
37        #dictionary containing data name and error on dy of that data
38        self.err_dy = {}
39       
40        #default state objects
41        self.state_reader = None 
42        self._extensions = '.inv'
43        self.temp_state = None 
44        self.__data = None 
45       
46        # Log startup
47        logging.info("Invariant plug-in started")
48       
49    def help(self, evt):
50        """
51        Show a general help dialog.
52        """
53        from .help_panel import  HelpWindow
54        frame = HelpWindow(None, -1)   
55        frame.Show(True)
56       
57    def get_data(self):
58        """
59        """
60        return self.__data
61   
62    def get_panels(self, parent):
63        """
64        Create and return the list of wx.Panels for your plug-in.
65        Define the plug-in perspective.
66       
67        Panels should inherit from DefaultPanel defined below,
68        or should present the same interface. They must define
69        "window_caption" and "window_name".
70       
71        :param parent: parent window
72       
73        :return: list of panels
74        """
75        ## Save a reference to the parent
76        self.parent = parent
77        self.invariant_panel = InvariantPanel(parent=self.parent)
78        self.invariant_panel.set_manager(manager=self)
79        self.perspective.append(self.invariant_panel.window_name) 
80        #Create reader when fitting panel are created
81        self.state_reader = reader(self.set_state)   
82        #append that reader to list of available reader
83        loader = Loader()
84        loader.associate_file_reader(".inv", self.state_reader)
85        #loader.associate_file_reader(".svs", self.state_reader)
86        # Return the list of panels
87        return [self.invariant_panel]
88 
89    def get_context_menu(self, plotpanel=None):
90        """
91        This method is optional.
92   
93        When the context menu of a plot is rendered, the
94        get_context_menu method will be called to give you a
95        chance to add a menu item to the context menu.
96       
97        A ref to a Graph object is passed so that you can
98        investigate the plot content and decide whether you
99        need to add items to the context menu. 
100       
101        This method returns a list of menu items.
102        Each item is itself a list defining the text to
103        appear in the menu, a tool-tip help text, and a
104        call-back method.
105       
106        :param graph: the Graph object to which we attach the context menu
107       
108        :return: a list of menu items with call-back function
109        """
110        graph = plotpanel.graph
111        invariant_option = "Compute invariant"
112        invariant_hint = "Will displays the invariant panel for"
113        invariant_hint += " further computation"
114       
115        if graph.selected_plottable not in plotpanel.plots:
116            return []
117        data = plotpanel.plots[graph.selected_plottable]
118       
119        if issubclass(data.__class__, Data1D):
120           if data.name != "$I_{obs}(q)$" and  data.name != " $P_{fit}(r)$":
121               return [[invariant_option, invariant_hint, 
122                                        self._compute_invariant]]
123        return []
124
125    def _compute_invariant(self, event):   
126        """
127        Open the invariant panel to invariant computation
128        """
129        self.panel = event.GetEventObject()
130        Plugin.on_perspective(self, event=event)
131        id = self.panel.graph.selected_plottable
132        data = self.panel.plots[self.panel.graph.selected_plottable]
133        if data is None:
134            return
135        if not issubclass(data.__class__, Data1D):
136            name = data.__class__.__name__
137            msg = "Invariant use only Data1D got: [%s] " % str(name)
138            raise ValueError, msg
139        self.compute_helper(data=data)
140               
141    def set_data(self, data_list=None):
142        """
143        receive a list of data and compute invariant
144        """
145        data = None
146        if data_list is None:
147            data_list = []
148        if len(data_list) >= 1:
149            if len(data_list) == 1:
150                data = data_list[0]
151            else:
152                msg = "invariant panel does not allow multiple data!\n"
153                msg += "Please select one.\n"
154                from invariant_widgets import DataDialog
155                dlg = DataDialog(data_list=data_list, text=msg)
156                if dlg.ShowModal() == wx.ID_OK:
157                    data = dlg.get_data()
158            if data is None:
159                return
160            if issubclass(data.__class__, Data1D):
161                wx.PostEvent(self.parent, NewPlotEvent(plot=data,
162                                           title=data.title))
163                try:
164                    self.compute_helper(data)
165                except:
166                    msg = "Prview Set_data: " + str(sys.exc_value)
167                    wx.PostEvent(self.parent, StatusEvent(status=msg,
168                                                                info="error"))
169        else:   
170            msg = "invariant cannot be computed for data of "
171            msg += "type %s" % (data.__class__.__name__)
172            wx.PostEvent(self.parent, 
173                     StatusEvent(status=msg, info='error'))
174    def delete_data(self, data_id):
175        """
176        """
177        if self.__data is None:
178            return
179        for id in data_id:
180            if id == self.__data.id:
181                self.clear_panel()
182               
183    def clear_panel(self):
184        """
185        """
186        self.invariant_panel.clear_panel()
187       
188    def compute_helper(self, data):
189        """
190        """
191        if data is None:
192            return 
193        # set current data if not it's a state data
194        if not self.invariant_panel.is_state_data:
195            # Store reference to data
196            self.__data = data
197            # Set the data set to be user for invariant calculation
198            self.invariant_panel.set_data(data=data)
199           
200    def save_file(self, filepath, state=None):
201        """
202        Save data in provided state object.
203               
204        :param filepath: path of file to write to
205        :param state: invariant state
206        """     
207        # Write the state to file
208        # First, check that the data is of the right type
209        current_plottable = self.__data
210
211        if issubclass(current_plottable.__class__, Data1D):
212            self.state_reader.write(filepath, current_plottable, state)
213        else:
214            msg = "invariant.save_file: the data being saved is"
215            msg += " not a sans.dataloader.data_info.Data1D object" 
216            raise RuntimeError, msg
217
218    def set_state(self, state=None, datainfo=None):   
219        """
220        Call-back method for the state reader.
221        This method is called when a .inv/.svs file is loaded.
222       
223        :param state: State object
224        """
225        self.temp_state = None
226        try:
227            if datainfo.__class__.__name__ == 'list':
228                data = datainfo[0]
229            else:
230                data = datainfo
231            if data is None:
232                msg = "invariant.set_state: datainfo parameter cannot"
233                msg += " be None in standalone mode"
234                raise RuntimeError, msg
235            # Make sure the user sees the invariant panel after loading
236            #self.parent.set_perspective(self.perspective)
237            self.on_perspective(event=None)
238            name = data.meta_data['invstate'].file
239            data.meta_data['invstate'].file = name
240            data.name = name
241            data.filename = name
242
243            data = self.parent.create_gui_data(data,None)
244            self.__data = data
245            wx.PostEvent(self.parent, NewPlotEvent(plot=self.__data,
246                                        reset=True, title=self.__data.title))
247            data_dict = {self.__data.id:self.__data}
248            self.parent.add_data(data_list=data_dict)
249            # set state
250            self.invariant_panel.is_state_data = True
251           
252            # Load the invariant states
253            self.temp_state = state
254            # Requires to have self.__data and self.temp_state  first.
255            self.on_set_state_helper(None)
256
257        except: 
258            logging.error("invariant.set_state: %s" % sys.exc_value)
259           
260    def on_set_state_helper(self, event=None):
261        """
262        Set the state when called by EVT_STATE_UPDATE event from guiframe
263        after a .inv/.svs file is loaded
264        """
265        self.invariant_panel.set_state(state=self.temp_state,
266                                       data=self.__data)
267        self.temp_state = None
268       
269       
270    def plot_theory(self, data=None, name=None):
271        """
272        Receive a data set and post a NewPlotEvent to parent.
273       
274        :param data: extrapolated data to be plotted
275        :param name: Data's name to use for the legend
276        """
277        #import copy
278        if data is None:
279            id = str(self.__data.id) + name
280            group_id = self.__data.group_id
281            wx.PostEvent(self.parent, NewPlotEvent(id=id,
282                                               group_id=group_id,
283                                               action='Remove'))
284            return
285   
286        new_plot = Data1D(x=[], y=[], dy=None)
287        new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
288        scale = self.invariant_panel.get_scale()
289        background = self.invariant_panel.get_background()
290       
291        if scale != 0:
292            # Put back the sacle and bkg for plotting
293            data.y = (data.y + background)/scale
294            new_plot = Data1D(x=data.x, y=data.y, dy=None)
295            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
296        else:
297            msg = "Scale can not be zero."
298            raise ValueError, msg
299        if len(new_plot.x)== 0 :
300            return
301       
302        new_plot.name = name
303        new_plot.xaxis(self.__data._xaxis, self.__data._xunit)
304        new_plot.yaxis(self.__data._yaxis, self.__data._yunit)
305        new_plot.group_id = self.__data.group_id
306        new_plot.id = str(self.__data.id) + name
307        new_plot.title = self.__data.title
308        # Save theory_data in a state
309        if data != None:
310            name_head = name.split('-')
311            if name_head[0] == 'Low':
312                self.invariant_panel.state.theory_lowQ = copy.deepcopy(new_plot)
313            elif name_head[0] == 'High':
314                self.invariant_panel.state.theory_highQ =copy.deepcopy(new_plot)
315           
316        self.parent.update_theory(data_id=self.__data.id, theory=new_plot)
317        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
318                                               title=self.__data.title))
319       
320    def plot_data(self, scale, background):
321        """
322        replot the current data if the user enters a new scale or background
323        """
324        new_plot = scale * self.__data - background
325        new_plot.name = self.__data.name
326        new_plot.group_id = self.__data.group_id
327        new_plot.id = self.__data.id
328        new_plot.title = self.__data.title
329       
330        # Save data in a state: but seems to never happen
331        if new_plot != None:
332            self.invariant_panel.state.data = copy.deepcopy(new_plot)
333        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
334                                               title=new_plot.title))
335       
Note: See TracBrowser for help on using the repository browser.