Ignore:
Timestamp:
May 26, 2017 7:41:44 AM (7 years ago)
Author:
Piotr Rozyczko <rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
c1e380e
Parents:
6964d44 (diff), 7132e49 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ESS_GUI

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/guiframe/data_manager.py

    r630155bd rc416a17  
    22#This software was developed by the University of Tennessee as part of the 
    33#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    4 #project funded by the US National Science Foundation. 
     4#project funded by the US National Science Foundation.  
    55# 
    66#See the license text in license.txt 
    … …  
    99################################################################################ 
    1010""" 
    11 This module manages all data loaded into the application. Data_manager makes 
    12 available all data loaded  for the current perspective. 
    13  
    14 All modules "creating Data" posts their data to data_manager . 
     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 .  
    1515Data_manager  make these new data available for all other perspectives. 
    1616""" 
     17import logging 
    1718import os 
    18 import copy 
    19 import logging 
    20 import json 
    21 from StringIO import StringIO 
     19import copy  
    2220 
    2321from sas.sasgui.guiframe.data_state import DataState 
    … …  
    2826import time 
    2927 
    30 # used for import/export 
    31 import numpy as np 
    32 from sas.sascalc.dataloader.data_info import Sample, Source, Vector 
    33 from sas.sasgui.plottools.plottables import Plottable, Theory1D, Fit1D, Text, Chisq, View 
     28logger = logging.getLogger(__name__) 
    3429 
    3530class DataManager(object): 
    … …  
    4035        """ 
    4136        Store opened path and data object created at the loading time 
    42         :param auto_plot: if True the datamanager sends data to plotting 
    43                             plugin. 
     37        :param auto_plot: if True the datamanager sends data to plotting  
     38                            plugin.  
    4439        :param auto_set_data: if True the datamanager sends to the current 
    4540        perspective 
    … …  
    5752        n_count = 0 
    5853        for  value in self.stored_data.values(): 
    59             n_count += 1 
     54            n_count += 1  
    6055            _str += "State No %s \n"  % str(n_count) 
    6156            _str += str(value) + "\n" 
    6257        return _str 
    63  
     58         
    6459    def create_gui_data(self, data, path=None): 
    6560        """ 
    6661        Receive data from loader and create a data to use for guiframe 
    6762        """ 
    68  
     63         
    6964        if issubclass(Data2D, data.__class__): 
    70             new_plot = Data2D(image=None, err_image=None) 
    71         else: 
    72             new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
     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??? 
    7374 
    7475        new_plot.copy_from_datainfo(data) 
    … …  
    8990        if title.strip() == "": 
    9091            title = file_name 
    91  
     92         
    9293        if new_plot.filename.strip() == "": 
    9394            new_plot.filename = file_name 
    94  
     95         
    9596        new_plot.name = name 
    9697        new_plot.title = title 
    … …  
    115116        ## name of the data allow to differentiate data when plotted 
    116117        name = parse_name(name=name, expression="_") 
    117  
    118118        max_char = name.find("[") 
    119119        if max_char < 0: 
    120120            max_char = len(name) 
    121121        name = name[0:max_char] 
    122  
    123122        if name not in self.data_name_dict: 
    124123            self.data_name_dict[name] = 0 
    … …  
    127126            name = name + " [" + str(self.data_name_dict[name]) + "]" 
    128127        return name 
    129  
    130  
     128     
     129   
    131130    def add_data(self, data_list): 
    132131        """ 
    133         receive a list of 
     132        receive a list of  
    134133        """ 
    135134        for id, data in data_list.iteritems(): 
    … …  
    137136                msg = "Data manager already stores %s" % str(data.name) 
    138137                msg += "" 
    139                 logging.info(msg) 
     138                logger.info(msg) 
    140139                data_state = self.stored_data[id] 
    141140                data_state.data = data 
    … …  
    151150        if prev_data.id not in self.stored_data.keys(): 
    152151            return None, {} 
    153         data_state = self.stored_data[prev_data.id] 
     152        data_state = self.stored_data[prev_data.id]  
    154153        self.stored_data[new_data.id]  = data_state.clone() 
    155154        self.stored_data[new_data.id].data = new_data 
    156155        if prev_data.id in self.stored_data.keys(): 
    157             del self.stored_data[prev_data.id] 
     156            del self.stored_data[prev_data.id]  
    158157        return prev_data.id, {new_data.id: self.stored_data[new_data.id]} 
    159  
     158     
    160159    def update_theory(self, theory, data_id=None, state=None): 
    161160        """ 
    … …  
    165164            uid = theory.id 
    166165        if uid in self.stored_data.keys(): 
    167              data_state = self.stored_data[uid] 
     166             data_state = self.stored_data[uid]  
    168167        else: 
    169168            data_state = DataState() 
    … …  
    172171        self.stored_data[uid] = data_state 
    173172        return {uid: self.stored_data[uid]} 
    174  
    175173 
    176174    def get_message(self): 
    … …  
    196194                if search_id in theory_list.keys(): 
    197195                     _selected_theory_list[search_id] = theory_list[search_id] 
    198  
     196                    
    199197        return _selected_data, _selected_theory_list 
    200  
    201  
     198    
     199            
    202200    def freeze(self, theory_id): 
    203201        """ 
    … …  
    229227        return selected_theory 
    230228 
    231  
    232229    def delete_data(self, data_id, theory_id=None, delete_all=False): 
    233230        """ 
    … …  
    239236                    del self.data_name_dict[data_state.data.name] 
    240237                del self.stored_data[d_id] 
    241  
    242238        self.delete_theory(data_id, theory_id) 
    243239        if delete_all: 
    … …  
    264260            if id in self.stored_data: 
    265261                del self.stored_data[id] 
    266  
    267262 
    268263    def get_by_name(self, name_list=None): 
    … …  
    301296        """ 
    302297        return self.stored_data 
    303  
    304     def assign(self, other): 
    305         self.stored_data = other.stored_data 
    306         self.message = other.message 
    307         self.data_name_dict = other.data_name_dict 
    308         self.count = other.count 
    309         self.list_of_id = other.list_of_id 
    310         self.time_stamp = other.time_stamp 
    311  
    312     def save_to_writable(self, fp): 
    313         """ 
    314         save content of stored_data to fp (a .write()-supporting file-like object) 
    315         """ 
    316  
    317         def add_type(dict, type): 
    318             dict['__type__'] = type.__name__ 
    319             return dict 
    320  
    321         def jdefault(o): 
    322             """ 
    323             objects that can't otherwise be serialized need to be converted 
    324             """ 
    325             # tuples and sets (TODO: default JSONEncoder converts tuples to lists, create custom Encoder that preserves tuples) 
    326             if isinstance(o, (tuple, set)): 
    327                 content = { 'data': list(o) } 
    328                 return add_type(content, type(o)) 
    329  
    330             # "simple" types 
    331             if isinstance(o, (Sample, Source, Vector)): 
    332                 return add_type(o.__dict__, type(o)) 
    333             if isinstance(o, (Plottable, View)): 
    334                 return add_type(o.__dict__, type(o)) 
    335  
    336             # DataState 
    337             if isinstance(o, DataState): 
    338                 # don't store parent 
    339                 content = o.__dict__.copy() 
    340                 content.pop('parent') 
    341                 return add_type(content, type(o)) 
    342  
    343             # ndarray 
    344             if isinstance(o, np.ndarray): 
    345                 buffer = StringIO() 
    346                 np.save(buffer, o) 
    347                 buffer.seek(0) 
    348                 content = { 'data': buffer.read().decode('latin-1') } 
    349                 return add_type(content, type(o)) 
    350  
    351             # not supported 
    352             logging.info("data cannot be serialized to json: %s" % type(o)) 
    353             return None 
    354  
    355         json.dump(self.stored_data, fp, indent=2, sort_keys=True, default=jdefault) 
    356  
    357  
    358     def load_from_readable(self, fp): 
    359         """ 
    360         load content from tp to stored_data (a .read()-supporting file-like object) 
    361         """ 
    362  
    363         supported = [ 
    364             tuple, set, 
    365             Sample, Source, Vector, 
    366             Plottable, Data1D, Data2D, Theory1D, Fit1D, Text, Chisq, View, 
    367             DataState, np.ndarray] 
    368  
    369         lookup = dict((cls.__name__, cls) for cls in supported) 
    370  
    371         class TooComplexException(Exception): 
    372             pass 
    373  
    374         def simple_type(cls, data, level): 
    375             class Empty(object): 
    376                 def __init__(self): 
    377                     for key, value in data.iteritems(): 
    378                         setattr(self, key, generate(value, level)) 
    379  
    380             # create target object 
    381             o = Empty() 
    382             o.__class__ = cls 
    383  
    384             return o 
    385  
    386         def construct(type, data, level): 
    387             try: 
    388                 cls = lookup[type] 
    389             except KeyError: 
    390                 logging.info('unknown type: %s' % type) 
    391                 return None 
    392  
    393             # tuples and sets 
    394             if cls in (tuple, set): 
    395                 # convert list to tuple/set 
    396                 return cls(generate(data['data'], level)) 
    397  
    398             # "simple" types 
    399             if cls in (Sample, Source, Vector): 
    400                 return simple_type(cls, data, level) 
    401             if issubclass(cls, Plottable) or (cls == View): 
    402                 return simple_type(cls, data, level) 
    403  
    404             # DataState 
    405             if cls == DataState: 
    406                 o = simple_type(cls, data, level) 
    407                 o.parent = None # TODO: set to ??? 
    408                 return o 
    409  
    410             # ndarray 
    411             if cls == np.ndarray: 
    412                 buffer = StringIO() 
    413                 buffer.write(data['data'].encode('latin-1')) 
    414                 buffer.seek(0) 
    415                 return np.load(buffer) 
    416  
    417             logging.info('not implemented: %s, %s' % (type, cls)) 
    418             return None 
    419  
    420         def generate(data, level): 
    421             if level > 16: # recursion limit (arbitrary number) 
    422                 raise TooComplexException() 
    423             else: 
    424                 level += 1 
    425  
    426             if isinstance(data, dict): 
    427                 try: 
    428                     type = data['__type__'] 
    429                 except KeyError: 
    430                     # if dictionary doesn't have __type__ then it is assumed to be just an ordinary dictionary 
    431                     o = {} 
    432                     for key, value in data.iteritems(): 
    433                         o[key] = generate(value, level) 
    434                     return o 
    435  
    436                 return construct(type, data, level) 
    437  
    438             if isinstance(data, list): 
    439                 return [generate(item, level) for item in data] 
    440  
    441             return data 
    442  
    443         new_stored_data = {} 
    444         for id, data in json.load(fp).iteritems(): 
    445             try: 
    446                 new_stored_data[id] = generate(data, 0) 
    447             except TooComplexException: 
    448                 logging.info('unable to load %s' % id) 
    449  
    450         self.stored_data = new_stored_data 
Note: See TracChangeset for help on using the changeset viewer.