source: sasview/src/sas/sasgui/guiframe/data_manager.py @ 959eb01

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.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 959eb01 was 959eb01, checked in by ajj, 3 years ago

normalising line endings

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