source: sasview/src/sas/sasgui/guiframe/data_manager.py @ 2ffe241

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 2ffe241 was 2ffe241, checked in by krzywon, 7 years ago

Fix issues with loading 2D data in the SESANS branch and always set isSesans to False when working with 2D.

  • Property mode set to 100644
File size: 10.5 KB
Line 
1################################################################################
2#This software was developed by the University of Tennessee as part of the
3#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
4#project funded by the US National Science Foundation.
5#
6#See the license text in license.txt
7#
8#copyright 2010, University of Tennessee
9################################################################################
10"""
11This module manages all data loaded into the application. Data_manager makes
12available all data loaded  for the current perspective.
13
14All modules "creating Data" posts their data to data_manager .
15Data_manager  make these new data available for all other perspectives.
16"""
17import logging
18import os
19import copy 
20
21from sas.sasgui.guiframe.data_state import DataState
22from sas.sasgui.guiframe.utils import parse_name
23import sas.sascalc.dataloader.data_info as DataInfo
24from sas.sasgui.guiframe.dataFitting import Data1D
25from sas.sasgui.guiframe.dataFitting import Data2D
26import time
27
28class DataManager(object):
29    """
30    Manage a list of data
31    """
32    def __init__(self):
33        """
34        Store opened path and data object created at the loading time
35        :param auto_plot: if True the datamanager sends data to plotting
36                            plugin.
37        :param auto_set_data: if True the datamanager sends to the current
38        perspective
39        """
40        self.stored_data = {}
41        self.message = ""
42        self.data_name_dict = {}
43        self.count = 0
44        self.list_of_id = []
45        self.time_stamp = time.time()
46     
47    def __str__(self):
48        _str  = ""
49        _str += "No of states  is %s \n" % str(len(self.stored_data))
50        n_count = 0
51        for  value in self.stored_data.values():
52            n_count += 1 
53            _str += "State No %s \n"  % str(n_count)
54            _str += str(value) + "\n"
55        return _str
56       
57    def create_gui_data(self, data, path=None):
58        """
59        Receive data from loader and create a data to use for guiframe
60        """
61       
62        if issubclass(Data2D, data.__class__):
63            new_plot = Data2D(image=None, err_image=None) # For now, isSesans for 2D data is always false
64        else:
65            new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None, isSesans=data.isSesans)
66
67
68        #elif data.meta_data['loader'] == 'SESANS':
69        #    new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None, isSesans=True)
70        #else:
71        #    new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None) #SESANS check???
72
73        new_plot.copy_from_datainfo(data)
74        data.clone_without_data(clone=new_plot)
75        #creating a name for data
76        title = ""
77        file_name = os.path.basename(path) if path is not None else data.filename
78        if file_name:
79            name = file_name
80        elif data.run:
81            name = data.run[0]
82        else:
83            name = "data"
84        name = self.rename(name)
85        #find title
86        if data.title.strip():
87            title = data.title
88        if title.strip() == "":
89            title = file_name
90       
91        if new_plot.filename.strip() == "":
92            new_plot.filename = file_name
93       
94        new_plot.name = name
95        new_plot.title = title
96        ## allow to highlight data when plotted
97        new_plot.interactive = True
98        ## when 2 data have the same id override the 1 st plotted
99        self.time_stamp += 1
100        new_plot.id = str(name) + str(self.time_stamp)
101        ##group_id specify on which panel to plot this data
102        new_plot.group_id = str(name) + str(self.time_stamp)
103        new_plot.is_data = True
104        new_plot.path = path
105        new_plot.list_group_id = []
106        ##post data to plot
107        # plot data
108        return new_plot
109 
110    def rename(self, name):
111        """
112        rename data
113        """
114        ## name of the data allow to differentiate data when plotted
115        name = parse_name(name=name, expression="_")
116       
117        max_char = name.find("[")
118        if max_char < 0:
119            max_char = len(name)
120        name = name[0:max_char]
121       
122        if name not in self.data_name_dict:
123            self.data_name_dict[name] = 0
124        else:
125            self.data_name_dict[name] += 1
126            name = name + " [" + str(self.data_name_dict[name]) + "]"
127        return name
128   
129 
130    def add_data(self, data_list):
131        """
132        receive a list of
133        """
134        for id, data in data_list.iteritems():
135            if id  in self.stored_data:
136                msg = "Data manager already stores %s" % str(data.name)
137                msg += ""
138                logging.info(msg)
139                data_state = self.stored_data[id]
140                data_state.data = data
141            else:
142                data_state = DataState(data)
143                data_state.id = id
144                data_state.path = data.path
145                self.stored_data[id] = data_state
146   
147    def update_data(self, prev_data, new_data):
148        """
149        """
150        if prev_data.id not in self.stored_data.keys():
151            return None, {}
152        data_state = self.stored_data[prev_data.id] 
153        self.stored_data[new_data.id]  = data_state.clone()
154        self.stored_data[new_data.id].data = new_data
155        if prev_data.id in self.stored_data.keys():
156            del self.stored_data[prev_data.id] 
157        return prev_data.id, {new_data.id: self.stored_data[new_data.id]}
158   
159    def update_theory(self, theory, data_id=None, state=None):
160        """
161        """
162        uid = data_id
163        if data_id is None and theory is not None:
164            uid = theory.id
165        if uid in self.stored_data.keys():
166             data_state = self.stored_data[uid] 
167        else:
168            data_state = DataState()
169        data_state.uid = uid
170        data_state.set_theory(theory_data=theory, theory_state=state)
171        self.stored_data[uid] = data_state
172        return {uid: self.stored_data[uid]}
173       
174   
175    def get_message(self):
176        """
177        return message
178        """
179        return self.message
180   
181    def get_by_id(self, id_list=None):
182        """
183        """
184        _selected_data = {}
185        _selected_theory_list = {}
186        if id_list is None:
187            return
188        for d_id in self.stored_data:
189            for search_id in id_list:
190                data_state = self.stored_data[d_id]
191                data = data_state.data
192                theory_list = data_state.get_theory()
193                if search_id == d_id:
194                    _selected_data[search_id] = data
195                if search_id in theory_list.keys():
196                     _selected_theory_list[search_id] = theory_list[search_id]
197                   
198        return _selected_data, _selected_theory_list
199   
200           
201    def freeze(self, theory_id):
202        """
203        """
204        return self.freeze_theory(self.stored_data.keys(), theory_id)
205       
206    def freeze_theory(self, data_id, theory_id):
207        """
208        """
209        selected_theory = {}
210        for d_id in data_id:
211            if d_id in self.stored_data:
212                data_state = self.stored_data[d_id]
213                theory_list = data_state.get_theory()
214                for t_id in theory_id:
215                    if t_id in theory_list.keys():
216                        theory_data, theory_state = theory_list[t_id]
217                        new_theory = copy.deepcopy(theory_data)
218                        new_theory.id  = time.time()
219                        new_theory.is_data = True
220                        new_theory.name += '_@' + \
221                                    str(new_theory.id)[7:-1].replace('.', '')
222                        new_theory.title = new_theory.name
223                        new_theory.label = new_theory.name
224                        selected_theory[new_theory.id] = DataState(new_theory)
225                        self.stored_data[new_theory.id] = \
226                                    selected_theory[new_theory.id]
227
228        return selected_theory
229                   
230           
231    def delete_data(self, data_id, theory_id=None, delete_all=False):
232        """
233        """
234        for d_id in data_id:
235            if d_id in self.stored_data.keys():
236                data_state = self.stored_data[d_id]
237                if data_state.data.name in self.data_name_dict:
238                    del self.data_name_dict[data_state.data.name]
239                del self.stored_data[d_id]
240       
241        self.delete_theory(data_id, theory_id)
242        if delete_all:
243            self.stored_data = {}
244            self.data_name_dict = {}
245           
246    def delete_theory(self, data_id, theory_id):
247        """
248        """
249        for d_id in data_id:
250            if d_id in self.stored_data:
251                data_state = self.stored_data[d_id]
252                theory_list = data_state.get_theory()
253                if theory_id in theory_list.keys():
254                    del theory_list[theory_id]
255        #del pure theory
256        self.delete_by_id(theory_id)
257           
258    def delete_by_id(self, id_list=None):
259        """
260        save data and path
261        """
262        for id in id_list:
263            if id in self.stored_data:
264                del self.stored_data[id]
265         
266   
267    def get_by_name(self, name_list=None):
268        """
269        return a list of data given a list of data names
270        """
271        _selected_data = {}
272        for selected_name in name_list:
273            for id, data_state in self.stored_data.iteritems():
274                if data_state.data.name == selected_name:
275                    _selected_data[id] = data_state.data
276        return _selected_data
277   
278    def delete_by_name(self, name_list=None):
279        """
280        save data and path
281        """
282        for selected_name in name_list:
283            for id, data_state in self.stored_data.iteritems():
284                if data_state.data.name == selected_name:
285                    del self.stored_data[id]
286
287    def get_data_state(self, data_id):
288        """
289        Send list of selected data
290        """
291        _selected_data_state = {}
292        for id in data_id:
293            if id in self.stored_data.keys():
294                _selected_data_state[id] = self.stored_data[id]
295        return _selected_data_state
296   
297    def get_all_data(self):
298        """
299        return list of all available data
300        """
301        return self.stored_data
302   
303
304       
Note: See TracBrowser for help on using the repository browser.